From 8483be6bcbc3bff4b76e8f4eb3502f1b197437ef Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 31 Oct 2024 04:03:43 +0000
Subject: [PATCH 1/2] Bump activerecord from 7.1.3.4 to 7.2.2

Bumps [activerecord](https://github.com/rails/rails) from 7.1.3.4 to 7.2.2.
- [Release notes](https://github.com/rails/rails/releases)
- [Changelog](https://github.com/rails/rails/blob/v7.2.2/activerecord/CHANGELOG.md)
- [Commits](https://github.com/rails/rails/compare/v7.1.3.4...v7.2.2)

---
updated-dependencies:
- dependency-name: activerecord
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 Gemfile.lock | 56 +++++++++++++++++++++++++++++-----------------------
 1 file changed, 31 insertions(+), 25 deletions(-)

diff --git a/Gemfile.lock b/Gemfile.lock
index 261e377b..265d46c4 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -15,38 +15,41 @@ GIT
 GEM
   remote: http://rubygems.org/
   specs:
-    actionpack (7.1.3.4)
-      actionview (= 7.1.3.4)
-      activesupport (= 7.1.3.4)
+    actionpack (7.2.2)
+      actionview (= 7.2.2)
+      activesupport (= 7.2.2)
       nokogiri (>= 1.8.5)
       racc
-      rack (>= 2.2.4)
+      rack (>= 2.2.4, < 3.2)
       rack-session (>= 1.0.1)
       rack-test (>= 0.6.3)
       rails-dom-testing (~> 2.2)
       rails-html-sanitizer (~> 1.6)
-    actionview (7.1.3.4)
-      activesupport (= 7.1.3.4)
+      useragent (~> 0.16)
+    actionview (7.2.2)
+      activesupport (= 7.2.2)
       builder (~> 3.1)
       erubi (~> 1.11)
       rails-dom-testing (~> 2.2)
       rails-html-sanitizer (~> 1.6)
-    activemodel (7.1.3.4)
-      activesupport (= 7.1.3.4)
-    activerecord (7.1.3.4)
-      activemodel (= 7.1.3.4)
-      activesupport (= 7.1.3.4)
+    activemodel (7.2.2)
+      activesupport (= 7.2.2)
+    activerecord (7.2.2)
+      activemodel (= 7.2.2)
+      activesupport (= 7.2.2)
       timeout (>= 0.4.0)
-    activesupport (7.1.3.4)
+    activesupport (7.2.2)
       base64
+      benchmark (>= 0.3)
       bigdecimal
-      concurrent-ruby (~> 1.0, >= 1.0.2)
+      concurrent-ruby (~> 1.0, >= 1.3.1)
       connection_pool (>= 2.2.5)
       drb
       i18n (>= 1.6, < 2)
+      logger (>= 1.4.2)
       minitest (>= 5.1)
-      mutex_m
-      tzinfo (~> 2.0)
+      securerandom (>= 0.3)
+      tzinfo (~> 2.0, >= 2.0.5)
     addressable (2.4.0)
     ancestry (4.3.3)
       activerecord (>= 5.2.6)
@@ -56,12 +59,13 @@ GEM
       thor (>= 0.14.0)
     ast (2.4.2)
     base64 (0.2.0)
+    benchmark (0.3.0)
     bigdecimal (3.1.8)
     builder (3.3.0)
     coderay (1.1.3)
     commander (4.6.0)
       highline (~> 2.0.0)
-    concurrent-ruby (1.3.3)
+    concurrent-ruby (1.3.4)
     connection_pool (2.4.1)
     coveralls_reborn (0.28.0)
       simplecov (~> 0.22.0)
@@ -88,11 +92,11 @@ GEM
       oauth2 (~> 1.0)
     hashie (5.0.0)
     highline (2.0.3)
-    i18n (1.14.5)
+    i18n (1.14.6)
       concurrent-ruby (~> 1.0)
     io-console (0.7.2)
-    irb (1.12.0)
-      rdoc
+    irb (1.14.1)
+      rdoc (>= 4.0.0)
       reline (>= 0.4.2)
     jeweler (2.3.9)
       builder
@@ -110,17 +114,17 @@ GEM
     kramdown (2.4.0)
       rexml
     language_server-protocol (3.17.0.3)
+    logger (1.6.1)
     loofah (2.22.0)
       crass (~> 1.0.2)
       nokogiri (>= 1.12.0)
     method_source (1.0.0)
     mime-types (2.99.3)
-    minitest (5.24.1)
+    minitest (5.25.1)
     mize (0.6.0)
     multi_json (1.15.0)
     multi_xml (0.6.0)
     multipart-post (2.3.0)
-    mutex_m (0.2.0)
     netrc (0.11.0)
     nokogiri (1.16.7-x86_64-darwin)
       racc (~> 1.4)
@@ -165,10 +169,10 @@ GEM
     rails-html-sanitizer (1.6.0)
       loofah (~> 2.21)
       nokogiri (~> 1.14)
-    railties (7.1.3.4)
-      actionpack (= 7.1.3.4)
-      activesupport (= 7.1.3.4)
-      irb
+    railties (7.2.2)
+      actionpack (= 7.2.2)
+      activesupport (= 7.2.2)
+      irb (~> 1.13)
       rackup (>= 1.0.0)
       rake (>= 12.2)
       thor (~> 1.0, >= 1.2.2)
@@ -217,6 +221,7 @@ GEM
       rubocop (>= 1)
     ruby-progressbar (1.13.0)
     safe_type (1.1.1)
+    securerandom (0.3.1)
     semver2 (3.4.2)
     simplecov (0.22.0)
       docile (~> 1.1)
@@ -272,6 +277,7 @@ GEM
     unparser (0.6.15)
       diff-lcs (~> 1.3)
       parser (>= 3.3.0)
+    useragent (0.16.10)
     webrick (1.8.1)
     yard (0.9.36)
     yard-sorbet (0.9.0)

From b1759e44345c4af4fb01415eefc0bac4ff6b8b30 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <dependabot[bot]@users.noreply.github.com>
Date: Thu, 31 Oct 2024 04:04:57 +0000
Subject: [PATCH 2/2] Update RBIs [dependabot skip]

---
 ...npack@7.1.3.4.rbi => actionpack@7.2.2.rbi} | 281 ++++--
 ...nview@7.1.3.4.rbi => actionview@7.2.2.rbi} | 446 ++++-----
 ...odel@7.1.3.4.rbi => activemodel@7.2.2.rbi} |  76 +-
 ...ord@7.1.3.4.rbi => activerecord@7.2.2.rbi} | 859 +++++++++++-------
 ...rt@7.1.3.4.rbi => activesupport@7.2.2.rbi} | 322 ++++---
 sorbet/rbi/gems/benchmark@0.3.0.rbi           |  69 ++
 ...by@1.3.3.rbi => concurrent-ruby@1.3.4.rbi} |   4 +
 .../gems/{i18n@1.14.5.rbi => i18n@1.14.6.rbi} |   1 +
 sorbet/rbi/gems/logger@1.6.1.rbi              | 114 +++
 ...initest@5.24.1.rbi => minitest@5.25.1.rbi} |   2 +-
 sorbet/rbi/gems/mutex_m@0.2.0.rbi             |  29 -
 ...ailties@7.1.3.4.rbi => railties@7.2.2.rbi} | 120 ++-
 sorbet/rbi/gems/securerandom@0.3.1.rbi        |  49 +
 sorbet/rbi/gems/useragent@0.16.10.rbi         |   9 +
 14 files changed, 1440 insertions(+), 941 deletions(-)
 rename sorbet/rbi/gems/{actionpack@7.1.3.4.rbi => actionpack@7.2.2.rbi} (95%)
 rename sorbet/rbi/gems/{actionview@7.1.3.4.rbi => actionview@7.2.2.rbi} (88%)
 rename sorbet/rbi/gems/{activemodel@7.1.3.4.rbi => activemodel@7.2.2.rbi} (95%)
 rename sorbet/rbi/gems/{activerecord@7.1.3.4.rbi => activerecord@7.2.2.rbi} (94%)
 rename sorbet/rbi/gems/{activesupport@7.1.3.4.rbi => activesupport@7.2.2.rbi} (95%)
 create mode 100644 sorbet/rbi/gems/benchmark@0.3.0.rbi
 rename sorbet/rbi/gems/{concurrent-ruby@1.3.3.rbi => concurrent-ruby@1.3.4.rbi} (99%)
 rename sorbet/rbi/gems/{i18n@1.14.5.rbi => i18n@1.14.6.rbi} (99%)
 create mode 100644 sorbet/rbi/gems/logger@1.6.1.rbi
 rename sorbet/rbi/gems/{minitest@5.24.1.rbi => minitest@5.25.1.rbi} (99%)
 delete mode 100644 sorbet/rbi/gems/mutex_m@0.2.0.rbi
 rename sorbet/rbi/gems/{railties@7.1.3.4.rbi => railties@7.2.2.rbi} (93%)
 create mode 100644 sorbet/rbi/gems/securerandom@0.3.1.rbi
 create mode 100644 sorbet/rbi/gems/useragent@0.16.10.rbi

diff --git a/sorbet/rbi/gems/actionpack@7.1.3.4.rbi b/sorbet/rbi/gems/actionpack@7.2.2.rbi
similarity index 95%
rename from sorbet/rbi/gems/actionpack@7.1.3.4.rbi
rename to sorbet/rbi/gems/actionpack@7.2.2.rbi
index 685c3f7f..b8fde7f4 100644
--- a/sorbet/rbi/gems/actionpack@7.1.3.4.rbi
+++ b/sorbet/rbi/gems/actionpack@7.2.2.rbi
@@ -4,6 +4,7 @@
 # This is an autogenerated file for types exported from the `actionpack` gem.
 # Please instead update this file by running `bin/tapioca gem actionpack`.
 
+
 module AbstractController
   extend ::ActiveSupport::Autoload
 
@@ -41,7 +42,7 @@ class AbstractController::Base
   def formats=(_arg0); end
   def inspect; end
   def performed?; end
-  def process(action, *args, **_arg2); end
+  def process(action, *_arg1, **_arg2, &_arg3); end
   def response_body; end
   def response_body=(_arg0); end
   def send_action(*_arg0); end
@@ -205,45 +206,45 @@ module AbstractController::Callbacks::ClassMethods
 end
 
 module AbstractController::Collector
-  def atom(*args, **_arg1, &block); end
-  def bmp(*args, **_arg1, &block); end
-  def css(*args, **_arg1, &block); end
-  def csv(*args, **_arg1, &block); end
-  def gif(*args, **_arg1, &block); end
-  def gzip(*args, **_arg1, &block); end
-  def html(*args, **_arg1, &block); end
-  def ics(*args, **_arg1, &block); end
-  def jpeg(*args, **_arg1, &block); end
-  def js(*args, **_arg1, &block); end
-  def json(*args, **_arg1, &block); end
-  def m4a(*args, **_arg1, &block); end
-  def mp3(*args, **_arg1, &block); end
-  def mp4(*args, **_arg1, &block); end
-  def mpeg(*args, **_arg1, &block); end
-  def multipart_form(*args, **_arg1, &block); end
-  def ogg(*args, **_arg1, &block); end
-  def otf(*args, **_arg1, &block); end
-  def pdf(*args, **_arg1, &block); end
-  def png(*args, **_arg1, &block); end
-  def rss(*args, **_arg1, &block); end
-  def svg(*args, **_arg1, &block); end
-  def text(*args, **_arg1, &block); end
-  def tiff(*args, **_arg1, &block); end
-  def ttf(*args, **_arg1, &block); end
-  def url_encoded_form(*args, **_arg1, &block); end
-  def vcf(*args, **_arg1, &block); end
-  def vtt(*args, **_arg1, &block); end
-  def webm(*args, **_arg1, &block); end
-  def webp(*args, **_arg1, &block); end
-  def woff(*args, **_arg1, &block); end
-  def woff2(*args, **_arg1, &block); end
-  def xml(*args, **_arg1, &block); end
-  def yaml(*args, **_arg1, &block); end
-  def zip(*args, **_arg1, &block); end
-
-  private
-
-  def method_missing(symbol, *args, **_arg2, &block); end
+  def atom(*_arg0, **_arg1, &_arg2); end
+  def bmp(*_arg0, **_arg1, &_arg2); end
+  def css(*_arg0, **_arg1, &_arg2); end
+  def csv(*_arg0, **_arg1, &_arg2); end
+  def gif(*_arg0, **_arg1, &_arg2); end
+  def gzip(*_arg0, **_arg1, &_arg2); end
+  def html(*_arg0, **_arg1, &_arg2); end
+  def ics(*_arg0, **_arg1, &_arg2); end
+  def jpeg(*_arg0, **_arg1, &_arg2); end
+  def js(*_arg0, **_arg1, &_arg2); end
+  def json(*_arg0, **_arg1, &_arg2); end
+  def m4a(*_arg0, **_arg1, &_arg2); end
+  def mp3(*_arg0, **_arg1, &_arg2); end
+  def mp4(*_arg0, **_arg1, &_arg2); end
+  def mpeg(*_arg0, **_arg1, &_arg2); end
+  def multipart_form(*_arg0, **_arg1, &_arg2); end
+  def ogg(*_arg0, **_arg1, &_arg2); end
+  def otf(*_arg0, **_arg1, &_arg2); end
+  def pdf(*_arg0, **_arg1, &_arg2); end
+  def png(*_arg0, **_arg1, &_arg2); end
+  def rss(*_arg0, **_arg1, &_arg2); end
+  def svg(*_arg0, **_arg1, &_arg2); end
+  def text(*_arg0, **_arg1, &_arg2); end
+  def tiff(*_arg0, **_arg1, &_arg2); end
+  def ttf(*_arg0, **_arg1, &_arg2); end
+  def url_encoded_form(*_arg0, **_arg1, &_arg2); end
+  def vcf(*_arg0, **_arg1, &_arg2); end
+  def vtt(*_arg0, **_arg1, &_arg2); end
+  def webm(*_arg0, **_arg1, &_arg2); end
+  def webp(*_arg0, **_arg1, &_arg2); end
+  def woff(*_arg0, **_arg1, &_arg2); end
+  def woff2(*_arg0, **_arg1, &_arg2); end
+  def xml(*_arg0, **_arg1, &_arg2); end
+  def yaml(*_arg0, **_arg1, &_arg2); end
+  def zip(*_arg0, **_arg1, &_arg2); end
+
+  private
+
+  def method_missing(symbol, *_arg1, **_arg2, &_arg3); end
 
   class << self
     def generate_method_for_mime(mime); end
@@ -258,7 +259,6 @@ AbstractController::DoubleRenderError::DEFAULT_MESSAGE = T.let(T.unsafe(nil), St
 class AbstractController::Error < ::StandardError; end
 
 module AbstractController::Helpers
-  include ::ActiveSupport::Deprecation::DeprecatedConstantAccessor
   extend ::ActiveSupport::Concern
   extend ::AbstractController::Helpers::Resolution
   include GeneratedInstanceMethods
@@ -297,10 +297,6 @@ module AbstractController::Helpers::ClassMethods
   def define_helpers_module(klass, helpers = T.unsafe(nil)); end
 end
 
-class AbstractController::Helpers::DeprecatedMissingHelperError < ::LoadError
-  def initialize(error, path); end
-end
-
 module AbstractController::Helpers::Resolution
   def all_helpers_from_path(path); end
   def helper_modules_from_paths(paths); end
@@ -411,6 +407,11 @@ class ActionController::API < ::ActionController::Metal
   include ::ActionController::ConditionalGet
   include ::ActionController::BasicImplicitRender
   include ::ActionController::StrongParameters
+  include ::ActionController::RateLimiting
+  include ::ActionController::Caching
+  include ::AbstractController::Caching::Fragments
+  include ::AbstractController::Caching::ConfigMethods
+  include ::AbstractController::Caching
   include ::ActionController::DataStreaming
   include ::ActionController::DefaultHeaders
   include ::ActionController::Logging
@@ -425,6 +426,10 @@ class ActionController::API < ::ActionController::Metal
   extend ::ActionController::Rendering::ClassMethods
   extend ::ActionController::Renderers::ClassMethods
   extend ::ActionController::ConditionalGet::ClassMethods
+  extend ::ActionController::RateLimiting::ClassMethods
+  extend ::AbstractController::Caching::Fragments::ClassMethods
+  extend ::AbstractController::Caching::ClassMethods
+  extend ::AbstractController::Caching::ConfigMethods
   extend ::ActionController::DefaultHeaders::ClassMethods
   extend ::ActionController::Logging::ClassMethods
   extend ::ActiveSupport::Callbacks::ClassMethods
@@ -440,17 +445,29 @@ class ActionController::API < ::ActionController::Metal
   def _renderers=(_arg0); end
   def _renderers?; end
   def _run_process_action_callbacks(&block); end
+  def _view_cache_dependencies; end
+  def _view_cache_dependencies=(_arg0); end
+  def _view_cache_dependencies?; end
   def _wrapper_options; end
   def _wrapper_options=(_arg0); end
   def _wrapper_options?; end
+  def default_static_extension; end
+  def default_static_extension=(value); end
   def default_url_options; end
   def default_url_options=(_arg0); end
   def default_url_options?; end
+  def enable_fragment_cache_logging; end
+  def enable_fragment_cache_logging=(value); end
   def etaggers; end
   def etaggers=(_arg0); end
   def etaggers?; end
+  def fragment_cache_keys; end
+  def fragment_cache_keys=(_arg0); end
+  def fragment_cache_keys?; end
   def logger; end
   def logger=(value); end
+  def perform_caching; end
+  def perform_caching=(value); end
   def raise_on_missing_callback_actions; end
   def raise_on_missing_callback_actions=(val); end
   def raise_on_open_redirects; end
@@ -468,18 +485,30 @@ class ActionController::API < ::ActionController::Metal
     def _renderers; end
     def _renderers=(value); end
     def _renderers?; end
+    def _view_cache_dependencies; end
+    def _view_cache_dependencies=(value); end
+    def _view_cache_dependencies?; end
     def _wrapper_options; end
     def _wrapper_options=(value); end
     def _wrapper_options?; end
+    def default_static_extension; end
+    def default_static_extension=(value); end
     def default_url_options; end
     def default_url_options=(value); end
     def default_url_options?; end
+    def enable_fragment_cache_logging; end
+    def enable_fragment_cache_logging=(value); end
     def etaggers; end
     def etaggers=(value); end
     def etaggers?; end
+    def fragment_cache_keys; end
+    def fragment_cache_keys=(value); end
+    def fragment_cache_keys?; end
     def logger; end
     def logger=(value); end
     def middleware_stack; end
+    def perform_caching; end
+    def perform_caching=(value); end
     def raise_on_missing_callback_actions; end
     def raise_on_missing_callback_actions=(val); end
     def raise_on_open_redirects; end
@@ -494,6 +523,42 @@ end
 ActionController::API::MODULES = T.let(T.unsafe(nil), Array)
 class ActionController::ActionControllerError < ::StandardError; end
 
+module ActionController::AllowBrowser
+  extend ::ActiveSupport::Concern
+
+  mixes_in_class_methods ::ActionController::AllowBrowser::ClassMethods
+
+  private
+
+  def allow_browser(versions:, block:); end
+end
+
+class ActionController::AllowBrowser::BrowserBlocker
+  def initialize(request, versions:); end
+
+  def blocked?; end
+  def request; end
+  def versions; end
+
+  private
+
+  def bot?; end
+  def expanded_versions; end
+  def minimum_browser_version_for_browser; end
+  def normalized_browser_name; end
+  def parsed_user_agent; end
+  def unsupported_browser?; end
+  def user_agent_version_reported?; end
+  def version_below_minimum_required?; end
+  def version_guarded_browser?; end
+end
+
+ActionController::AllowBrowser::BrowserBlocker::SETS = T.let(T.unsafe(nil), Hash)
+
+module ActionController::AllowBrowser::ClassMethods
+  def allow_browser(versions:, block: T.unsafe(nil), **options); end
+end
+
 module ActionController::ApiRendering
   extend ::ActiveSupport::Concern
   include ::ActionController::Rendering
@@ -512,7 +577,6 @@ class ActionController::Base < ::ActionController::Metal
   include ::AbstractController::Rendering
   include ::AbstractController::Translation
   include ::AbstractController::AssetPaths
-  include ::ActiveSupport::Deprecation::DeprecatedConstantAccessor
   include ::AbstractController::Helpers
   include ::ActionController::Helpers
   include ::ActionDispatch::Routing::PolymorphicRoutes
@@ -548,6 +612,8 @@ class ActionController::Base < ::ActionController::Metal
   include ::ActionController::RequestForgeryProtection
   include ::ActionController::ContentSecurityPolicy
   include ::ActionController::PermissionsPolicy
+  include ::ActionController::RateLimiting
+  include ::ActionController::AllowBrowser
   include ::ActionController::Streaming
   include ::ActionController::DataStreaming
   include ::ActionController::HttpAuthentication::Basic::ControllerMethods
@@ -580,6 +646,8 @@ class ActionController::Base < ::ActionController::Metal
   extend ::ActionController::RequestForgeryProtection::ClassMethods
   extend ::ActionController::ContentSecurityPolicy::ClassMethods
   extend ::ActionController::PermissionsPolicy::ClassMethods
+  extend ::ActionController::RateLimiting::ClassMethods
+  extend ::ActionController::AllowBrowser::ClassMethods
   extend ::ActionController::HttpAuthentication::Basic::ControllerMethods::ClassMethods
   extend ::ActionController::DefaultHeaders::ClassMethods
   extend ::ActionController::Logging::ClassMethods
@@ -592,7 +660,8 @@ class ActionController::Base < ::ActionController::Metal
   def _helper_methods; end
   def _helper_methods=(_arg0); end
   def _helper_methods?; end
-  def _layout_conditions(&block); end
+  def _layout_conditions; end
+  def _layout_conditions?; end
   def _process_action_callbacks; end
   def _renderers; end
   def _renderers=(_arg0); end
@@ -615,8 +684,6 @@ class ActionController::Base < ::ActionController::Metal
   def csrf_token_storage_strategy=(value); end
   def default_asset_host_protocol; end
   def default_asset_host_protocol=(value); end
-  def default_protect_from_forgery; end
-  def default_protect_from_forgery=(value); end
   def default_static_extension; end
   def default_static_extension=(value); end
   def default_url_options; end
@@ -715,8 +782,6 @@ class ActionController::Base < ::ActionController::Metal
     def csrf_token_storage_strategy=(value); end
     def default_asset_host_protocol; end
     def default_asset_host_protocol=(value); end
-    def default_protect_from_forgery; end
-    def default_protect_from_forgery=(value); end
     def default_static_extension; end
     def default_static_extension=(value); end
     def default_url_options; end
@@ -772,15 +837,15 @@ class ActionController::Base < ::ActionController::Metal
 end
 
 module ActionController::Base::HelperMethods
-  def alert(*args, **_arg1, &block); end
-  def combined_fragment_cache_key(*args, **_arg1, &block); end
-  def content_security_policy?(*args, **_arg1, &block); end
-  def content_security_policy_nonce(*args, **_arg1, &block); end
-  def cookies(*args, **_arg1, &block); end
-  def form_authenticity_token(*args, **_arg1, &block); end
-  def notice(*args, **_arg1, &block); end
-  def protect_against_forgery?(*args, **_arg1, &block); end
-  def view_cache_dependencies(*args, **_arg1, &block); end
+  def alert(*_arg0, **_arg1, &_arg2); end
+  def combined_fragment_cache_key(*_arg0, **_arg1, &_arg2); end
+  def content_security_policy?(*_arg0, **_arg1, &_arg2); end
+  def content_security_policy_nonce(*_arg0, **_arg1, &_arg2); end
+  def cookies(*_arg0, **_arg1, &_arg2); end
+  def form_authenticity_token(*_arg0, **_arg1, &_arg2); end
+  def notice(*_arg0, **_arg1, &_arg2); end
+  def protect_against_forgery?(*_arg0, **_arg1, &_arg2); end
+  def view_cache_dependencies(*_arg0, **_arg1, &_arg2); end
 end
 
 ActionController::Base::MODULES = T.let(T.unsafe(nil), Array)
@@ -1176,7 +1241,6 @@ end
 
 ActionController::HttpAuthentication::Token::TOKEN_KEY = T.let(T.unsafe(nil), String)
 ActionController::HttpAuthentication::Token::TOKEN_REGEX = T.let(T.unsafe(nil), Regexp)
-ActionController::HttpAuthentication::Token::WHITESPACED_AUTHN_PAIR_DELIMITERS = T.let(T.unsafe(nil), Regexp)
 
 module ActionController::ImplicitRender
   include ::ActionController::BasicImplicitRender
@@ -1424,7 +1488,7 @@ class ActionController::MimeResponds::Collector::VariantCollector
 
   def all(*args, &block); end
   def any(*args, &block); end
-  def method_missing(name, *args, &block); end
+  def method_missing(name, *_arg1, &block); end
   def variant; end
 
   private
@@ -1557,6 +1621,8 @@ class ActionController::Parameters
 
   private
 
+  def _deep_transform_keys_in_object(object, &block); end
+  def _deep_transform_keys_in_object!(object, &block); end
   def array_of_permitted_scalars?(value); end
   def convert_hashes_to_parameters(key, value); end
   def convert_parameters_to_hashes(value, using, &block); end
@@ -1578,7 +1644,7 @@ class ActionController::Parameters
     def action_on_unpermitted_parameters; end
     def action_on_unpermitted_parameters=(val); end
     def allow_deprecated_parameters_hash_equality; end
-    def allow_deprecated_parameters_hash_equality=(val); end
+    def allow_deprecated_parameters_hash_equality=(value); end
     def always_permitted_parameters; end
     def always_permitted_parameters=(val); end
     def hook_into_yaml_loading; end
@@ -1631,18 +1697,11 @@ end
 ActionController::ParamsWrapper::EXCLUDE_PARAMETERS = T.let(T.unsafe(nil), Array)
 
 class ActionController::ParamsWrapper::Options < ::Struct
-  include ::Mutex_m
-
   def initialize(name, format, include, exclude, klass, model); end
 
   def include; end
-  def lock; end
-  def locked?; end
   def model; end
   def name; end
-  def synchronize(&block); end
-  def try_lock; end
-  def unlock; end
 
   private
 
@@ -1670,6 +1729,20 @@ module ActionController::Railties::Helpers
   def inherited(klass); end
 end
 
+module ActionController::RateLimiting
+  extend ::ActiveSupport::Concern
+
+  mixes_in_class_methods ::ActionController::RateLimiting::ClassMethods
+
+  private
+
+  def rate_limiting(to:, within:, by:, with:, store:); end
+end
+
+module ActionController::RateLimiting::ClassMethods
+  def rate_limit(to:, within:, by: T.unsafe(nil), with: T.unsafe(nil), store: T.unsafe(nil), **options); end
+end
+
 module ActionController::Redirecting
   extend ::ActiveSupport::Concern
   include GeneratedInstanceMethods
@@ -1723,7 +1796,7 @@ class ActionController::Renderer
   def controller; end
   def defaults; end
   def new(env = T.unsafe(nil)); end
-  def normalize_env(env, &block); end
+  def normalize_env(env, &_arg1); end
   def render(*args); end
   def render_to_string(*args); end
   def with_defaults(defaults); end
@@ -1871,6 +1944,7 @@ module ActionController::RequestForgeryProtection
   def masked_authenticity_token(form_options: T.unsafe(nil)); end
   def non_xhr_javascript_response?; end
   def normalize_action_path(action_path); end
+  def normalize_relative_action_path(rel_action_path); end
   def per_form_csrf_token(session, action_path, method); end
   def protect_against_forgery?; end
   def real_csrf_token(_session = T.unsafe(nil)); end
@@ -2232,7 +2306,6 @@ class ActionController::UrlGenerationError < ::ActionController::ActionControlle
 end
 
 module ActionDispatch
-  include ::ActiveSupport::Deprecation::DeprecatedConstantAccessor
   extend ::ActiveSupport::Autoload
 
   def eager_load!; end
@@ -2316,7 +2389,7 @@ module ActionDispatch::Assertions::RoutingAssertions
   def assert_generates(expected_path, options, defaults = T.unsafe(nil), extras = T.unsafe(nil), message = T.unsafe(nil)); end
   def assert_recognizes(expected_options, path, extras = T.unsafe(nil), msg = T.unsafe(nil)); end
   def assert_routing(path, options, defaults = T.unsafe(nil), extras = T.unsafe(nil), message = T.unsafe(nil)); end
-  def method_missing(selector, *args, **_arg2, &block); end
+  def method_missing(selector, *_arg1, **_arg2, &_arg3); end
   def setup; end
   def with_routing(&block); end
 
@@ -2332,6 +2405,23 @@ module ActionDispatch::Assertions::RoutingAssertions::ClassMethods
   def with_routing(&block); end
 end
 
+module ActionDispatch::Assertions::RoutingAssertions::WithIntegrationRouting
+  extend ::ActiveSupport::Concern
+
+  mixes_in_class_methods ::ActionDispatch::Assertions::RoutingAssertions::WithIntegrationRouting::ClassMethods
+
+  def with_routing(&block); end
+
+  private
+
+  def create_routes; end
+  def reset_routes(old_routes, old_integration_session); end
+end
+
+module ActionDispatch::Assertions::RoutingAssertions::WithIntegrationRouting::ClassMethods
+  def with_routing(&block); end
+end
+
 class ActionDispatch::AssumeSSL
   def initialize(app); end
 
@@ -2654,7 +2744,6 @@ class ActionDispatch::DebugView < ::ActionView::Base
 end
 
 ActionDispatch::DebugView::RESCUES_TEMPLATE_PATHS = T.let(T.unsafe(nil), Array)
-class ActionDispatch::DeprecatedIllegalStateError < ::StandardError; end
 
 class ActionDispatch::ExceptionWrapper
   def initialize(backtrace_cleaner, exception); end
@@ -2967,10 +3056,8 @@ module ActionDispatch::Http::FilterParameters
 end
 
 ActionDispatch::Http::FilterParameters::ENV_MATCH = T.let(T.unsafe(nil), Array)
-ActionDispatch::Http::FilterParameters::KV_RE = T.let(T.unsafe(nil), String)
 ActionDispatch::Http::FilterParameters::NULL_ENV_FILTER = T.let(T.unsafe(nil), ActiveSupport::ParameterFilter)
 ActionDispatch::Http::FilterParameters::NULL_PARAM_FILTER = T.let(T.unsafe(nil), ActiveSupport::ParameterFilter)
-ActionDispatch::Http::FilterParameters::PAIR_RE = T.let(T.unsafe(nil), Regexp)
 
 module ActionDispatch::Http::FilterRedirect
   def filtered_location; end
@@ -2979,6 +3066,7 @@ module ActionDispatch::Http::FilterRedirect
 
   def location_filter_match?; end
   def location_filters; end
+  def parameter_filtered_location; end
 end
 
 ActionDispatch::Http::FilterRedirect::FILTERED = T.let(T.unsafe(nil), String)
@@ -3191,7 +3279,7 @@ module ActionDispatch::Integration::Runner
 
   private
 
-  def method_missing(method, *args, **_arg2, &block); end
+  def method_missing(method, *_arg1, **_arg2, &_arg3); end
   def respond_to_missing?(method, _); end
 end
 
@@ -3267,11 +3355,14 @@ class ActionDispatch::IntegrationTest < ::ActiveSupport::TestCase
   include ::ActionDispatch::Assertions
   include ::ActionDispatch::Integration::Runner
   include ::ActionController::TemplateAssertions
+  include ::ActionDispatch::TestHelpers::PageDumpHelper
   include ::ActionDispatch::IntegrationTest::Behavior
   include ::ActionDispatch::Routing::PolymorphicRoutes
   include ::ActionDispatch::Routing::UrlFor
   include ::ActionDispatch::IntegrationTest::UrlOptions
+  include ::ActionDispatch::Assertions::RoutingAssertions::WithIntegrationRouting
   extend ::ActionDispatch::IntegrationTest::Behavior::ClassMethods
+  extend ::ActionDispatch::Assertions::RoutingAssertions::WithIntegrationRouting::ClassMethods
 end
 
 module ActionDispatch::IntegrationTest::Behavior
@@ -3283,11 +3374,14 @@ module ActionDispatch::IntegrationTest::Behavior
   include ::ActionDispatch::Assertions
   include ::ActionDispatch::Integration::Runner
   include ::ActionController::TemplateAssertions
+  include ::ActionDispatch::TestHelpers::PageDumpHelper
   extend ::ActiveSupport::Concern
   include ::ActionDispatch::Routing::UrlFor
   include ::ActionDispatch::IntegrationTest::UrlOptions
+  include ::ActionDispatch::Assertions::RoutingAssertions::WithIntegrationRouting
 
   mixes_in_class_methods ::ActionDispatch::IntegrationTest::Behavior::ClassMethods
+  mixes_in_class_methods ::ActionDispatch::Assertions::RoutingAssertions::WithIntegrationRouting::ClassMethods
 
   def app; end
   def document_root_element; end
@@ -3361,6 +3455,7 @@ class ActionDispatch::Journey::Formatter
   def initialize(routes); end
 
   def clear; end
+  def eager_load!; end
   def generate(name, options, path_parameters); end
   def routes; end
 
@@ -4054,11 +4149,8 @@ class ActionDispatch::PermissionsPolicy
   def picture_in_picture(*sources); end
   def screen_wake_lock(*sources); end
   def serial(*sources); end
-  def speaker(*sources); end
   def sync_xhr(*sources); end
   def usb(*sources); end
-  def vibrate(*sources); end
-  def vr(*sources); end
   def web_share(*sources); end
 
   private
@@ -4106,6 +4198,7 @@ class ActionDispatch::PublicExceptions
   def render_html(status); end
 end
 
+ActionDispatch::RFC2396_PARSER = T.let(T.unsafe(nil), URI::RFC2396_Parser)
 class ActionDispatch::Railtie < ::Rails::Railtie; end
 class ActionDispatch::Reloader < ::ActionDispatch::Executor; end
 
@@ -4211,8 +4304,6 @@ class ActionDispatch::Request
   def request_parameters=(params); end
   def reset_csrf_token; end
   def reset_session; end
-  def return_only_media_type_on_content_type; end
-  def return_only_media_type_on_content_type=(value); end
   def route_uri_pattern; end
   def route_uri_pattern=(pattern); end
   def routes; end
@@ -4237,6 +4328,7 @@ class ActionDispatch::Request
   def check_method(name); end
   def default_session; end
   def read_body_stream; end
+  def reset_stream(body_stream); end
 
   class << self
     def empty; end
@@ -4654,6 +4746,10 @@ class ActionDispatch::Routing::Mapper
   end
 end
 
+class ActionDispatch::Routing::Mapper::BacktraceCleaner < ::ActiveSupport::BacktraceCleaner
+  def initialize; end
+end
+
 module ActionDispatch::Routing::Mapper::Base
   def default_url_options(options); end
   def default_url_options=(options); end
@@ -5021,6 +5117,7 @@ class ActionDispatch::Routing::RouteSet
   def find_script_name(options); end
   def formatter; end
   def formatter=(_arg0); end
+  def from_requirements(requirements); end
   def generate_extras(options, recall = T.unsafe(nil)); end
   def generate_url_helpers(supports_path); end
   def inspect; end
@@ -5469,6 +5566,20 @@ class ActionDispatch::Static
   def call(env); end
 end
 
+module ActionDispatch::TestHelpers; end
+
+module ActionDispatch::TestHelpers::PageDumpHelper
+  def save_and_open_page(path = T.unsafe(nil)); end
+
+  private
+
+  def html_dump_default_path; end
+  def open_file(path); end
+  def save_page(path = T.unsafe(nil)); end
+end
+
+class ActionDispatch::TestHelpers::PageDumpHelper::InvalidResponse < ::StandardError; end
+
 module ActionDispatch::TestProcess
   include ::ActionDispatch::TestProcess::FixtureFile
 
@@ -5527,7 +5638,7 @@ end
 module ActionPack::VERSION; end
 ActionPack::VERSION::MAJOR = T.let(T.unsafe(nil), Integer)
 ActionPack::VERSION::MINOR = T.let(T.unsafe(nil), Integer)
-ActionPack::VERSION::PRE = T.let(T.unsafe(nil), String)
+ActionPack::VERSION::PRE = T.let(T.unsafe(nil), T.untyped)
 ActionPack::VERSION::STRING = T.let(T.unsafe(nil), String)
 ActionPack::VERSION::TINY = T.let(T.unsafe(nil), Integer)
 
@@ -5589,7 +5700,7 @@ class Mime::NullType
 
   private
 
-  def method_missing(method, *args); end
+  def method_missing(method, *_arg1, **_arg2, &_arg3); end
   def respond_to_missing?(method, _); end
 
   class << self
@@ -5626,7 +5737,7 @@ class Mime::Type
 
   private
 
-  def method_missing(method, *args); end
+  def method_missing(method, *_arg1, **_arg2, &_arg3); end
   def respond_to_missing?(method, include_private = T.unsafe(nil)); end
   def to_a; end
   def to_ary; end
diff --git a/sorbet/rbi/gems/actionview@7.1.3.4.rbi b/sorbet/rbi/gems/actionview@7.2.2.rbi
similarity index 88%
rename from sorbet/rbi/gems/actionview@7.1.3.4.rbi
rename to sorbet/rbi/gems/actionview@7.2.2.rbi
index f4eaf45d..988f6216 100644
--- a/sorbet/rbi/gems/actionview@7.1.3.4.rbi
+++ b/sorbet/rbi/gems/actionview@7.2.2.rbi
@@ -4,8 +4,8 @@
 # This is an autogenerated file for types exported from the `actionview` gem.
 # Please instead update this file by running `bin/tapioca gem actionview`.
 
+
 class ActionController::Base < ::ActionController::Metal
-  include ::ActiveSupport::Deprecation::DeprecatedConstantAccessor
   include ::ActionDispatch::Routing::PolymorphicRoutes
   include ::ActionController::Head
   include ::AbstractController::Caching::ConfigMethods
@@ -17,7 +17,8 @@ class ActionController::Base < ::ActionController::Metal
   def _helper_methods; end
   def _helper_methods=(_arg0); end
   def _helper_methods?; end
-  def _layout_conditions(&block); end
+  def _layout_conditions; end
+  def _layout_conditions?; end
   def _process_action_callbacks; end
   def _renderers; end
   def _renderers=(_arg0); end
@@ -40,8 +41,6 @@ class ActionController::Base < ::ActionController::Metal
   def csrf_token_storage_strategy=(value); end
   def default_asset_host_protocol; end
   def default_asset_host_protocol=(value); end
-  def default_protect_from_forgery; end
-  def default_protect_from_forgery=(value); end
   def default_static_extension; end
   def default_static_extension=(value); end
   def default_url_options; end
@@ -140,8 +139,6 @@ class ActionController::Base < ::ActionController::Metal
     def csrf_token_storage_strategy=(value); end
     def default_asset_host_protocol; end
     def default_asset_host_protocol=(value); end
-    def default_protect_from_forgery; end
-    def default_protect_from_forgery=(value); end
     def default_static_extension; end
     def default_static_extension=(value); end
     def default_url_options; end
@@ -395,6 +392,7 @@ class ActionView::CacheExpiry::ViewReloader
   private
 
   def all_view_paths; end
+  def build_watcher; end
   def dirs_to_watch; end
   def rebuild_watcher; end
   def reload!; end
@@ -510,8 +508,8 @@ ActionView::DependencyTracker::ERBTracker::RENDER_ARGUMENTS = T.let(T.unsafe(nil
 ActionView::DependencyTracker::ERBTracker::STRING = T.let(T.unsafe(nil), Regexp)
 ActionView::DependencyTracker::ERBTracker::VARIABLE_OR_METHOD_CHAIN = T.let(T.unsafe(nil), Regexp)
 
-class ActionView::DependencyTracker::RipperTracker
-  def initialize(name, template, view_paths = T.unsafe(nil)); end
+class ActionView::DependencyTracker::RubyTracker
+  def initialize(name, template, view_paths = T.unsafe(nil), parser_class: T.unsafe(nil)); end
 
   def dependencies; end
 
@@ -530,7 +528,7 @@ class ActionView::DependencyTracker::RipperTracker
   end
 end
 
-ActionView::DependencyTracker::RipperTracker::EXPLICIT_DEPENDENCY = T.let(T.unsafe(nil), Regexp)
+ActionView::DependencyTracker::RubyTracker::EXPLICIT_DEPENDENCY = T.let(T.unsafe(nil), Regexp)
 
 class ActionView::Digestor
   class << self
@@ -1135,6 +1133,7 @@ module ActionView::Helpers::FormTagHelper
   def field_id(object_name, method_name, *suffixes, index: T.unsafe(nil), namespace: T.unsafe(nil)); end
   def field_name(object_name, method_name, *method_names, multiple: T.unsafe(nil), index: T.unsafe(nil)); end
   def field_set_tag(legend = T.unsafe(nil), options = T.unsafe(nil), &block); end
+  def fieldset_tag(legend = T.unsafe(nil), options = T.unsafe(nil), &block); end
   def file_field_tag(name, options = T.unsafe(nil)); end
   def form_tag(url_for_options = T.unsafe(nil), options = T.unsafe(nil), &block); end
   def hidden_field_tag(name, value = T.unsafe(nil), options = T.unsafe(nil)); end
@@ -1285,10 +1284,12 @@ module ActionView::Helpers::TagHelper
   private
 
   def build_tag_values(*args); end
+  def ensure_valid_html5_tag_name(name); end
   def tag_builder; end
 
   class << self
     def build_tag_values(*args); end
+    def ensure_valid_html5_tag_name(name); end
   end
 end
 
@@ -1304,23 +1305,154 @@ class ActionView::Helpers::TagHelper::TagBuilder
 
   def initialize(view_context); end
 
+  def a(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def abbr(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def address(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def animate(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def animate_motion(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def animate_transform(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def area(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def article(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def aside(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
   def attributes(attributes); end
+  def audio(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def b(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def base(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def bdi(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def bdo(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def blockquote(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def body(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
   def boolean_tag_option(key); end
+  def br(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def button(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def canvas(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def caption(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def circle(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def cite(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def code(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def col(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def colgroup(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
   def content_tag_string(name, content, options, escape = T.unsafe(nil)); end
-  def p(*arguments, **options, &block); end
+  def data(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def datalist(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def dd(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def del(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def details(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def dfn(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def dialog(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def div(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def dl(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def dt(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def ellipse(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def em(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def embed(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def fieldset(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def figcaption(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def figure(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def footer(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def form(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def h1(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def h2(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def h3(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def h4(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def h5(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def h6(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def head(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def header(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def hgroup(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def hr(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def html(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def i(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def iframe(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def img(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def input(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def ins(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def kbd(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def keygen(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def label(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def legend(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def li(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def line(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def link(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def main(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def map(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def mark(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def menu(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def meta(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def meter(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def nav(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def noscript(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def object(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def ol(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def optgroup(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def option(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def output(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def p(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def path(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def picture(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def polygon(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def polyline(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def portal(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def pre(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def progress(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def q(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def rect(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def rp(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def rt(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def ruby(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def s(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def samp(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def script(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def search(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def section(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def select(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def self_closing_tag_string(name, options, escape = T.unsafe(nil), tag_suffix = T.unsafe(nil)); end
+  def set(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def slot(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def small(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def source(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def span(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def stop(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def strong(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def style(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def sub(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def summary(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def sup(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def table(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
   def tag_option(key, value, escape); end
   def tag_options(options, escape = T.unsafe(nil)); end
-  def tag_string(name, content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
-
-  private
-
-  def method_missing(called, *args, **options, &block); end
+  def tag_string(name, content = T.unsafe(nil), options, escape: T.unsafe(nil), &block); end
+  def tbody(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def td(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def template(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def textarea(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def tfoot(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def th(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def thead(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def time(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def title(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def tr(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def track(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def u(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def ul(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def use(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def var(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def video(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def view(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+  def wbr(content = T.unsafe(nil), escape: T.unsafe(nil), **options, &block); end
+
+  private
+
+  def method_missing(called, *args, escape: T.unsafe(nil), **options, &block); end
   def prefix_tag_option(prefix, key, value, escape); end
   def respond_to_missing?(*args); end
-end
 
-ActionView::Helpers::TagHelper::TagBuilder::HTML_VOID_ELEMENTS = T.let(T.unsafe(nil), Set)
-ActionView::Helpers::TagHelper::TagBuilder::SVG_SELF_CLOSING_ELEMENTS = T.let(T.unsafe(nil), Set)
+  class << self
+    def define_element(name, code_generator:, method_name: T.unsafe(nil)); end
+    def define_self_closing_element(name, code_generator:, method_name: T.unsafe(nil)); end
+    def define_void_element(name, code_generator:, method_name: T.unsafe(nil)); end
+  end
+end
 
 module ActionView::Helpers::Tags
   extend ::ActiveSupport::Autoload
@@ -1785,6 +1917,7 @@ module ActionView::Helpers::UrlHelper::ClassMethods
   def _url_for_modules; end
 end
 
+ActionView::Helpers::UrlHelper::RFC2396_PARSER = T.let(T.unsafe(nil), URI::RFC2396_Parser)
 ActionView::Helpers::UrlHelper::STRINGIFIED_COMMON_METHODS = T.let(T.unsafe(nil), Hash)
 
 class ActionView::I18nProxy < ::I18n::Config
@@ -1831,7 +1964,10 @@ module ActionView::Layouts
     def _layout_conditions?; end
   end
 
-  module GeneratedInstanceMethods; end
+  module GeneratedInstanceMethods
+    def _layout_conditions; end
+    def _layout_conditions?; end
+  end
 end
 
 module ActionView::Layouts::ClassMethods
@@ -1875,6 +2011,7 @@ class ActionView::LogSubscriber::Start
   include ::ActionView::LogSubscriber::Utils
 
   def finish(name, id, payload); end
+  def silenced?(_); end
   def start(name, id, payload); end
 end
 
@@ -2170,269 +2307,30 @@ end
 
 ActionView::RecordIdentifier::JOIN = T.let(T.unsafe(nil), String)
 ActionView::RecordIdentifier::NEW = T.let(T.unsafe(nil), String)
+module ActionView::RenderParser; end
+ActionView::RenderParser::ALL_KNOWN_KEYS = T.let(T.unsafe(nil), Array)
 
-class ActionView::RenderParser
+class ActionView::RenderParser::Base
   def initialize(name, code); end
 
-  def render_calls; end
-
   private
 
   def directory; end
-  def layout_to_virtual_path(layout_path); end
-  def normalize_args(string, options_hash); end
-  def parse_hash(node); end
-  def parse_hash_to_symbols(node); end
-  def parse_render(node); end
-  def parse_render_from_options(options_hash); end
-  def parse_str(node); end
-  def parse_sym(node); end
   def partial_to_virtual_path(render_type, partial_path); end
-  def render_template_with_layout?(render_type, options_hash); end
-  def render_template_with_spacer?(options_hash); end
-  def resolve_path_directory(path); end
 end
 
-ActionView::RenderParser::ALL_KNOWN_KEYS = T.let(T.unsafe(nil), Array)
-ActionView::RenderParser::RENDER_TYPE_KEYS = T.let(T.unsafe(nil), Array)
-
-module ActionView::RenderParser::RipperASTParser
-  extend ::ActionView::RenderParser::RipperASTParser
-
-  def parse_render_nodes(code); end
-end
-
-class ActionView::RenderParser::RipperASTParser::Node < ::Array
-  def initialize(type, arr, opts = T.unsafe(nil)); end
-
-  def argument_nodes; end
-  def call?; end
-  def call_method_name; end
-  def children; end
-  def fcall?; end
-  def fcall_named?(name); end
-  def hash?; end
-  def hash_from_body(body); end
-  def inspect; end
-  def string?; end
-  def symbol?; end
-  def to_hash; end
-  def to_string; end
-  def to_symbol; end
-  def type; end
-  def variable_name; end
-  def variable_reference?; end
-  def vcall?; end
-end
-
-class ActionView::RenderParser::RipperASTParser::NodeParser < ::Ripper
-  def on_BEGIN(*args); end
-  def on_CHAR(tok); end
-  def on_END(*args); end
-  def on___end__(tok); end
-  def on_alias(*args); end
-  def on_alias_error(*args); end
-  def on_aref(*args); end
-  def on_aref_field(*args); end
-  def on_arg_ambiguous(*args); end
-  def on_arg_paren(*args); end
-  def on_args_add(list, item); end
-  def on_args_add_block(list, item); end
-  def on_args_add_star(list, item); end
-  def on_args_forward(*args); end
-  def on_args_new(*args); end
-  def on_array(*args); end
-  def on_aryptn(*args); end
-  def on_assign(*args); end
-  def on_assign_error(*args); end
-  def on_assoc_new(*args); end
-  def on_assoc_splat(*args); end
-  def on_assoclist_from_args(*args); end
-  def on_backref(tok); end
-  def on_backtick(tok); end
-  def on_bare_assoc_hash(*args); end
-  def on_begin(*args); end
-  def on_binary(*args); end
-  def on_block_var(*args); end
-  def on_blockarg(*args); end
-  def on_bodystmt(*args); end
-  def on_brace_block(*args); end
-  def on_break(*args); end
-  def on_call(*args); end
-  def on_case(*args); end
-  def on_class(*args); end
-  def on_class_name_error(*args); end
-  def on_comma(tok); end
-  def on_command(*args); end
-  def on_command_call(*args); end
-  def on_comment(tok); end
-  def on_const(tok); end
-  def on_const_path_field(*args); end
-  def on_const_path_ref(*args); end
-  def on_const_ref(*args); end
-  def on_cvar(tok); end
-  def on_def(*args); end
-  def on_defined(*args); end
-  def on_defs(*args); end
-  def on_do_block(*args); end
-  def on_dot2(*args); end
-  def on_dot3(*args); end
-  def on_dyna_symbol(*args); end
-  def on_else(*args); end
-  def on_elsif(*args); end
-  def on_embdoc(tok); end
-  def on_embdoc_beg(tok); end
-  def on_embdoc_end(tok); end
-  def on_embexpr_beg(tok); end
-  def on_embexpr_end(tok); end
-  def on_embvar(tok); end
-  def on_ensure(*args); end
-  def on_excessed_comma(*args); end
-  def on_fcall(*args); end
-  def on_field(*args); end
-  def on_float(tok); end
-  def on_fndptn(*args); end
-  def on_for(*args); end
-  def on_gvar(tok); end
-  def on_hash(*args); end
-  def on_heredoc_beg(tok); end
-  def on_heredoc_dedent(*args); end
-  def on_heredoc_end(tok); end
-  def on_hshptn(*args); end
-  def on_ident(tok); end
-  def on_if(*args); end
-  def on_if_mod(*args); end
-  def on_ifop(*args); end
-  def on_ignored_nl(tok); end
-  def on_ignored_sp(tok); end
-  def on_imaginary(tok); end
-  def on_in(*args); end
-  def on_int(tok); end
-  def on_ivar(tok); end
-  def on_kw(tok); end
-  def on_kwrest_param(*args); end
-  def on_label(tok); end
-  def on_label_end(tok); end
-  def on_lambda(*args); end
-  def on_lbrace(tok); end
-  def on_lbracket(tok); end
-  def on_lparen(tok); end
-  def on_magic_comment(*args); end
-  def on_massign(*args); end
-  def on_method_add_arg(list, item); end
-  def on_method_add_block(list, item); end
-  def on_mlhs_add(list, item); end
-  def on_mlhs_add_post(list, item); end
-  def on_mlhs_add_star(list, item); end
-  def on_mlhs_new(*args); end
-  def on_mlhs_paren(*args); end
-  def on_module(*args); end
-  def on_mrhs_add(list, item); end
-  def on_mrhs_add_star(list, item); end
-  def on_mrhs_new(*args); end
-  def on_mrhs_new_from_args(*args); end
-  def on_next(*args); end
-  def on_nl(tok); end
-  def on_nokw_param(*args); end
-  def on_op(tok); end
-  def on_opassign(*args); end
-  def on_operator_ambiguous(*args); end
-  def on_param_error(*args); end
-  def on_params(*args); end
-  def on_paren(*args); end
-  def on_parse_error(*args); end
-  def on_period(tok); end
-  def on_program(*args); end
-  def on_qsymbols_add(list, item); end
-  def on_qsymbols_beg(tok); end
-  def on_qsymbols_new(*args); end
-  def on_qwords_add(list, item); end
-  def on_qwords_beg(tok); end
-  def on_qwords_new(*args); end
-  def on_rational(tok); end
-  def on_rbrace(tok); end
-  def on_rbracket(tok); end
-  def on_redo(*args); end
-  def on_regexp_add(list, item); end
-  def on_regexp_beg(tok); end
-  def on_regexp_end(tok); end
-  def on_regexp_literal(*args); end
-  def on_regexp_new(*args); end
-  def on_rescue(*args); end
-  def on_rescue_mod(*args); end
-  def on_rest_param(*args); end
-  def on_retry(*args); end
-  def on_return(*args); end
-  def on_return0(*args); end
-  def on_rparen(tok); end
-  def on_sclass(*args); end
-  def on_semicolon(tok); end
-  def on_sp(tok); end
-  def on_stmts_add(list, item); end
-  def on_stmts_new(*args); end
-  def on_string_add(list, item); end
-  def on_string_concat(*args); end
-  def on_string_content(*args); end
-  def on_string_dvar(*args); end
-  def on_string_embexpr(*args); end
-  def on_string_literal(*args); end
-  def on_super(*args); end
-  def on_symbeg(tok); end
-  def on_symbol(*args); end
-  def on_symbol_literal(*args); end
-  def on_symbols_add(list, item); end
-  def on_symbols_beg(tok); end
-  def on_symbols_new(*args); end
-  def on_tlambda(tok); end
-  def on_tlambeg(tok); end
-  def on_top_const_field(*args); end
-  def on_top_const_ref(*args); end
-  def on_tstring_beg(tok); end
-  def on_tstring_content(tok); end
-  def on_tstring_end(tok); end
-  def on_unary(*args); end
-  def on_undef(*args); end
-  def on_unless(*args); end
-  def on_unless_mod(*args); end
-  def on_until(*args); end
-  def on_until_mod(*args); end
-  def on_var_alias(*args); end
-  def on_var_field(*args); end
-  def on_var_ref(*args); end
-  def on_vcall(*args); end
-  def on_void_stmt(*args); end
-  def on_when(*args); end
-  def on_while(*args); end
-  def on_while_mod(*args); end
-  def on_word_add(list, item); end
-  def on_word_new(*args); end
-  def on_words_add(list, item); end
-  def on_words_beg(tok); end
-  def on_words_new(*args); end
-  def on_words_sep(tok); end
-  def on_xstring_add(list, item); end
-  def on_xstring_literal(*args); end
-  def on_xstring_new(*args); end
-  def on_yield(*args); end
-  def on_yield0(*args); end
-  def on_zsuper(*args); end
-end
-
-class ActionView::RenderParser::RipperASTParser::RenderCallExtractor < ::ActionView::RenderParser::RipperASTParser::NodeParser
-  def initialize(*args); end
+ActionView::RenderParser::Default = ActionView::RenderParser::PrismRenderParser
 
+class ActionView::RenderParser::PrismRenderParser < ::ActionView::RenderParser::Base
   def render_calls; end
 
   private
 
-  def on_arg_paren(content); end
-  def on_command(name, *args); end
-  def on_fcall(name, *args); end
-  def on_paren(content); end
-  def on_render_call(node); end
+  def render_call_options(node); end
+  def render_call_template(node); end
 end
 
-ActionView::RenderParser::RipperASTParser::RenderCallExtractor::METHODS_TO_PARSE = T.let(T.unsafe(nil), Array)
+ActionView::RenderParser::RENDER_TYPE_KEYS = T.let(T.unsafe(nil), Array)
 
 class ActionView::Renderer
   def initialize(lookup_context); end
@@ -2443,15 +2341,14 @@ class ActionView::Renderer
   def render(context, options); end
   def render_body(context, options); end
   def render_partial(context, options, &block); end
-  def render_partial_to_object(context, options, &block); end
-  def render_template(context, options); end
-  def render_template_to_object(context, options); end
   def render_to_object(context, options); end
 
   private
 
   def collection_from_object(object); end
   def collection_from_options(options); end
+  def render_partial_to_object(context, options, &block); end
+  def render_template_to_object(context, options); end
 end
 
 module ActionView::Rendering
@@ -2488,13 +2385,11 @@ module ActionView::Rendering::ClassMethods
 end
 
 class ActionView::Resolver
-  include ::ActiveSupport::Deprecation::DeprecatedConstantAccessor
-
   def all_template_paths; end
   def built_templates; end
   def caching; end
   def caching=(val); end
-  def caching?(&block); end
+  def caching?(&_arg0); end
   def clear_cache; end
   def find_all(name, prefix = T.unsafe(nil), partial = T.unsafe(nil), details = T.unsafe(nil), key = T.unsafe(nil), locals = T.unsafe(nil)); end
 
@@ -2785,6 +2680,7 @@ end
 ActionView::Template::Inline::Finalizer = T.let(T.unsafe(nil), Proc)
 ActionView::Template::LEADING_ENCODING_REGEXP = T.let(T.unsafe(nil), Regexp)
 ActionView::Template::NONE = T.let(T.unsafe(nil), Object)
+ActionView::Template::RUBY_RESERVED_KEYWORDS = T.let(T.unsafe(nil), Array)
 
 class ActionView::Template::RawFile
   def initialize(filename); end
@@ -2924,7 +2820,6 @@ class ActionView::TestCase < ::ActiveSupport::TestCase
   include ::Rails::Dom::Testing::Assertions::SelectorAssertions
   include ::Rails::Dom::Testing::Assertions
   include ::ActionDispatch::Assertions
-  include ::ActiveSupport::Deprecation::DeprecatedConstantAccessor
   include ::AbstractController::Helpers
   include ::ActiveSupport::Benchmarkable
   include ::ActionView::Helpers::ActiveModelHelper
@@ -3033,6 +2928,7 @@ module ActionView::TestCase::Behavior
   def output_buffer=(_arg0); end
   def render(options = T.unsafe(nil), local_assigns = T.unsafe(nil), &block); end
   def rendered; end
+  def rendered=(_arg0); end
   def rendered_views; end
   def request; end
   def request=(_arg0); end
@@ -3043,7 +2939,7 @@ module ActionView::TestCase::Behavior
   def _user_defined_ivars; end
   def _view; end
   def document_root_element; end
-  def method_missing(selector, *args, **_arg2); end
+  def method_missing(selector, *_arg1, **_arg2, &_arg3); end
   def respond_to_missing?(name, include_private = T.unsafe(nil)); end
   def view; end
   def view_assigns; end
@@ -3153,7 +3049,7 @@ end
 module ActionView::VERSION; end
 ActionView::VERSION::MAJOR = T.let(T.unsafe(nil), Integer)
 ActionView::VERSION::MINOR = T.let(T.unsafe(nil), Integer)
-ActionView::VERSION::PRE = T.let(T.unsafe(nil), String)
+ActionView::VERSION::PRE = T.let(T.unsafe(nil), T.untyped)
 ActionView::VERSION::STRING = T.let(T.unsafe(nil), String)
 ActionView::VERSION::TINY = T.let(T.unsafe(nil), Integer)
 
diff --git a/sorbet/rbi/gems/activemodel@7.1.3.4.rbi b/sorbet/rbi/gems/activemodel@7.2.2.rbi
similarity index 95%
rename from sorbet/rbi/gems/activemodel@7.1.3.4.rbi
rename to sorbet/rbi/gems/activemodel@7.2.2.rbi
index ebbce1e0..f1549048 100644
--- a/sorbet/rbi/gems/activemodel@7.1.3.4.rbi
+++ b/sorbet/rbi/gems/activemodel@7.2.2.rbi
@@ -4,6 +4,7 @@
 # This is an autogenerated file for types exported from the `activemodel` gem.
 # Please instead update this file by running `bin/tapioca gem activemodel`.
 
+
 module ActiveModel
   extend ::ActiveSupport::Autoload
 
@@ -189,8 +190,8 @@ module ActiveModel::AttributeMethods
   mixes_in_class_methods GeneratedClassMethods
   mixes_in_class_methods ::ActiveModel::AttributeMethods::ClassMethods
 
-  def attribute_missing(match, *args, **_arg2, &block); end
-  def method_missing(method, *args, **_arg2, &block); end
+  def attribute_missing(match, *_arg1, **_arg2, &_arg3); end
+  def method_missing(method, *_arg1, **_arg2, &_arg3); end
   def respond_to?(method, include_private_methods = T.unsafe(nil)); end
   def respond_to_without_attributes?(*_arg0); end
 
@@ -236,7 +237,8 @@ module ActiveModel::AttributeMethods::ClassMethods
   def attribute_method_affix(*affixes); end
   def attribute_method_prefix(*prefixes, parameters: T.unsafe(nil)); end
   def attribute_method_suffix(*suffixes, parameters: T.unsafe(nil)); end
-  def define_attribute_method(attr_name, _owner: T.unsafe(nil)); end
+  def define_attribute_method(attr_name, _owner: T.unsafe(nil), as: T.unsafe(nil)); end
+  def define_attribute_method_pattern(pattern, attr_name, owner:, as:, override: T.unsafe(nil)); end
   def define_attribute_methods(*attr_names); end
   def eagerly_generate_alias_attribute_methods(new_name, old_name); end
   def generate_alias_attribute_methods(code_generator, new_name, old_name); end
@@ -246,7 +248,9 @@ module ActiveModel::AttributeMethods::ClassMethods
 
   def attribute_method_patterns_cache; end
   def attribute_method_patterns_matching(method_name); end
-  def define_proxy_call(code_generator, name, proxy_target, parameters, *call_args, namespace:); end
+  def build_mangled_name(name); end
+  def define_call(code_generator, name, target_name, mangled_name, parameters, call_args, namespace:, as:); end
+  def define_proxy_call(code_generator, name, proxy_target, parameters, *call_args, namespace:, as: T.unsafe(nil)); end
   def generated_attribute_methods; end
   def inherited(base); end
   def instance_method_already_implemented?(method_name); end
@@ -279,7 +283,6 @@ class ActiveModel::AttributeMethods::ClassMethods::AttributeMethodPattern::Attri
   end
 end
 
-ActiveModel::AttributeMethods::FORWARD_PARAMETERS = T.let(T.unsafe(nil), String)
 ActiveModel::AttributeMethods::NAME_COMPILABLE_REGEXP = T.let(T.unsafe(nil), Regexp)
 
 class ActiveModel::AttributeMutationTracker
@@ -318,23 +321,66 @@ module ActiveModel::AttributeRegistration::ClassMethods
   def _default_attributes; end
   def attribute(name, type = T.unsafe(nil), default: T.unsafe(nil), **options); end
   def attribute_types; end
+  def decorate_attributes(names = T.unsafe(nil), &decorator); end
+  def type_for_attribute(attribute_name, &block); end
 
   private
 
-  def apply_pending_attributes(attribute_set); end
-  def build_default_attributes; end
-  def pending_attribute(name); end
+  def apply_pending_attribute_modifications(attribute_set); end
+  def hook_attribute_type(attribute, type); end
+  def pending_attribute_modifications; end
   def reset_default_attributes; end
+  def reset_default_attributes!; end
   def resolve_attribute_name(name); end
   def resolve_type_name(name, **options); end
 end
 
-class ActiveModel::AttributeRegistration::ClassMethods::PendingAttribute
-  def apply_to(attribute); end
+class ActiveModel::AttributeRegistration::ClassMethods::PendingDecorator < ::Struct
+  def apply_to(attribute_set); end
+  def decorator; end
+  def decorator=(_); end
+  def names; end
+  def names=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class ActiveModel::AttributeRegistration::ClassMethods::PendingDefault < ::Struct
+  def apply_to(attribute_set); end
   def default; end
-  def default=(_arg0); end
+  def default=(_); end
+  def name; end
+  def name=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class ActiveModel::AttributeRegistration::ClassMethods::PendingType < ::Struct
+  def apply_to(attribute_set); end
+  def name; end
+  def name=(_); end
   def type; end
-  def type=(_arg0); end
+  def type=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
 end
 
 class ActiveModel::AttributeSet
@@ -442,7 +488,7 @@ module ActiveModel::Attributes::ClassMethods
 
   private
 
-  def define_method_attribute=(name, owner:); end
+  def define_method_attribute=(canonical_name, owner:, as: T.unsafe(nil)); end
 end
 
 class ActiveModel::BlockValidator < ::ActiveModel::EachValidator
@@ -1159,7 +1205,7 @@ ActiveModel::Type::Integer::DEFAULT_LIMIT = T.let(T.unsafe(nil), Integer)
 class ActiveModel::Type::Registry
   def initialize; end
 
-  def lookup(symbol, *args, **_arg2); end
+  def lookup(symbol, *_arg1, **_arg2, &_arg3); end
   def register(type_name, klass = T.unsafe(nil), &block); end
 
   private
@@ -1259,7 +1305,7 @@ end
 module ActiveModel::VERSION; end
 ActiveModel::VERSION::MAJOR = T.let(T.unsafe(nil), Integer)
 ActiveModel::VERSION::MINOR = T.let(T.unsafe(nil), Integer)
-ActiveModel::VERSION::PRE = T.let(T.unsafe(nil), String)
+ActiveModel::VERSION::PRE = T.let(T.unsafe(nil), T.untyped)
 ActiveModel::VERSION::STRING = T.let(T.unsafe(nil), String)
 ActiveModel::VERSION::TINY = T.let(T.unsafe(nil), Integer)
 
diff --git a/sorbet/rbi/gems/activerecord@7.1.3.4.rbi b/sorbet/rbi/gems/activerecord@7.2.2.rbi
similarity index 94%
rename from sorbet/rbi/gems/activerecord@7.1.3.4.rbi
rename to sorbet/rbi/gems/activerecord@7.2.2.rbi
index a1acb1ff..5874d233 100644
--- a/sorbet/rbi/gems/activerecord@7.1.3.4.rbi
+++ b/sorbet/rbi/gems/activerecord@7.2.2.rbi
@@ -4,6 +4,7 @@
 # This is an autogenerated file for types exported from the `activerecord` gem.
 # Please instead update this file by running `bin/tapioca gem activerecord`.
 
+
 module ActiveRecord
   include ::ActiveSupport::Deprecation::DeprecatedConstantAccessor
   extend ::ActiveSupport::Autoload
@@ -11,8 +12,10 @@ module ActiveRecord
   class << self
     def action_on_strict_loading_violation; end
     def action_on_strict_loading_violation=(_arg0); end
+    def after_all_transactions_commit(&block); end
+    def all_open_transactions; end
     def allow_deprecated_singular_associations_name; end
-    def allow_deprecated_singular_associations_name=(_arg0); end
+    def allow_deprecated_singular_associations_name=(value); end
     def application_record_class; end
     def application_record_class=(_arg0); end
     def async_query_executor; end
@@ -22,7 +25,7 @@ module ActiveRecord
     def belongs_to_required_validates_foreign_key; end
     def belongs_to_required_validates_foreign_key=(_arg0); end
     def commit_transaction_on_non_local_return; end
-    def commit_transaction_on_non_local_return=(_arg0); end
+    def commit_transaction_on_non_local_return=(value); end
     def db_warnings_action; end
     def db_warnings_action=(action); end
     def db_warnings_ignore; end
@@ -57,6 +60,10 @@ module ActiveRecord
     def marshalling_format_version=(value); end
     def migration_strategy; end
     def migration_strategy=(_arg0); end
+    def permanent_connection_checkout; end
+    def permanent_connection_checkout=(value); end
+    def protocol_adapters; end
+    def protocol_adapters=(_arg0); end
     def query_transformers; end
     def query_transformers=(_arg0); end
     def queues; end
@@ -73,12 +80,12 @@ module ActiveRecord
     def schema_cache_ignored_tables=(_arg0); end
     def schema_format; end
     def schema_format=(_arg0); end
-    def suppress_multiple_database_warning; end
-    def suppress_multiple_database_warning=(value); end
     def timestamped_migrations; end
     def timestamped_migrations=(_arg0); end
     def use_yaml_unsafe_load; end
     def use_yaml_unsafe_load=(_arg0); end
+    def validate_migration_timestamps; end
+    def validate_migration_timestamps=(_arg0); end
     def verbose_query_logs; end
     def verbose_query_logs=(_arg0); end
     def verify_foreign_keys_for_fixtures; end
@@ -182,17 +189,18 @@ module ActiveRecord::Associations
 end
 
 class ActiveRecord::Associations::AliasTracker
-  def initialize(connection, aliases); end
+  def initialize(table_alias_length, aliases); end
 
   def aliased_table_for(arel_table, table_name = T.unsafe(nil)); end
   def aliases; end
 
   private
 
+  def table_alias_for(table_name); end
   def truncate(name); end
 
   class << self
-    def create(connection, initial_table, joins, aliases = T.unsafe(nil)); end
+    def create(pool, initial_table, joins, aliases = T.unsafe(nil)); end
     def initial_count_for(connection, name, table_joins); end
   end
 end
@@ -200,6 +208,7 @@ end
 class ActiveRecord::Associations::Association
   def initialize(owner, reflection); end
 
+  def collection?; end
   def create(attributes = T.unsafe(nil), &block); end
   def create!(attributes = T.unsafe(nil), &block); end
   def disable_joins; end
@@ -455,6 +464,7 @@ end
 class ActiveRecord::Associations::CollectionAssociation < ::ActiveRecord::Associations::Association
   def add_to_target(record, skip_callbacks: T.unsafe(nil), replace: T.unsafe(nil), &block); end
   def build(attributes = T.unsafe(nil), &block); end
+  def collection?; end
   def concat(*records); end
   def delete(*records); end
   def delete_all(dependent = T.unsafe(nil)); end
@@ -467,6 +477,8 @@ class ActiveRecord::Associations::CollectionAssociation < ::ActiveRecord::Associ
   def ids_writer(ids); end
   def include?(record); end
   def load_target; end
+  def nested_attributes_target; end
+  def nested_attributes_target=(_arg0); end
   def null_scope?; end
   def reader; end
   def replace(other_array); end
@@ -677,6 +689,8 @@ class ActiveRecord::Associations::CollectionProxy < ::ActiveRecord::Relation
   def where_clause=(arg); end
   def with(*_arg0, **_arg1, &_arg2); end
   def with!(*_arg0, **_arg1, &_arg2); end
+  def with_recursive(*_arg0, **_arg1, &_arg2); end
+  def with_recursive!(*_arg0, **_arg1, &_arg2); end
   def with_values(*_arg0, **_arg1, &_arg2); end
   def with_values=(arg); end
   def without(*_arg0, **_arg1, &_arg2); end
@@ -874,7 +888,7 @@ class ActiveRecord::Associations::JoinDependency::JoinAssociation < ::ActiveReco
 
   private
 
-  def append_constraints(join, constraints); end
+  def append_constraints(connection, join, constraints); end
 end
 
 class ActiveRecord::Associations::JoinDependency::JoinBase < ::ActiveRecord::Associations::JoinDependency::JoinPart
@@ -903,6 +917,18 @@ class ActiveRecord::Associations::JoinDependency::JoinPart
   def table_name(*_arg0, **_arg1, &_arg2); end
 end
 
+class ActiveRecord::Associations::NestedError < ::ActiveModel::NestedError
+  def initialize(association, inner_error); end
+
+  private
+
+  def association; end
+  def compute_attribute(inner_error); end
+  def index; end
+  def index_errors_setting; end
+  def ordered_records; end
+end
+
 class ActiveRecord::Associations::Preloader
   extend ::ActiveSupport::Autoload
 
@@ -1049,6 +1075,7 @@ class ActiveRecord::Associations::SingularAssociation < ::ActiveRecord::Associat
   def build(attributes = T.unsafe(nil), &block); end
   def force_reload_reader; end
   def reader; end
+  def reset; end
   def writer(record); end
 
   private
@@ -1108,9 +1135,6 @@ end
 class ActiveRecord::AsynchronousQueryInsideTransactionError < ::ActiveRecord::ActiveRecordError; end
 
 module ActiveRecord::AttributeAssignment
-  include ::ActiveModel::ForbiddenAttributesProtection
-  include ::ActiveModel::AttributeAssignment
-
   private
 
   def _assign_attributes(attributes); end
@@ -1171,7 +1195,9 @@ module ActiveRecord::AttributeMethods
   def attributes_for_update(attribute_names); end
   def attributes_with_values(attribute_names); end
   def format_for_inspect(name, value); end
+  def method_missing(name, *_arg1, **_arg2, &_arg3); end
   def pk_attribute?(name); end
+  def respond_to_missing?(name, include_private = T.unsafe(nil)); end
 
   class << self
     def dangerous_attribute_methods; end
@@ -1242,11 +1268,13 @@ module ActiveRecord::AttributeMethods::ClassMethods
   def alias_attribute(new_name, old_name); end
   def alias_attribute_method_definition(code_generator, pattern, new_name, old_name); end
   def attribute_method?(attribute); end
+  def attribute_methods_generated?; end
   def attribute_names; end
   def dangerous_attribute_method?(name); end
   def dangerous_class_method?(method_name); end
   def define_attribute_methods; end
   def eagerly_generate_alias_attribute_methods(_new_name, _old_name); end
+  def generate_alias_attribute_methods(code_generator, new_name, old_name); end
   def generate_alias_attributes; end
   def has_attribute?(attr_name); end
   def initialize_generated_modules; end
@@ -1259,6 +1287,17 @@ module ActiveRecord::AttributeMethods::ClassMethods
   def inherited(child_class); end
 end
 
+module ActiveRecord::AttributeMethods::CompositePrimaryKey
+  def id; end
+  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 primary_key_values_present?; end
+end
+
 module ActiveRecord::AttributeMethods::Dirty
   extend ::ActiveSupport::Concern
   include GeneratedInstanceMethods
@@ -1318,15 +1357,8 @@ module ActiveRecord::AttributeMethods::Dirty
   end
 end
 
-class ActiveRecord::AttributeMethods::GeneratedAttributeMethods < ::Module
-  include ::Mutex_m
-
-  def lock; end
-  def locked?; end
-  def synchronize(&block); end
-  def try_lock; end
-  def unlock; end
-end
+class ActiveRecord::AttributeMethods::GeneratedAttributeMethods < ::Module; end
+ActiveRecord::AttributeMethods::GeneratedAttributeMethods::LOCK = T.let(T.unsafe(nil), Monitor)
 
 module ActiveRecord::AttributeMethods::PrimaryKey
   extend ::ActiveSupport::Concern
@@ -1360,7 +1392,6 @@ module ActiveRecord::AttributeMethods::PrimaryKey::ClassMethods
 
   private
 
-  def derive_primary_key(value); end
   def inherited(base); end
 end
 
@@ -1397,7 +1428,7 @@ end
 module ActiveRecord::AttributeMethods::Read::ClassMethods
   private
 
-  def define_method_attribute(name, owner:); end
+  def define_method_attribute(canonical_name, owner:, as: T.unsafe(nil)); end
 end
 
 module ActiveRecord::AttributeMethods::Serialization
@@ -1417,7 +1448,7 @@ module ActiveRecord::AttributeMethods::Serialization
 end
 
 module ActiveRecord::AttributeMethods::Serialization::ClassMethods
-  def serialize(attr_name, class_name_or_coder = T.unsafe(nil), coder: T.unsafe(nil), type: T.unsafe(nil), yaml: T.unsafe(nil), **options); end
+  def serialize(attr_name, coder: T.unsafe(nil), type: T.unsafe(nil), yaml: T.unsafe(nil), **options); end
 
   private
 
@@ -1459,14 +1490,14 @@ 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 hook_attribute_type(name, cast_type); end
 end
 
 class ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter
+  def ==(other); end
   def cast(value); end
   def deserialize(value); end
 
@@ -1497,33 +1528,31 @@ end
 module ActiveRecord::AttributeMethods::Write::ClassMethods
   private
 
-  def define_method_attribute=(name, owner:); end
+  def define_method_attribute=(canonical_name, owner:, as: T.unsafe(nil)); end
 end
 
 module ActiveRecord::Attributes
   extend ::ActiveSupport::Concern
-  include GeneratedInstanceMethods
+  include ::ActiveModel::AttributeRegistration
 
-  mixes_in_class_methods GeneratedClassMethods
+  mixes_in_class_methods ::ActiveModel::AttributeRegistration::ClassMethods
   mixes_in_class_methods ::ActiveRecord::Attributes::ClassMethods
-
-  module GeneratedClassMethods
-    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
-  end
-
-  module GeneratedInstanceMethods; end
 end
 
 module ActiveRecord::Attributes::ClassMethods
-  def attribute(name, cast_type = T.unsafe(nil), default: T.unsafe(nil), **options); end
+  def _default_attributes; end
   def define_attribute(name, cast_type, default: T.unsafe(nil), user_provided_default: T.unsafe(nil)); end
-  def load_schema!; end
+
+  protected
+
+  def reload_schema_from_cache(*_arg0); end
 
   private
 
   def define_default_attribute(name, value, type, from_user:); end
+  def reset_default_attributes; end
+  def resolve_type_name(name, **options); end
+  def type_for_column(connection, column); end
 end
 
 ActiveRecord::Attributes::ClassMethods::NO_DEFAULT_PROVIDED = T.let(T.unsafe(nil), Object)
@@ -1547,13 +1576,11 @@ module ActiveRecord::AutosaveAssociation
   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 association_valid?(association, record); end
   def compute_primary_key(reflection, record); end
-  def custom_validation_context?; end
   def init_internals; end
   def inverse_polymorphic_association_changed?(reflection, record); end
   def nested_records_changed_for_autosave?; end
-  def normalize_reflection_attribute(indexed_attribute, reflection, index, attribute); end
   def save_belongs_to_association(reflection); end
   def save_collection_association(reflection); end
   def save_has_one_association(reflection); end
@@ -1577,6 +1604,13 @@ module ActiveRecord::AutosaveAssociation::ClassMethods
 end
 
 class ActiveRecord::Base
+  include ::ActiveModel::Validations
+  include ::ActiveSupport::Callbacks
+  include ::ActiveModel::Validations::HelperMethods
+  include ::ActiveModel::Conversion
+  include ::ActiveModel::ForbiddenAttributesProtection
+  include ::ActiveModel::AttributeAssignment
+  include ::ActiveModel::API
   include ::ActiveModel::Access
   include ::ActiveRecord::Core
   include ::ActiveRecord::Persistence
@@ -1587,16 +1621,11 @@ class ActiveRecord::Base
   include ::ActiveRecord::Scoping::Default
   include ::ActiveRecord::Scoping::Named
   include ::ActiveRecord::Sanitization
-  include ::ActiveModel::ForbiddenAttributesProtection
-  include ::ActiveModel::AttributeAssignment
   include ::ActiveRecord::AttributeAssignment
-  include ::ActiveModel::Conversion
   include ::ActiveRecord::Integration
-  include ::ActiveModel::Validations
-  include ::ActiveSupport::Callbacks
-  include ::ActiveModel::Validations::HelperMethods
   include ::ActiveRecord::Validations
   include ::ActiveRecord::CounterCache
+  include ::ActiveModel::AttributeRegistration
   include ::ActiveRecord::Attributes
   include ::ActiveRecord::Locking::Optimistic
   include ::ActiveRecord::Locking::Pessimistic
@@ -1636,13 +1665,18 @@ class ActiveRecord::Base
   include ::ActiveRecord::Suppressor
   include ::ActiveRecord::Normalization
   include ::ActiveRecord::Marshalling::Methods
+  extend ::ActiveModel::Validations::ClassMethods
   extend ::ActiveModel::Naming
-  extend ::ActiveSupport::Benchmarkable
+  extend ::ActiveModel::Callbacks
+  extend ::ActiveSupport::Callbacks::ClassMethods
   extend ::ActiveSupport::DescendantsTracker
+  extend ::ActiveModel::Translation
+  extend ::ActiveModel::Validations::HelperMethods
+  extend ::ActiveModel::Conversion::ClassMethods
+  extend ::ActiveSupport::Benchmarkable
   extend ::ActiveRecord::ConnectionHandling
   extend ::ActiveRecord::QueryCache::ClassMethods
   extend ::ActiveRecord::Querying
-  extend ::ActiveModel::Translation
   extend ::ActiveRecord::Translation
   extend ::ActiveRecord::DynamicMatchers
   extend ::ActiveRecord::DelegatedType
@@ -1659,14 +1693,10 @@ class ActiveRecord::Base
   extend ::ActiveRecord::Scoping::Default::ClassMethods
   extend ::ActiveRecord::Scoping::Named::ClassMethods
   extend ::ActiveRecord::Sanitization::ClassMethods
-  extend ::ActiveModel::Conversion::ClassMethods
   extend ::ActiveRecord::Integration::ClassMethods
-  extend ::ActiveModel::Validations::ClassMethods
-  extend ::ActiveModel::Callbacks
-  extend ::ActiveSupport::Callbacks::ClassMethods
-  extend ::ActiveModel::Validations::HelperMethods
   extend ::ActiveRecord::Validations::ClassMethods
   extend ::ActiveRecord::CounterCache::ClassMethods
+  extend ::ActiveModel::AttributeRegistration::ClassMethods
   extend ::ActiveRecord::Attributes::ClassMethods
   extend ::ActiveRecord::Locking::Optimistic::ClassMethods
   extend ::ActiveRecord::Encryption::EncryptableRecord::ClassMethods
@@ -1734,13 +1764,17 @@ class ActiveRecord::Base
   def attribute_method_patterns?; end
   def automatic_scope_inversing; end
   def automatic_scope_inversing?; end
+  def automatically_invert_plural_associations; end
+  def automatically_invert_plural_associations?; end
   def cache_timestamp_format; end
   def cache_timestamp_format?; end
   def cache_versioning; end
   def cache_versioning?; end
   def collection_cache_versioning; end
   def collection_cache_versioning?; end
-  def column_for_attribute(name, &block); end
+  def column_for_attribute(name, &_arg1); end
+  def counter_cached_association_names; end
+  def counter_cached_association_names?; end
   def default_connection_handler; end
   def default_connection_handler?; end
   def default_role; end
@@ -1752,7 +1786,7 @@ class ActiveRecord::Base
   def defined_enums; end
   def defined_enums?; end
   def destroy_association_async_batch_size; end
-  def destroy_association_async_job(&block); end
+  def destroy_association_async_job(&_arg0); end
   def encrypted_attributes; end
   def encrypted_attributes=(_arg0); end
   def encrypted_attributes?; end
@@ -1762,7 +1796,7 @@ class ActiveRecord::Base
   def lock_optimistically?; end
   def logger; end
   def logger?; end
-  def model_name(&block); end
+  def model_name(&_arg0); end
   def nested_attributes_options; end
   def nested_attributes_options?; end
   def normalized_attributes; end
@@ -1796,7 +1830,7 @@ class ActiveRecord::Base
   def time_zone_aware_attributes?; end
   def time_zone_aware_types; end
   def time_zone_aware_types?; end
-  def type_for_attribute(attr_name, &block); end
+  def type_for_attribute(*_arg0, **_arg1, &_arg2); end
   def validation_context; end
 
   private
@@ -1869,12 +1903,15 @@ class ActiveRecord::Base
     def attribute_method_patterns; end
     def attribute_method_patterns=(value); end
     def attribute_method_patterns?; 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
+    def attributes_for_inspect; end
+    def attributes_for_inspect=(value); end
+    def attributes_for_inspect?; end
     def automatic_scope_inversing; end
     def automatic_scope_inversing=(value); end
     def automatic_scope_inversing?; end
+    def automatically_invert_plural_associations; end
+    def automatically_invert_plural_associations=(value); end
+    def automatically_invert_plural_associations?; end
     def before_create(*args, **options, &block); end
     def before_destroy(*args, **options, &block); end
     def before_save(*args, **options, &block); end
@@ -1900,6 +1937,9 @@ class ActiveRecord::Base
     def connection_class_for_self; end
     def connection_handler; end
     def connection_handler=(handler); end
+    def counter_cached_association_names; end
+    def counter_cached_association_names=(value); end
+    def counter_cached_association_names?; end
     def current_preventing_writes; end
     def current_role; end
     def current_shard; end
@@ -2064,6 +2104,7 @@ class ActiveRecord::Batches::BatchEnumerator
   def finish; end
   def relation; end
   def start; end
+  def touch_all(*_arg0, **_arg1, &_arg2); end
   def update_all(updates); end
 end
 
@@ -2094,6 +2135,7 @@ module ActiveRecord::Calculations
   def aggregate_column(column_name); end
   def all_attributes?(column_names); end
   def build_count_subquery(relation, column_name, distinct); end
+  def build_count_subquery?(operation, column_name, distinct); end
   def distinct_select?(column_name); end
   def execute_grouped_calculation(operation, column_name, distinct); end
   def execute_simple_calculation(operation, column_name, distinct); end
@@ -2216,6 +2258,11 @@ class ActiveRecord::ConfigurationError < ::ActiveRecord::ActiveRecordError; end
 
 module ActiveRecord::ConnectionAdapters
   extend ::ActiveSupport::Autoload
+
+  class << self
+    def register(name, class_name, path = T.unsafe(nil)); end
+    def resolve(adapter_name); end
+  end
 end
 
 class ActiveRecord::ConnectionAdapters::AbstractAdapter
@@ -2229,6 +2276,7 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter
   include ::ActiveRecord::ConnectionAdapters::Savepoints
   extend ::ActiveSupport::Callbacks::ClassMethods
   extend ::ActiveSupport::DescendantsTracker
+  extend ::ActiveRecord::ConnectionAdapters::Quoting::ClassMethods
 
   def initialize(config_or_deprecated_connection, deprecated_logger = T.unsafe(nil), deprecated_connection_options = T.unsafe(nil), deprecated_config = T.unsafe(nil)); end
 
@@ -2242,7 +2290,6 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter
   def adapter_name; end
   def add_enum_value(*_arg0); end
   def advisory_locks_enabled?; end
-  def all_foreign_keys_valid?(*args, **_arg1, &block); end
   def async_enabled?; end
   def build_insert_sql(insert); end
   def case_insensitive_comparison(attribute, value); end
@@ -2254,6 +2301,7 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter
   def clear_cache!(new_connection: T.unsafe(nil)); end
   def close; end
   def connect!; end
+  def connected?; end
   def connection_class; end
   def connection_retries; end
   def create(*_arg0, **_arg1, &_arg2); end
@@ -2280,13 +2328,11 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter
   def in_use?; end
   def index_algorithms; end
   def insert(*_arg0, **_arg1, &_arg2); end
-  def internal_metadata; end
+  def inspect; end
   def lease; end
   def lock; end
   def lock_thread=(lock_thread); end
   def logger; end
-  def migration_context; end
-  def migrations_paths; end
   def owner; end
   def pool; end
   def pool=(value); end
@@ -2311,7 +2357,6 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter
   def rollback_to_savepoint(*_arg0, **_arg1, &_arg2); end
   def savepoint_errors_invalidate_transactions?; end
   def schema_cache; end
-  def schema_migration; end
   def schema_version; end
   def seconds_idle; end
   def shard; end
@@ -2358,7 +2403,6 @@ class ActiveRecord::ConnectionAdapters::AbstractAdapter
   def truncate_tables(*_arg0, **_arg1, &_arg2); end
   def unprepared_statement; end
   def update(*_arg0, **_arg1, &_arg2); end
-  def use_metadata_table?; end
   def valid_type?(type); end
   def verify!; end
   def visitor; end
@@ -2428,9 +2472,7 @@ ActiveRecord::ConnectionAdapters::AbstractAdapter::DEFAULT_READ_QUERY = T.let(T.
 ActiveRecord::ConnectionAdapters::AbstractAdapter::EXCEPTION_IMMEDIATE = T.let(T.unsafe(nil), Hash)
 ActiveRecord::ConnectionAdapters::AbstractAdapter::EXCEPTION_NEVER = T.let(T.unsafe(nil), Hash)
 ActiveRecord::ConnectionAdapters::AbstractAdapter::EXTENDED_TYPE_MAPS = T.let(T.unsafe(nil), Concurrent::Map)
-ActiveRecord::ConnectionAdapters::AbstractAdapter::FIBER_LOCK = T.let(T.unsafe(nil), ActiveSupport::Concurrency::LoadInterlockAwareMonitor)
 ActiveRecord::ConnectionAdapters::AbstractAdapter::SIMPLE_INT = T.let(T.unsafe(nil), Regexp)
-ActiveRecord::ConnectionAdapters::AbstractAdapter::THREAD_LOCK = T.let(T.unsafe(nil), ActiveSupport::Concurrency::ThreadLoadInterlockAwareMonitor)
 ActiveRecord::ConnectionAdapters::AbstractAdapter::TYPE_MAP = T.let(T.unsafe(nil), ActiveRecord::Type::TypeMap)
 
 class ActiveRecord::ConnectionAdapters::AbstractAdapter::Version
@@ -2475,7 +2517,7 @@ class ActiveRecord::ConnectionAdapters::AlterTable
 end
 
 class ActiveRecord::ConnectionAdapters::BoundSchemaReflection
-  def initialize(abstract_schema_reflection, connection); end
+  def initialize(abstract_schema_reflection, pool); end
 
   def add(name); end
   def cached?(table_name); end
@@ -2486,13 +2528,22 @@ class ActiveRecord::ConnectionAdapters::BoundSchemaReflection
   def columns_hash?(table_name); end
   def data_source_exists?(name); end
   def data_sources(name); end
-  def database_version; end
   def dump_to(filename); end
   def indexes(table_name); end
   def load!; end
   def primary_keys(table_name); end
   def size; end
   def version; end
+
+  class << self
+    def for_lone_connection(abstract_schema_reflection, connection); end
+  end
+end
+
+class ActiveRecord::ConnectionAdapters::BoundSchemaReflection::FakePool
+  def initialize(connection); end
+
+  def with_connection; end
 end
 
 class ActiveRecord::ConnectionAdapters::ChangeColumnDefaultDefinition < ::Struct
@@ -2641,7 +2692,6 @@ class ActiveRecord::ConnectionAdapters::ConnectionHandler
   def initialize; 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
@@ -2656,12 +2706,11 @@ class ActiveRecord::ConnectionAdapters::ConnectionHandler
   def prevent_writes=(prevent_writes); end
   def remove_connection_pool(connection_name, role: T.unsafe(nil), shard: T.unsafe(nil)); end
   def retrieve_connection(connection_name, role: T.unsafe(nil), shard: T.unsafe(nil)); end
-  def retrieve_connection_pool(connection_name, role: T.unsafe(nil), shard: T.unsafe(nil)); end
+  def retrieve_connection_pool(connection_name, role: T.unsafe(nil), shard: T.unsafe(nil), strict: T.unsafe(nil)); end
 
   private
 
   def connection_name_to_pool_manager; end
-  def deprecation_for_pool_handling(method); end
   def determine_owner_name(owner_name, config); end
   def disconnect_pool_from_pool_manager(pool_manager, role, shard); end
   def get_pool_manager(connection_name); end
@@ -2670,8 +2719,6 @@ class ActiveRecord::ConnectionAdapters::ConnectionHandler
   def set_pool_manager(connection_name); end
 end
 
-ActiveRecord::ConnectionAdapters::ConnectionHandler::FINALIZER = T.let(T.unsafe(nil), Proc)
-
 class ActiveRecord::ConnectionAdapters::ConnectionHandler::StringConnectionName
   def initialize(name); end
 
@@ -2681,18 +2728,20 @@ class ActiveRecord::ConnectionAdapters::ConnectionHandler::StringConnectionName
 end
 
 class ActiveRecord::ConnectionAdapters::ConnectionPool
-  include ::MonitorMixin
   include ::ActiveRecord::ConnectionAdapters::QueryCache::ConnectionPoolConfiguration
+  include ::MonitorMixin
   include ::ActiveRecord::ConnectionAdapters::AbstractPool
 
-  def initialize(pool_config); end
+  def initialize(*_arg0, **_arg1, &_arg2); end
 
+  def active_connection; end
   def active_connection?; end
   def async_executor; end
   def automatic_reconnect; end
   def automatic_reconnect=(_arg0); end
   def checkin(conn); end
   def checkout(checkout_timeout = T.unsafe(nil)); end
+  def checkout_and_verify(connection); end
   def checkout_timeout; end
   def checkout_timeout=(_arg0); end
   def clear_reloadable_connections(raise_on_acquisition_timeout = T.unsafe(nil)); end
@@ -2700,7 +2749,6 @@ class ActiveRecord::ConnectionAdapters::ConnectionPool
   def connected?; end
   def connection; end
   def connection_class; end
-  def connection_klass(*args, **_arg1, &block); end
   def connections; end
   def db_config; end
   def discard!; end
@@ -2709,21 +2757,31 @@ class ActiveRecord::ConnectionAdapters::ConnectionPool
   def disconnect!; end
   def flush(minimum_idle = T.unsafe(nil)); end
   def flush!; end
-  def lock_thread=(lock_thread); end
+  def inspect; end
+  def internal_metadata; end
+  def lease_connection; end
+  def migration_context; end
+  def migrations_paths; end
   def num_waiting_in_queue; end
+  def permanent_lease?; end
+  def pin_connection!(lock_thread); end
   def pool_config; end
   def reap; end
   def reaper; end
-  def release_connection(owner_thread = T.unsafe(nil)); end
+  def release_connection(existing_lease = T.unsafe(nil)); end
   def remove(conn); end
   def role; end
   def schedule_query(future_result); end
+  def schema_cache; end
+  def schema_migration; end
   def schema_reflection(*_arg0, **_arg1, &_arg2); end
-  def schema_reflection=(arg); end
+  def schema_reflection=(schema_reflection); end
+  def server_version(*_arg0, **_arg1, &_arg2); end
   def shard; end
   def size; end
   def stat; end
-  def with_connection; end
+  def unpin_connection!; end
+  def with_connection(prevent_permanent_checkout: T.unsafe(nil)); end
 
   private
 
@@ -2732,17 +2790,19 @@ class ActiveRecord::ConnectionAdapters::ConnectionPool
   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
   def checkout_new_connection; end
-  def connection_cache_key(thread); end
-  def current_thread; end
+  def connection_lease; end
   def new_connection; end
   def release(conn, owner_thread = T.unsafe(nil)); end
   def remove_connection_from_thread_cache(conn, owner_thread = T.unsafe(nil)); end
   def try_to_checkout_new_connection; end
   def with_exclusively_acquired_all_connections(raise_on_acquisition_timeout = T.unsafe(nil)); end
   def with_new_connections_blocked; end
+
+  class << self
+    def install_executor_hooks(executor = T.unsafe(nil)); end
+  end
 end
 
 module ActiveRecord::ConnectionAdapters::ConnectionPool::BiasableQueue
@@ -2766,6 +2826,31 @@ class ActiveRecord::ConnectionAdapters::ConnectionPool::ConnectionLeasingQueue <
   def internal_poll(timeout); end
 end
 
+module ActiveRecord::ConnectionAdapters::ConnectionPool::ExecutorHooks
+  class << self
+    def complete(_); end
+    def run; end
+  end
+end
+
+class ActiveRecord::ConnectionAdapters::ConnectionPool::Lease
+  def initialize; end
+
+  def clear(connection); end
+  def connection; end
+  def connection=(_arg0); end
+  def release; end
+  def sticky; end
+  def sticky=(_arg0); end
+end
+
+class ActiveRecord::ConnectionAdapters::ConnectionPool::LeaseRegistry
+  def initialize; end
+
+  def [](context); end
+  def clear; end
+end
+
 class ActiveRecord::ConnectionAdapters::ConnectionPool::Queue
   def initialize(lock = T.unsafe(nil)); end
 
@@ -2803,6 +2888,14 @@ class ActiveRecord::ConnectionAdapters::ConnectionPool::Reaper
   end
 end
 
+class ActiveRecord::ConnectionAdapters::ConnectionPool::WeakThreadKeyMap
+  def initialize; end
+
+  def [](key); end
+  def []=(key, value); end
+  def clear; end
+end
+
 class ActiveRecord::ConnectionAdapters::CreateIndexDefinition < ::Struct
   def algorithm; end
   def algorithm=(_); end
@@ -2862,7 +2955,7 @@ module ActiveRecord::ConnectionAdapters::DatabaseStatements
   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), returning: 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 internal_exec_query(sql, name = T.unsafe(nil), binds = T.unsafe(nil), prepare: T.unsafe(nil), async: T.unsafe(nil)); end
+  def internal_exec_query(sql, name = T.unsafe(nil), binds = T.unsafe(nil), prepare: T.unsafe(nil), async: T.unsafe(nil), allow_retry: T.unsafe(nil)); end
   def mark_transaction_written_if_write(sql); end
   def materialize_transactions(*_arg0, **_arg1, &_arg2); end
   def open_transactions(*_arg0, **_arg1, &_arg2); end
@@ -2876,7 +2969,7 @@ module ActiveRecord::ConnectionAdapters::DatabaseStatements
   def rollback_to_savepoint(name = T.unsafe(nil)); end
   def rollback_transaction(*_arg0, **_arg1, &_arg2); end
   def sanitize_limit(limit); end
-  def select_all(arel, name = T.unsafe(nil), binds = T.unsafe(nil), preparable: T.unsafe(nil), async: T.unsafe(nil)); end
+  def select_all(arel, name = T.unsafe(nil), binds = T.unsafe(nil), preparable: T.unsafe(nil), async: T.unsafe(nil), allow_retry: T.unsafe(nil)); end
   def select_one(arel, name = T.unsafe(nil), binds = T.unsafe(nil), async: T.unsafe(nil)); end
   def select_rows(arel, name = T.unsafe(nil), binds = T.unsafe(nil), async: T.unsafe(nil)); end
   def select_value(arel, name = T.unsafe(nil), binds = T.unsafe(nil), async: T.unsafe(nil)); end
@@ -2908,10 +3001,10 @@ module ActiveRecord::ConnectionAdapters::DatabaseStatements
   def last_inserted_id(result); end
   def raw_execute(sql, name, async: T.unsafe(nil), allow_retry: T.unsafe(nil), materialize_transactions: T.unsafe(nil)); end
   def returning_column_values(result); end
-  def select(sql, name = T.unsafe(nil), binds = T.unsafe(nil), prepare: T.unsafe(nil), async: T.unsafe(nil)); end
+  def select(sql, name = T.unsafe(nil), binds = T.unsafe(nil), prepare: T.unsafe(nil), async: T.unsafe(nil), allow_retry: T.unsafe(nil)); end
   def single_value_from_rows(rows); end
   def sql_for_insert(sql, pk, binds, returning); end
-  def to_sql_and_binds(arel_or_sql_string, binds = T.unsafe(nil), preparable = T.unsafe(nil)); end
+  def to_sql_and_binds(arel_or_sql_string, binds = T.unsafe(nil), preparable = T.unsafe(nil), allow_retry = T.unsafe(nil)); end
   def with_multi_statements; end
 end
 
@@ -3001,37 +3094,45 @@ end
 class ActiveRecord::ConnectionAdapters::NullPool
   include ::ActiveRecord::ConnectionAdapters::AbstractPool
 
+  def initialize; end
+
   def async_executor; end
   def checkin(_); end
   def connection_class; end
   def db_config; end
+  def dirties_query_cache; end
   def remove(_); end
+  def schema_cache; end
   def schema_reflection; end
+  def server_version(connection); end
 end
 
 ActiveRecord::ConnectionAdapters::NullPool::NULL_CONFIG = T.let(T.unsafe(nil), ActiveRecord::ConnectionAdapters::NullPool::NullConfig)
 
 class ActiveRecord::ConnectionAdapters::NullPool::NullConfig
-  def method_missing(*_arg0); end
+  def method_missing(*_arg0, **_arg1, &_arg2); end
 end
 
 class ActiveRecord::ConnectionAdapters::NullTransaction
-  def initialize; end
-
   def add_record(record, _ = T.unsafe(nil)); end
+  def after_commit; end
+  def after_rollback; end
+  def before_commit; end
   def closed?; end
   def dirty!; end
   def dirty?; end
   def invalidate!; end
   def invalidated?; end
   def joinable?; end
+  def materialized?; end
   def open?; end
   def restartable?; end
   def state; end
+  def user_transaction; end
 end
 
 class ActiveRecord::ConnectionAdapters::PoolConfig
-  include ::Mutex_m
+  include ::MonitorMixin
 
   def initialize(connection_class, db_config, role, shard); end
 
@@ -3041,16 +3142,13 @@ class ActiveRecord::ConnectionAdapters::PoolConfig
   def db_config; end
   def discard_pool!; end
   def disconnect!(automatic_reconnect: T.unsafe(nil)); end
-  def lock; end
-  def locked?; end
   def pool; end
   def role; end
   def schema_reflection; end
   def schema_reflection=(_arg0); end
+  def server_version(connection); end
+  def server_version=(_arg0); end
   def shard; end
-  def synchronize(&block); end
-  def try_lock; end
-  def unlock; end
 
   class << self
     def discard_pools!; end
@@ -3089,21 +3187,22 @@ end
 module ActiveRecord::ConnectionAdapters::QueryCache
   def initialize(*_arg0); end
 
-  def cache; end
+  def cache(&block); end
   def clear_query_cache; end
   def disable_query_cache!; end
   def enable_query_cache!; end
   def query_cache; end
+  def query_cache=(_arg0); end
   def query_cache_enabled; 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
+  def select_all(arel, name = T.unsafe(nil), binds = T.unsafe(nil), preparable: T.unsafe(nil), async: T.unsafe(nil), allow_retry: T.unsafe(nil)); end
+  def uncached(dirties: T.unsafe(nil), &block); end
 
   private
 
   def cache_notification_info(sql, name, binds); end
   def cache_sql(sql, name, binds); end
-  def configure_query_cache!; end
   def lookup_sql_cache(sql, name, binds); end
+  def unset_query_cache!; end
 
   class << self
     def dirties_query_cache(base, *method_names); end
@@ -3112,22 +3211,56 @@ module ActiveRecord::ConnectionAdapters::QueryCache
 end
 
 module ActiveRecord::ConnectionAdapters::QueryCache::ConnectionPoolConfiguration
-  def initialize(*_arg0); end
+  def initialize(*_arg0, **_arg1, &_arg2); end
 
+  def checkout_and_verify(connection); end
+  def clear_query_cache; end
+  def dirties_query_cache; end
+  def disable_query_cache(dirties: T.unsafe(nil)); end
   def disable_query_cache!; end
+  def enable_query_cache; end
   def enable_query_cache!; end
+  def query_cache; end
   def query_cache_enabled; end
 end
 
 ActiveRecord::ConnectionAdapters::QueryCache::DEFAULT_SIZE = T.let(T.unsafe(nil), Integer)
 
+class ActiveRecord::ConnectionAdapters::QueryCache::QueryCacheRegistry
+  def initialize; end
+
+  def clear; end
+  def compute_if_absent(context); end
+end
+
+class ActiveRecord::ConnectionAdapters::QueryCache::Store
+  def initialize(version, max_size); end
+
+  def [](key); end
+  def clear; end
+  def compute_if_absent(key); end
+  def dirties; end
+  def dirties=(_arg0); end
+  def dirties?; end
+  def empty?; end
+  def enabled; end
+  def enabled=(_arg0); end
+  def enabled?; end
+  def size; end
+
+  private
+
+  def check_version; end
+end
+
 module ActiveRecord::ConnectionAdapters::Quoting
+  extend ::ActiveSupport::Concern
+
+  mixes_in_class_methods ::ActiveRecord::ConnectionAdapters::Quoting::ClassMethods
+
   def cast_bound_value(value); end
-  def column_name_matcher; end
-  def column_name_with_order_matcher; end
   def lookup_cast_type_from_column(column); end
   def quote(value); end
-  def quote_bound_value(value); end
   def quote_column_name(column_name); end
   def quote_default_expression(value, column); end
   def quote_string(s); end
@@ -3147,11 +3280,14 @@ module ActiveRecord::ConnectionAdapters::Quoting
 
   def lookup_cast_type(sql_type); end
   def type_casted_binds(binds); end
-  def warn_quote_duration_deprecated; end
 end
 
-ActiveRecord::ConnectionAdapters::Quoting::COLUMN_NAME = T.let(T.unsafe(nil), Regexp)
-ActiveRecord::ConnectionAdapters::Quoting::COLUMN_NAME_WITH_ORDER = T.let(T.unsafe(nil), Regexp)
+module ActiveRecord::ConnectionAdapters::Quoting::ClassMethods
+  def column_name_matcher; end
+  def column_name_with_order_matcher; end
+  def quote_column_name(column_name); end
+  def quote_table_name(table_name); end
+end
 
 class ActiveRecord::ConnectionAdapters::RealTransaction < ::ActiveRecord::ConnectionAdapters::Transaction
   def commit; end
@@ -3217,26 +3353,24 @@ end
 class ActiveRecord::ConnectionAdapters::SchemaCache
   def initialize; end
 
-  def add(connection, table_name); end
-  def add_all(connection); end
+  def add(pool, table_name); end
+  def add_all(pool); end
   def cached?(table_name); end
   def clear_data_source_cache!(_connection, name); end
-  def columns(connection, table_name); end
-  def columns_hash(connection, table_name); end
-  def columns_hash?(connection, table_name); end
-  def data_source_exists?(connection, name); end
-  def data_sources(*args, **_arg1, &block); end
-  def database_version(connection); end
+  def columns(pool, table_name); end
+  def columns_hash(pool, table_name); end
+  def columns_hash?(_pool, table_name); end
+  def data_source_exists?(pool, name); end
   def dump_to(filename); end
   def encode_with(coder); end
-  def indexes(connection, table_name); end
+  def indexes(pool, table_name); end
   def init_with(coder); end
   def marshal_dump; end
   def marshal_load(array); end
-  def primary_keys(connection, table_name); end
+  def primary_keys(pool, table_name); end
   def schema_version; end
   def size; end
-  def version(connection); end
+  def version(pool); end
 
   private
 
@@ -3245,13 +3379,10 @@ class ActiveRecord::ConnectionAdapters::SchemaCache
   def ignored_table?(table_name); end
   def initialize_dup(other); end
   def open(filename); end
-  def prepare_data_sources(connection); end
-  def tables_to_cache(connection); end
+  def tables_to_cache(pool); end
 
   class << self
     def _load_from(filename); end
-    def load_from(*args, **_arg1, &block); end
-    def new(*args, **_arg1, &block); end
 
     private
 
@@ -3329,29 +3460,27 @@ ActiveRecord::ConnectionAdapters::SchemaDumper::DEFAULT_DATETIME_PRECISION = T.l
 class ActiveRecord::ConnectionAdapters::SchemaReflection
   def initialize(cache_path, cache = T.unsafe(nil)); end
 
-  def add(connection, name); end
+  def add(pool, name); end
   def cached?(table_name); end
   def clear!; end
-  def clear_data_source_cache!(connection, name); end
-  def columns(connection, table_name); end
-  def columns_hash(connection, table_name); end
-  def columns_hash?(connection, table_name); end
-  def data_source_exists?(connection, name); end
-  def data_sources(connection, name); end
-  def database_version(connection); end
-  def dump_to(connection, filename); end
-  def indexes(connection, table_name); end
-  def load!(connection); end
-  def primary_keys(connection, table_name); end
-  def set_schema_cache(cache); end
-  def size(connection); end
-  def version(connection); end
-
-  private
-
-  def cache(connection); end
+  def clear_data_source_cache!(pool, name); end
+  def columns(pool, table_name); end
+  def columns_hash(pool, table_name); end
+  def columns_hash?(pool, table_name); end
+  def data_source_exists?(pool, name); end
+  def data_sources(pool, name); end
+  def dump_to(pool, filename); end
+  def indexes(pool, table_name); end
+  def load!(pool); end
+  def primary_keys(pool, table_name); end
+  def size(pool); end
+  def version(pool); end
+
+  private
+
+  def cache(pool); end
   def empty_cache; end
-  def load_cache(connection); end
+  def load_cache(pool); end
   def possible_cache_available?; end
 
   class << self
@@ -3480,7 +3609,7 @@ module ActiveRecord::ConnectionAdapters::SchemaStatements
   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 rename_table_indexes(table_name, new_name, **options); end
   def strip_table_name_prefix_and_suffix(table_name); end
   def validate_change_column_null_argument!(value); end
   def validate_create_table_options!(options); end
@@ -3621,6 +3750,9 @@ 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, ensure_finalize = T.unsafe(nil)); end
+  def after_commit(&block); end
+  def after_rollback(&block); end
+  def before_commit(&block); end
   def before_commit_records; end
   def closed?; end
   def commit_records; end
@@ -3642,9 +3774,14 @@ class ActiveRecord::ConnectionAdapters::Transaction
   def rollback_records; end
   def savepoint_name; end
   def state; end
+  def user_transaction; end
   def written; end
   def written=(_arg0); end
 
+  protected
+
+  def append_callbacks(callbacks); end
+
   private
 
   def prepare_instances_to_run_callbacks_on(records); end
@@ -3652,6 +3789,14 @@ class ActiveRecord::ConnectionAdapters::Transaction
   def unique_records; end
 end
 
+class ActiveRecord::ConnectionAdapters::Transaction::Callback
+  def initialize(event, callback); end
+
+  def after_commit; end
+  def after_rollback; end
+  def before_commit; end
+end
+
 class ActiveRecord::ConnectionAdapters::TransactionInstrumenter
   def initialize(payload = T.unsafe(nil)); end
 
@@ -3709,11 +3854,9 @@ end
 class ActiveRecord::ConnectionFailed < ::ActiveRecord::QueryAborted; end
 
 module ActiveRecord::ConnectionHandling
-  def clear_active_connections!(role = T.unsafe(nil)); end
-  def clear_all_connections!(role = T.unsafe(nil)); end
+  def adapter_class; end
   def clear_cache!; end
   def clear_query_caches_for_current_thread; end
-  def clear_reloadable_connections!(role = T.unsafe(nil)); end
   def connected?; 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
@@ -3726,18 +3869,20 @@ module ActiveRecord::ConnectionHandling
   def connection_specification_name=(_arg0); end
   def connects_to(database: T.unsafe(nil), shards: T.unsafe(nil)); end
   def establish_connection(config_or_env = T.unsafe(nil)); end
-  def flush_idle_connections!(role = T.unsafe(nil)); end
+  def lease_connection; end
   def primary_class?; end
   def prohibit_shard_swapping(enabled = T.unsafe(nil)); end
-  def remove_connection(name = T.unsafe(nil)); end
+  def release_connection; end
+  def remove_connection; end
   def retrieve_connection; end
+  def schema_cache; end
   def shard_swapping_prohibited?; end
   def while_preventing_writes(enabled = T.unsafe(nil), &block); end
+  def with_connection(prevent_permanent_checkout: T.unsafe(nil), &block); end
 
   private
 
   def append_to_connected_to_stack(entry); end
-  def deprecation_for_delegation(method); end
   def resolve_config_for_connection(config_or_env); end
   def with_role_and_shard(role, shard, prevent_writes); end
 end
@@ -3771,6 +3916,7 @@ module ActiveRecord::Core
   def eql?(comparison_object); end
   def freeze; end
   def frozen?; end
+  def full_inspect; end
   def hash; end
   def init_with(coder, &block); end
   def init_with_attributes(attributes, new_record = T.unsafe(nil)); end
@@ -3781,15 +3927,19 @@ module ActiveRecord::Core
   def readonly?; end
   def strict_loading!(value = T.unsafe(nil), mode: T.unsafe(nil)); end
   def strict_loading?; end
+  def strict_loading_all?; end
   def strict_loading_mode; end
   def strict_loading_n_plus_one_only?; end
 
   private
 
+  def all_attributes_for_inspect; end
+  def attributes_for_inspect; end
   def custom_inspect_method_defined?; end
   def init_internals; end
   def initialize_dup(other); end
   def initialize_internals_callback; end
+  def inspect_with_attributes(attributes_to_list); end
   def inspection_filter; end
   def to_ary; end
 
@@ -3797,6 +3947,9 @@ module ActiveRecord::Core
     def _destroy_association_async_job; end
     def _destroy_association_async_job=(value); end
     def _destroy_association_async_job?; end
+    def attributes_for_inspect; end
+    def attributes_for_inspect=(value); end
+    def attributes_for_inspect?; end
     def belongs_to_required_by_default; end
     def belongs_to_required_by_default=(value); end
     def belongs_to_required_by_default?; end
@@ -3846,7 +3999,7 @@ end
 
 module ActiveRecord::Core::ClassMethods
   def arel_table; end
-  def cached_find_by_statement(key, &block); end
+  def cached_find_by_statement(connection, key, &block); end
   def filter_attributes; end
   def filter_attributes=(filter_attributes); end
   def find(*ids); end
@@ -3882,22 +4035,29 @@ module ActiveRecord::CounterCache
   private
 
   def _create_record(attribute_names = T.unsafe(nil)); end
+  def _foreign_keys_equal?(fkey1, fkey2); end
   def destroy_row; end
-  def each_counter_cached_associations; end
 
   module GeneratedClassMethods
     def _counter_cache_columns; end
     def _counter_cache_columns=(value); end
     def _counter_cache_columns?; end
+    def counter_cached_association_names; end
+    def counter_cached_association_names=(value); end
+    def counter_cached_association_names?; end
   end
 
-  module GeneratedInstanceMethods; end
+  module GeneratedInstanceMethods
+    def counter_cached_association_names; end
+    def counter_cached_association_names?; end
+  end
 end
 
 module ActiveRecord::CounterCache::ClassMethods
   def counter_cache_column?(name); end
   def decrement_counter(counter_name, id, by: T.unsafe(nil), touch: T.unsafe(nil)); end
   def increment_counter(counter_name, id, by: T.unsafe(nil), touch: T.unsafe(nil)); end
+  def load_schema!; end
   def reset_counters(id, *counters, touch: T.unsafe(nil)); end
   def update_counters(id, counters); end
 end
@@ -3949,6 +4109,7 @@ class ActiveRecord::DatabaseConfigurations::ConnectionUrlResolver
   def database_from_path; end
   def query_hash; end
   def raw_config; end
+  def resolved_adapter; end
   def uri; end
   def uri_parser; end
 end
@@ -3958,24 +4119,27 @@ class ActiveRecord::DatabaseConfigurations::DatabaseConfig
 
   def _database=(database); end
   def adapter; end
-  def adapter_class_method; end
-  def adapter_method; end
+  def adapter_class; end
   def checkout_timeout; end
   def database; end
   def env_name; end
   def for_current_env?; end
   def host; end
   def idle_timeout; end
+  def inspect; end
   def max_queue; end
   def max_threads; end
   def migrations_paths; end
   def min_threads; end
   def name; end
+  def new_connection; end
   def pool; end
   def query_cache; end
   def reaping_frequency; end
   def replica?; end
   def schema_cache_path; end
+  def use_metadata_table?; end
+  def validate!; end
 end
 
 class ActiveRecord::DatabaseConfigurations::HashConfig < ::ActiveRecord::DatabaseConfigurations::DatabaseConfig
@@ -3987,7 +4151,7 @@ class ActiveRecord::DatabaseConfigurations::HashConfig < ::ActiveRecord::Databas
   def configuration_hash; end
   def database; end
   def database_tasks?; end
-  def default_schema_cache_path; end
+  def default_schema_cache_path(db_dir = T.unsafe(nil)); end
   def host; end
   def idle_timeout; end
   def lazy_schema_cache_path; end
@@ -4003,6 +4167,7 @@ class ActiveRecord::DatabaseConfigurations::HashConfig < ::ActiveRecord::Databas
   def schema_cache_path; end
   def schema_dump(format = T.unsafe(nil)); end
   def socket; end
+  def use_metadata_table?; end
 
   private
 
@@ -4019,6 +4184,7 @@ class ActiveRecord::DatabaseConfigurations::UrlConfig < ::ActiveRecord::Database
   private
 
   def build_url_hash; end
+  def to_boolean!(configuration_hash, key); end
 end
 
 class ActiveRecord::DatabaseConnectionError < ::ActiveRecord::ConnectionNotEstablished
@@ -4030,6 +4196,7 @@ class ActiveRecord::DatabaseConnectionError < ::ActiveRecord::ConnectionNotEstab
   end
 end
 
+class ActiveRecord::DatabaseVersionError < ::ActiveRecord::ActiveRecordError; end
 class ActiveRecord::Deadlocked < ::ActiveRecord::TransactionRollbackError; end
 
 module ActiveRecord::DelegatedType
@@ -4059,6 +4226,7 @@ module ActiveRecord::Delegation
   def index(*_arg0, **_arg1, &_arg2); end
   def intersect?(*_arg0, **_arg1, &_arg2); end
   def join(*_arg0, **_arg1, &_arg2); end
+  def lease_connection(*_arg0, **_arg1, &_arg2); end
   def length(*_arg0, **_arg1, &_arg2); end
   def primary_key(*_arg0, **_arg1, &_arg2); end
   def reverse(*_arg0, **_arg1, &_arg2); end
@@ -4073,6 +4241,7 @@ module ActiveRecord::Delegation
   def to_sentence(*_arg0, **_arg1, &_arg2); end
   def to_xml(*_arg0, **_arg1, &_arg2); end
   def transaction(*_arg0, **_arg1, &_arg2); end
+  def with_connection(*_arg0, **_arg1, &_arg2); end
   def |(*_arg0, **_arg1, &_arg2); end
 
   private
@@ -4100,7 +4269,7 @@ module ActiveRecord::Delegation::ClassSpecificRelation
 
   private
 
-  def method_missing(method, *args, **_arg2, &block); end
+  def method_missing(method, *_arg1, **_arg2, &_arg3); end
 end
 
 module ActiveRecord::Delegation::ClassSpecificRelation::ClassMethods
@@ -4123,21 +4292,15 @@ module ActiveRecord::Delegation::DelegateCache
 end
 
 class ActiveRecord::Delegation::GeneratedRelationMethods < ::Module
-  include ::Mutex_m
-
   def generate_method(method); end
-  def lock; end
-  def locked?; end
-  def synchronize(&block); end
-  def try_lock; end
-  def unlock; end
 end
 
+ActiveRecord::Delegation::GeneratedRelationMethods::MUTEX = T.let(T.unsafe(nil), Thread::Mutex)
+
 class ActiveRecord::DeleteRestrictionError < ::ActiveRecord::ActiveRecordError
   def initialize(name = T.unsafe(nil)); end
 end
 
-class ActiveRecord::DeprecatedActiveJobRequiredError < ::ActiveRecord::ActiveRecordError; end
 class ActiveRecord::DestroyAssociationAsyncError < ::StandardError; end
 
 class ActiveRecord::DisableJoinsAssociationRelation < ::ActiveRecord::Relation
@@ -4161,7 +4324,7 @@ end
 module ActiveRecord::DynamicMatchers
   private
 
-  def method_missing(name, *arguments, &block); end
+  def method_missing(name, *_arg1, **_arg2, &_arg3); end
   def respond_to_missing?(name, _); end
 end
 
@@ -4456,7 +4619,7 @@ end
 
 ActiveRecord::Encryption::EncryptableRecord::ORIGINAL_ATTRIBUTE_PREFIX = T.let(T.unsafe(nil), String)
 
-class ActiveRecord::Encryption::EncryptedAttributeType < ::ActiveRecord::Type::Text
+class ActiveRecord::Encryption::EncryptedAttributeType < ::ActiveModel::Type::Value
   include ::ActiveModel::Type::Helpers::Mutable
 
   def initialize(scheme:, cast_type: T.unsafe(nil), previous_type: T.unsafe(nil), default: T.unsafe(nil)); end
@@ -4476,6 +4639,7 @@ class ActiveRecord::Encryption::EncryptedAttributeType < ::ActiveRecord::Type::T
   def scheme; end
   def serialize(value); end
   def support_unencrypted_data?; end
+  def type(*_arg0, **_arg1, &_arg2); end
   def with_context(*_arg0, **_arg1, &_arg2); end
 
   private
@@ -4483,8 +4647,10 @@ class ActiveRecord::Encryption::EncryptedAttributeType < ::ActiveRecord::Type::T
   def build_previous_types_for(schemes); end
   def clean_text_scheme; end
   def decrypt(value); end
+  def decrypt_as_text(value); end
   def decryption_options; end
   def encrypt(value); end
+  def encrypt_as_text(value); end
   def encryption_options; end
   def encryptor; end
   def handle_deserialize_error(error, value); end
@@ -4494,6 +4660,7 @@ class ActiveRecord::Encryption::EncryptedAttributeType < ::ActiveRecord::Type::T
   def serialize_with_current(value); end
   def serialize_with_oldest(value); end
   def serialize_with_oldest?; end
+  def text_to_database_type(value); end
   def try_to_deserialize_with_previous_encrypted_types(value); end
 end
 
@@ -4511,6 +4678,9 @@ class ActiveRecord::Encryption::EncryptingOnlyEncryptor < ::ActiveRecord::Encryp
 end
 
 class ActiveRecord::Encryption::Encryptor
+  def initialize(compress: T.unsafe(nil)); end
+
+  def binary?; end
   def decrypt(encrypted_text, key_provider: T.unsafe(nil), cipher_options: T.unsafe(nil)); end
   def encrypt(clear_text, key_provider: T.unsafe(nil), cipher_options: T.unsafe(nil)); end
   def encrypted?(text); end
@@ -4520,6 +4690,7 @@ class ActiveRecord::Encryption::Encryptor
   def build_encrypted_message(clear_text, key_provider:, cipher_options:); end
   def cipher; end
   def compress(data); end
+  def compress?; end
   def compress_if_worth_it(string); end
   def default_key_provider; end
   def deserialize_message(message); end
@@ -4668,6 +4839,7 @@ class ActiveRecord::Encryption::Message
 end
 
 class ActiveRecord::Encryption::MessageSerializer
+  def binary?; end
   def dump(message); end
   def load(serialized_content); end
 
@@ -4683,6 +4855,7 @@ class ActiveRecord::Encryption::MessageSerializer
 end
 
 class ActiveRecord::Encryption::NullEncryptor
+  def binary?; end
   def decrypt(encrypted_text, key_provider: T.unsafe(nil), cipher_options: T.unsafe(nil)); end
   def encrypt(clean_text, key_provider: T.unsafe(nil), cipher_options: T.unsafe(nil)); end
   def encrypted?(text); end
@@ -4709,7 +4882,7 @@ class ActiveRecord::Encryption::Properties
   def iv; end
   def iv=(value); end
   def key?(*_arg0, **_arg1, &_arg2); end
-  def method_missing(method, *args, **_arg2, &block); end
+  def method_missing(method, *_arg1, **_arg2, &_arg3); end
   def to_h; end
   def validate_value_type(value); end
 
@@ -4723,6 +4896,7 @@ ActiveRecord::Encryption::Properties::ALLOWED_VALUE_CLASSES = T.let(T.unsafe(nil
 ActiveRecord::Encryption::Properties::DEFAULT_PROPERTIES = T.let(T.unsafe(nil), Hash)
 
 class ActiveRecord::Encryption::ReadOnlyNullEncryptor
+  def binary?; end
   def decrypt(encrypted_text, key_provider: T.unsafe(nil), cipher_options: T.unsafe(nil)); end
   def encrypt(clean_text, key_provider: T.unsafe(nil), cipher_options: T.unsafe(nil)); end
   def encrypted?(text); end
@@ -4746,8 +4920,9 @@ class ActiveRecord::Encryption::Scheme
 
   private
 
-  def build_key_provider; end
   def default_key_provider; end
+  def deterministic_key_provider; end
+  def key_provider_from_key; end
   def validate_config!; end
 end
 
@@ -4759,6 +4934,7 @@ module ActiveRecord::Enum
   def _enum(name, values, prefix: T.unsafe(nil), suffix: T.unsafe(nil), scopes: T.unsafe(nil), instance_methods: T.unsafe(nil), validate: T.unsafe(nil), **options); end
   def _enum_methods_module; end
   def assert_valid_enum_definition_values(values); end
+  def assert_valid_enum_options(options); end
   def detect_enum_conflict!(enum_name, method_name, klass_method = T.unsafe(nil)); end
   def detect_negative_enum_conditions!(method_names); end
   def inherited(base); end
@@ -4813,9 +4989,8 @@ module ActiveRecord::Explain
 
   private
 
-  def build_explain_clause(options = T.unsafe(nil)); end
-  def connection_explain(sql, binds, options); end
-  def render_bind(attr); end
+  def build_explain_clause(connection, options = T.unsafe(nil)); end
+  def render_bind(connection, attr); end
 end
 
 class ActiveRecord::ExplainRegistry
@@ -4946,15 +5121,15 @@ class ActiveRecord::FixtureSet
   class << self
     def all_loaded_fixtures; end
     def all_loaded_fixtures=(val); end
-    def cache_fixtures(connection, fixtures_map); end
-    def cache_for_connection(connection); end
-    def cached_fixtures(connection, keys_to_fetch = T.unsafe(nil)); end
+    def cache_fixtures(connection_pool, fixtures_map); end
+    def cache_for_connection_pool(connection_pool); end
+    def cached_fixtures(connection_pool, keys_to_fetch = T.unsafe(nil)); end
     def composite_identify(label, key); end
     def context_class; end
-    def create_fixtures(fixtures_directories, fixture_set_names, class_names = T.unsafe(nil), config = T.unsafe(nil), &block); end
+    def create_fixtures(fixtures_directories, fixture_set_names, class_names = T.unsafe(nil), config = T.unsafe(nil)); end
     def default_fixture_model_name(fixture_set_name, config = T.unsafe(nil)); end
     def default_fixture_table_name(fixture_set_name, config = T.unsafe(nil)); end
-    def fixture_is_cached?(connection, table_name); end
+    def fixture_is_cached?(connection_pool, table_name); end
     def identify(label, column_type = T.unsafe(nil)); end
     def instantiate_all_loaded_fixtures(object, load_instances = T.unsafe(nil)); end
     def instantiate_fixtures(object, fixture_set, load_instances = T.unsafe(nil)); end
@@ -4963,8 +5138,8 @@ class ActiveRecord::FixtureSet
     private
 
     def check_all_foreign_keys_valid!(conn); end
-    def insert(fixture_sets, connection); end
-    def read_and_insert(fixtures_directories, fixture_files, class_names, connection); end
+    def insert(fixture_sets, connection_pool); end
+    def read_and_insert(fixtures_directories, fixture_files, class_names, connection_pool); end
     def update_all_loaded_fixtures(fixtures_map); end
   end
 end
@@ -5073,7 +5248,6 @@ class ActiveRecord::FutureResult
   def execute!(connection); end
   def execute_or_skip; end
   def lock_wait; end
-  def method_missing(method, *args, **_arg2, &block); end
   def pending?; end
   def result; end
   def schedule!(session); end
@@ -5085,7 +5259,10 @@ class ActiveRecord::FutureResult
   def exec_query(connection, *args, **kwargs); end
   def execute_or_wait; end
   def execute_query(connection, async: T.unsafe(nil)); end
-  def respond_to_missing?(name, include_private = T.unsafe(nil)); end
+
+  class << self
+    def wrap(result); end
+  end
 end
 
 class ActiveRecord::FutureResult::Canceled < ::ActiveRecord::ActiveRecordError; end
@@ -5195,8 +5372,6 @@ class ActiveRecord::IllegalMigrationNameError < ::ActiveRecord::MigrationError
   def initialize(name = T.unsafe(nil)); end
 end
 
-class ActiveRecord::ImmutableRelation < ::ActiveRecord::ActiveRecordError; end
-
 module ActiveRecord::Inheritance
   extend ::ActiveSupport::Concern
   include GeneratedInstanceMethods
@@ -5259,7 +5434,7 @@ module ActiveRecord::Inheritance::ClassMethods
 end
 
 class ActiveRecord::InsertAll
-  def initialize(model, inserts, on_duplicate:, update_only: T.unsafe(nil), returning: T.unsafe(nil), unique_by: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end
+  def initialize(relation, connection, inserts, on_duplicate:, update_only: T.unsafe(nil), returning: T.unsafe(nil), unique_by: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end
 
   def connection; end
   def execute; end
@@ -5291,12 +5466,15 @@ class ActiveRecord::InsertAll
   def resolve_attribute_alias(attribute); end
   def resolve_attribute_aliases; end
   def resolve_sti; end
-  def scope_attributes; end
   def timestamps_for_create; end
   def to_sql; end
   def unique_by_columns; end
   def unique_indexes; end
   def verify_attributes(attributes); end
+
+  class << self
+    def execute(relation, *_arg1, **_arg2, &_arg3); end
+  end
 end
 
 class ActiveRecord::InsertAll::Builder
@@ -5374,12 +5552,11 @@ module ActiveRecord::Integration::ClassMethods
 end
 
 class ActiveRecord::InternalMetadata
-  def initialize(connection); end
+  def initialize(pool); end
 
   def [](key); end
   def []=(key, value); end
   def arel_table; end
-  def connection; end
   def count; end
   def create_table; end
   def create_table_and_set_flags(environment, schema_sha1 = T.unsafe(nil)); end
@@ -5393,16 +5570,20 @@ class ActiveRecord::InternalMetadata
 
   private
 
-  def create_entry(key, value); end
-  def current_time; end
-  def select_entry(key); end
-  def update_entry(key, new_value); end
-  def update_or_create_entry(key, value); end
+  def create_entry(connection, key, value); end
+  def current_time(connection); end
+  def select_entry(connection, key); end
+  def update_entry(connection, key, new_value); end
+  def update_or_create_entry(connection, key, value); end
 end
 
 class ActiveRecord::InternalMetadata::NullInternalMetadata; end
 class ActiveRecord::InvalidForeignKey < ::ActiveRecord::WrappedDatabaseException; end
 
+class ActiveRecord::InvalidMigrationTimestampError < ::ActiveRecord::MigrationError
+  def initialize(version = T.unsafe(nil), name = T.unsafe(nil)); end
+end
+
 class ActiveRecord::InverseOfAssociationNotFoundError < ::ActiveRecord::ActiveRecordError
   include ::DidYouMean::Correctable
 
@@ -5479,7 +5660,6 @@ module ActiveRecord::Locking::Optimistic
 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
@@ -5488,6 +5668,7 @@ module ActiveRecord::Locking::Optimistic::ClassMethods
 
   private
 
+  def hook_attribute_type(name, cast_type); end
   def inherited(base); end
 end
 
@@ -5522,9 +5703,6 @@ class ActiveRecord::LogSubscriber < ::ActiveSupport::LogSubscriber
     def backtrace_cleaner=(value); end
     def backtrace_cleaner?; end
     def log_levels; end
-    def reset_runtime; end
-    def runtime; end
-    def runtime=(value); end
   end
 end
 
@@ -5619,6 +5797,7 @@ class ActiveRecord::Migration
 
   def announce(message); end
   def connection; end
+  def connection_pool; end
   def copy(destination, sources, options = T.unsafe(nil)); end
   def disable_ddl_transaction; end
   def down; end
@@ -5656,7 +5835,6 @@ class ActiveRecord::Migration
   class << self
     def [](version); end
     def check_all_pending!; end
-    def check_pending!(connection = T.unsafe(nil)); end
     def check_pending_migrations; end
     def current_version; end
     def delegate; end
@@ -5667,7 +5845,7 @@ class ActiveRecord::Migration
     def inherited(subclass); end
     def load_schema_if_pending!; end
     def maintain_test_schema!; end
-    def method_missing(name, *args, **_arg2, &block); end
+    def method_missing(name, *_arg1, **_arg2, &_arg3); end
     def migrate(direction); end
     def nearest_delegate; end
     def valid_version_format?(version_string); end
@@ -5780,7 +5958,7 @@ class ActiveRecord::Migration::CommandRecorder
   def invert_rename_index(args); end
   def invert_rename_table(args); end
   def invert_transaction(args, &block); end
-  def method_missing(method, *args, **_arg2, &block); end
+  def method_missing(method, *_arg1, **_arg2, &_arg3); end
   def respond_to_missing?(method, _); end
 end
 
@@ -5943,7 +6121,7 @@ module ActiveRecord::Migration::Compatibility::V6_1::TableDefinition
   def raise_on_if_exist_options(options); end
 end
 
-class ActiveRecord::Migration::Compatibility::V7_0 < ::ActiveRecord::Migration::Current
+class ActiveRecord::Migration::Compatibility::V7_0 < ::ActiveRecord::Migration::Compatibility::V7_1
   include ::ActiveRecord::Migration::Compatibility::V7_0::LegacyIndexName
 
   def add_belongs_to(table_name, ref_name, **options); end
@@ -5976,13 +6154,15 @@ module ActiveRecord::Migration::Compatibility::V7_0::TableDefinition
   def change(name, type, **options); end
   def column(name, type, **options); end
   def index(column_name, **options); end
+  def references(*args, **options); end
 
   private
 
   def raise_on_if_exist_options(options); end
 end
 
-ActiveRecord::Migration::Compatibility::V7_1 = ActiveRecord::Migration::Current
+class ActiveRecord::Migration::Compatibility::V7_1 < ::ActiveRecord::Migration::Current; end
+ActiveRecord::Migration::Compatibility::V7_2 = ActiveRecord::Migration::Current
 
 class ActiveRecord::Migration::Current < ::ActiveRecord::Migration
   def change_table(table_name, **options); end
@@ -5996,8 +6176,8 @@ class ActiveRecord::Migration::DefaultStrategy < ::ActiveRecord::Migration::Exec
   private
 
   def connection; end
-  def method_missing(method, *arguments, **_arg2, &block); end
-  def respond_to_missing?(method, *_arg1); end
+  def method_missing(method, *_arg1, **_arg2, &_arg3); end
+  def respond_to_missing?(method, include_private = T.unsafe(nil)); end
 end
 
 class ActiveRecord::Migration::ExecutionStrategy
@@ -6058,9 +6238,12 @@ class ActiveRecord::MigrationContext
   private
 
   def connection; end
+  def connection_pool; end
   def migration_files; end
   def move(direction, steps); end
   def parse_migration_filename(filename); end
+  def valid_migration_timestamp?(version); end
+  def validate_timestamp?; end
 end
 
 class ActiveRecord::MigrationError < ::ActiveRecord::ActiveRecordError
@@ -6203,9 +6386,7 @@ module ActiveRecord::ModelSchema
 end
 
 module ActiveRecord::ModelSchema::ClassMethods
-  def _default_attributes; end
-  def _returning_columns_for_insert; end
-  def attribute_types; end
+  def _returning_columns_for_insert(connection); end
   def attributes_builder; end
   def column_defaults; end
   def column_for_attribute(name); end
@@ -6233,7 +6414,6 @@ module ActiveRecord::ModelSchema::ClassMethods
   def table_exists?; end
   def table_name; end
   def table_name=(value); end
-  def type_for_attribute(attr_name, &block); end
   def yaml_encoder; end
 
   protected
@@ -6243,11 +6423,11 @@ 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
   def schema_loaded?; end
+  def type_for_column(connection, column); end
   def undecorated_table_name(model_name); end
 end
 
@@ -6274,6 +6454,7 @@ module ActiveRecord::NestedAttributes
   def assign_to_or_mark_for_destruction(record, attributes, allow_destroy); end
   def call_reject_if(association_name, attributes); end
   def check_record_limit!(limit, attributes_collection); end
+  def find_record_by_id(records, id); end
   def has_destroy_flag?(hash); end
   def raise_nested_attributes_record_not_found!(association_name, record_id); end
   def reject_new_record?(association_name, attributes); end
@@ -6407,8 +6588,8 @@ class ActiveRecord::NotNullViolation < ::ActiveRecord::StatementInvalid; end
 class ActiveRecord::PendingMigrationConnection
   class << self
     def current_preventing_writes; end
-    def establish_temporary_connection(db_config, &block); end
     def primary_class?; end
+    def with_temporary_pool(db_config, &block); end
   end
 end
 
@@ -6424,7 +6605,7 @@ class ActiveRecord::PendingMigrationError < ::ActiveRecord::MigrationError
 
   private
 
-  def connection; end
+  def connection_pool; end
   def detailed_migration_message(pending_migrations); end
 
   class << self
@@ -6490,26 +6671,18 @@ end
 
 module ActiveRecord::Persistence::ClassMethods
   def _delete_record(constraints); end
-  def _insert_record(values, returning); end
+  def _insert_record(connection, values, returning); end
   def _update_record(values, constraints); end
   def build(attributes = T.unsafe(nil), &block); end
   def composite_query_constraints_list; end
   def create(attributes = T.unsafe(nil), &block); end
   def create!(attributes = T.unsafe(nil), &block); end
-  def delete(id_or_array); end
-  def destroy(id); end
   def has_query_constraints?; end
-  def insert(attributes, returning: T.unsafe(nil), unique_by: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end
-  def insert!(attributes, returning: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end
-  def insert_all(attributes, returning: T.unsafe(nil), unique_by: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end
-  def insert_all!(attributes, returning: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end
   def instantiate(attributes, column_types = T.unsafe(nil), &block); end
   def query_constraints(*columns_list); end
   def query_constraints_list; end
   def update(id = T.unsafe(nil), attributes); end
   def update!(id = T.unsafe(nil), attributes); end
-  def upsert(attributes, **kwargs); end
-  def upsert_all(attributes, on_duplicate: T.unsafe(nil), update_only: T.unsafe(nil), returning: T.unsafe(nil), unique_by: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end
 
   private
 
@@ -6682,7 +6855,7 @@ end
 
 module ActiveRecord::QueryCache::ClassMethods
   def cache(&block); end
-  def uncached(&block); end
+  def uncached(dirties: T.unsafe(nil), &block); end
 end
 
 class ActiveRecord::QueryCanceled < ::ActiveRecord::QueryAborted; end
@@ -6697,6 +6870,7 @@ module ActiveRecord::QueryLogs
     def clear_cache; end
     def prepend_comment; end
     def prepend_comment=(val); end
+    def query_source_location; end
     def taggings; end
     def taggings=(val); end
     def tags; end
@@ -6869,12 +7043,15 @@ module ActiveRecord::QueryMethods
   def where_clause=(value); end
   def with(*args); end
   def with!(*args); end
+  def with_recursive(*args); end
+  def with_recursive!(*args); end
   def with_values; end
   def with_values=(value); end
   def without(*records); end
 
   protected
 
+  def arel_columns(columns); end
   def async!; end
   def build_having_clause(opts, rest = T.unsafe(nil)); end
   def build_subquery(subquery_alias, select_value); end
@@ -6883,25 +7060,30 @@ module ActiveRecord::QueryMethods
   private
 
   def arel_column(field); end
-  def arel_columns(columns); end
-  def assert_mutability!; end
+  def arel_columns_from_hash(fields); end
+  def assert_modifiable!; end
   def async; end
-  def build_arel(aliases = T.unsafe(nil)); end
+  def build_arel(connection, aliases = T.unsafe(nil)); end
+  def build_bound_sql_literal(statement, values); end
   def build_case_for_value_position(column, values); end
   def build_cast_value(name, value); end
   def build_from; end
   def build_join_buckets; end
   def build_join_dependencies; end
   def build_joins(join_sources, aliases = T.unsafe(nil)); end
+  def build_named_bound_sql_literal(statement, values); end
   def build_order(arel); end
   def build_select(arel); end
   def build_with(arel); end
+  def build_with_expression_from_value(value, nested = T.unsafe(nil)); end
   def build_with_join_node(name, kind = T.unsafe(nil)); end
   def build_with_value_from_hash(hash); 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 each_join_dependencies(join_dependencies = T.unsafe(nil), &block); end
+  def extract_table_name_from(string); end
+  def flattened_args(args); end
   def lookup_table_klass_from_join_dependencies(table_name); end
   def order_column(field); end
   def preprocess_order_args(order_args); end
@@ -6913,7 +7095,6 @@ module ActiveRecord::QueryMethods
   def select_named_joins(join_names, stashed_joins = T.unsafe(nil), &block); end
   def structurally_incompatible_values_for(other); end
   def table_name_matches?(from); end
-  def transform_select_hash_values(fields); end
   def validate_order_args(args); end
 end
 
@@ -6943,7 +7124,7 @@ end
 
 module ActiveRecord::Querying
   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 _query_by_sql(connection, sql, binds = T.unsafe(nil), preparable: T.unsafe(nil), async: T.unsafe(nil), allow_retry: T.unsafe(nil)); end
   def and(*_arg0, **_arg1, &_arg2); end
   def annotate(*_arg0, **_arg1, &_arg2); end
   def any?(*_arg0, **_arg1, &_arg2); end
@@ -6964,8 +7145,10 @@ module ActiveRecord::Querying
   def create_or_find_by(*_arg0, **_arg1, &_arg2); end
   def create_or_find_by!(*_arg0, **_arg1, &_arg2); end
   def create_with(*_arg0, **_arg1, &_arg2); end
+  def delete(*_arg0, **_arg1, &_arg2); end
   def delete_all(*_arg0, **_arg1, &_arg2); end
   def delete_by(*_arg0, **_arg1, &_arg2); end
+  def destroy(*_arg0, **_arg1, &_arg2); end
   def destroy_all(*_arg0, **_arg1, &_arg2); end
   def destroy_by(*_arg0, **_arg1, &_arg2); end
   def distinct(*_arg0, **_arg1, &_arg2); end
@@ -6980,7 +7163,7 @@ module ActiveRecord::Querying
   def find(*_arg0, **_arg1, &_arg2); end
   def find_by(*_arg0, **_arg1, &_arg2); end
   def find_by!(*_arg0, **_arg1, &_arg2); end
-  def find_by_sql(sql, binds = T.unsafe(nil), preparable: T.unsafe(nil), &block); end
+  def find_by_sql(sql, binds = T.unsafe(nil), preparable: T.unsafe(nil), allow_retry: T.unsafe(nil), &block); end
   def find_each(*_arg0, **_arg1, &_arg2); end
   def find_in_batches(*_arg0, **_arg1, &_arg2); end
   def find_or_create_by(*_arg0, **_arg1, &_arg2); end
@@ -7003,6 +7186,10 @@ module ActiveRecord::Querying
   def in_batches(*_arg0, **_arg1, &_arg2); end
   def in_order_of(*_arg0, **_arg1, &_arg2); end
   def includes(*_arg0, **_arg1, &_arg2); end
+  def insert(*_arg0, **_arg1, &_arg2); end
+  def insert!(*_arg0, **_arg1, &_arg2); end
+  def insert_all(*_arg0, **_arg1, &_arg2); end
+  def insert_all!(*_arg0, **_arg1, &_arg2); end
   def invert_where(*_arg0, **_arg1, &_arg2); end
   def joins(*_arg0, **_arg1, &_arg2); end
   def last(*_arg0, **_arg1, &_arg2); end
@@ -7049,14 +7236,16 @@ module ActiveRecord::Querying
   def touch_all(*_arg0, **_arg1, &_arg2); end
   def unscope(*_arg0, **_arg1, &_arg2); end
   def update_all(*_arg0, **_arg1, &_arg2); end
+  def upsert(*_arg0, **_arg1, &_arg2); end
+  def upsert_all(*_arg0, **_arg1, &_arg2); end
   def where(*_arg0, **_arg1, &_arg2); end
   def with(*_arg0, **_arg1, &_arg2); end
+  def with_recursive(*_arg0, **_arg1, &_arg2); end
   def without(*_arg0, **_arg1, &_arg2); end
 end
 
 ActiveRecord::Querying::QUERYING_METHODS = T.let(T.unsafe(nil), Array)
 class ActiveRecord::Railtie < ::Rails::Railtie; end
-ActiveRecord::Railtie::SQLITE3_PRODUCTION_WARN = T.let(T.unsafe(nil), String)
 class ActiveRecord::RangeError < ::ActiveRecord::StatementInvalid; end
 class ActiveRecord::ReadOnlyError < ::ActiveRecord::ActiveRecordError; end
 class ActiveRecord::ReadOnlyRecord < ::ActiveRecord::ActiveRecordError; end
@@ -7144,6 +7333,9 @@ module ActiveRecord::Reflection
     def automatic_scope_inversing; end
     def automatic_scope_inversing=(value); end
     def automatic_scope_inversing?; end
+    def automatically_invert_plural_associations; end
+    def automatically_invert_plural_associations=(value); end
+    def automatically_invert_plural_associations?; end
   end
 
   module GeneratedInstanceMethods
@@ -7153,6 +7345,8 @@ module ActiveRecord::Reflection
     def aggregate_reflections?; end
     def automatic_scope_inversing; end
     def automatic_scope_inversing?; end
+    def automatically_invert_plural_associations; end
+    def automatically_invert_plural_associations?; end
   end
 end
 
@@ -7168,6 +7362,7 @@ class ActiveRecord::Reflection::AbstractReflection
   def constraints; end
   def counter_cache_column; end
   def counter_must_be_updated_by_has_many?; end
+  def has_active_cached_counter?; end
   def has_cached_counter?; end
   def inverse_of; end
   def inverse_updates_counter_cache?; end
@@ -7268,6 +7463,7 @@ end
 module ActiveRecord::Reflection::ClassMethods
   def _reflect_on_association(association); end
   def clear_reflections_cache; end
+  def normalized_reflections; end
   def reflect_on_aggregation(aggregation); end
   def reflect_on_all_aggregations; end
   def reflect_on_all_associations(macro = T.unsafe(nil)); end
@@ -7301,6 +7497,7 @@ class ActiveRecord::Reflection::MacroReflection < ::ActiveRecord::Reflection::Ab
   def initialize(name, scope, options, active_record); end
 
   def ==(other_aggregation); end
+  def _klass(class_name); end
   def active_record; end
   def autosave=(autosave); end
   def compute_class(name); end
@@ -7314,7 +7511,7 @@ class ActiveRecord::Reflection::MacroReflection < ::ActiveRecord::Reflection::Ab
   private
 
   def derive_class_name; end
-  def validate_reflection!; end
+  def normalize_options(options); end
 end
 
 class ActiveRecord::Reflection::PolymorphicReflection < ::ActiveRecord::Reflection::AbstractReflection
@@ -7352,6 +7549,7 @@ end
 class ActiveRecord::Reflection::ThroughReflection < ::ActiveRecord::Reflection::AbstractReflection
   def initialize(delegate_reflection); end
 
+  def _klass(*_arg0, **_arg1, &_arg2); end
   def active_record(*_arg0, **_arg1, &_arg2); end
   def active_record_primary_key(*_arg0, **_arg1, &_arg2); end
   def add_as_polymorphic_through(reflection, seed); end
@@ -7428,6 +7626,8 @@ class ActiveRecord::Relation
   include ::ActiveRecord::SpawnMethods
   include ::ActiveRecord::Calculations
   include ::ActiveRecord::FinderMethods
+  include ::ActiveRecord::TokenFor::RelationMethods
+  include ::ActiveRecord::SignedId::RelationMethods
   extend ::ActiveRecord::Delegation::ClassMethods
 
   def initialize(klass, table: T.unsafe(nil), predicate_builder: T.unsafe(nil), values: T.unsafe(nil)); end
@@ -7446,8 +7646,10 @@ class ActiveRecord::Relation
   def create!(attributes = T.unsafe(nil), &block); end
   def create_or_find_by(attributes, &block); end
   def create_or_find_by!(attributes, &block); end
+  def delete(id_or_array); end
   def delete_all; end
   def delete_by(*args); end
+  def destroy(id); end
   def destroy_all; end
   def destroy_by(*args); end
   def eager_loading?; end
@@ -7462,6 +7664,10 @@ class ActiveRecord::Relation
   def first_or_create!(attributes = T.unsafe(nil), &block); end
   def first_or_initialize(attributes = T.unsafe(nil), &block); end
   def has_limit_or_offset?; end
+  def insert(attributes, returning: T.unsafe(nil), unique_by: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end
+  def insert!(attributes, returning: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end
+  def insert_all(attributes, returning: T.unsafe(nil), unique_by: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end
+  def insert_all!(attributes, returning: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end
   def inspect; end
   def joined_includes_values; end
   def klass; end
@@ -7496,6 +7702,8 @@ class ActiveRecord::Relation
   def update!(id = T.unsafe(nil), attributes); end
   def update_all(updates); end
   def update_counters(counters); end
+  def upsert(attributes, **kwargs); end
+  def upsert_all(attributes, on_duplicate: T.unsafe(nil), update_only: T.unsafe(nil), returning: T.unsafe(nil), unique_by: T.unsafe(nil), record_timestamps: T.unsafe(nil)); end
   def values; end
   def values_for_queries; end
   def where_values_hash(relation_table_name = T.unsafe(nil)); end
@@ -7529,6 +7737,24 @@ end
 
 ActiveRecord::Relation::CLAUSE_METHODS = T.let(T.unsafe(nil), Array)
 
+class ActiveRecord::Relation::ExplainProxy
+  def initialize(relation, options); end
+
+  def average(column_name); end
+  def count(column_name = T.unsafe(nil)); end
+  def first(limit = T.unsafe(nil)); end
+  def inspect; end
+  def last(limit = T.unsafe(nil)); end
+  def maximum(column_name); end
+  def minimum(column_name); end
+  def pluck(*column_names); end
+  def sum(identity_or_column = T.unsafe(nil)); end
+
+  private
+
+  def exec_explain(&block); end
+end
+
 class ActiveRecord::Relation::FromClause
   def initialize(value, name); end
 
@@ -7544,7 +7770,7 @@ class ActiveRecord::Relation::FromClause
 end
 
 class ActiveRecord::Relation::HashMerger
-  def initialize(relation, hash, rewhere = T.unsafe(nil)); end
+  def initialize(relation, hash); end
 
   def hash; end
   def merge; end
@@ -7556,7 +7782,7 @@ 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, rewhere = T.unsafe(nil)); end
+  def initialize(relation, other); end
 
   def merge; end
   def other; end
@@ -7621,7 +7847,7 @@ class ActiveRecord::Relation::WhereClause
   def extract_attributes; end
   def hash; end
   def invert; end
-  def merge(other, rewhere = T.unsafe(nil)); end
+  def merge(other); end
   def or(other); end
   def to_h(table_name = T.unsafe(nil), equality_only: T.unsafe(nil)); end
   def |(other); end
@@ -7641,7 +7867,6 @@ class ActiveRecord::Relation::WhereClause
   def extract_node_value(node); end
   def invert_predicate(node); end
   def non_empty_predicates; end
-  def predicates_unreferenced_by(other); end
   def predicates_with_wrapped_sql_literals; end
   def wrap_sql_literal(node); end
 
@@ -7660,6 +7885,7 @@ class ActiveRecord::Result
   def [](idx); end
   def cancel; end
   def cast_values(type_overrides = T.unsafe(nil)); end
+  def column_indexes; end
   def column_types; end
   def columns; end
   def each(&block); end
@@ -7686,6 +7912,7 @@ end
 
 ActiveRecord::Result::EMPTY = T.let(T.unsafe(nil), ActiveRecord::Result)
 ActiveRecord::Result::EMPTY_ASYNC = T.let(T.unsafe(nil), ActiveRecord::FutureResult::Complete)
+ActiveRecord::Result::EMPTY_HASH = T.let(T.unsafe(nil), Hash)
 class ActiveRecord::Rollback < ::ActiveRecord::ActiveRecordError; end
 
 module ActiveRecord::RuntimeRegistry
@@ -7693,7 +7920,14 @@ module ActiveRecord::RuntimeRegistry
 
   def async_sql_runtime; end
   def async_sql_runtime=(runtime); end
+  def cached_queries_count; end
+  def cached_queries_count=(count); end
+  def queries_count; end
+  def queries_count=(count); end
   def reset; end
+  def reset_cached_queries_count; end
+  def reset_queries_count; end
+  def reset_runtimes; end
   def sql_runtime; end
   def sql_runtime=(runtime); end
 end
@@ -7725,11 +7959,11 @@ module ActiveRecord::Sanitization::ClassMethods
 
   private
 
-  def quote_bound_value(value, c = T.unsafe(nil)); end
+  def quote_bound_value(connection, value); end
   def raise_if_bind_arity_mismatch(statement, expected, provided); end
-  def replace_bind_variable(value, c = T.unsafe(nil)); end
-  def replace_bind_variables(statement, values); end
-  def replace_named_bind_variables(statement, bind_vars); end
+  def replace_bind_variable(connection, value); end
+  def replace_bind_variables(connection, statement, values); end
+  def replace_named_bind_variables(connection, statement, bind_vars); end
 end
 
 class ActiveRecord::Schema < ::ActiveRecord::Migration::Current
@@ -7795,7 +8029,7 @@ class ActiveRecord::SchemaDumper
   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 dump(pool = T.unsafe(nil), stream = T.unsafe(nil), config = T.unsafe(nil)); end
     def excl_ignore_pattern; end
     def excl_ignore_pattern=(val); end
     def fk_ignore_pattern; end
@@ -7813,10 +8047,9 @@ class ActiveRecord::SchemaDumper
 end
 
 class ActiveRecord::SchemaMigration
-  def initialize(connection); end
+  def initialize(pool); end
 
   def arel_table; end
-  def connection; end
   def count; end
   def create_table; end
   def create_version(version); end
@@ -8042,6 +8275,11 @@ module ActiveRecord::SignedId::ClassMethods
   def signed_id_verifier=(verifier); end
 end
 
+module ActiveRecord::SignedId::RelationMethods
+  def find_signed(*_arg0, **_arg1, &_arg2); end
+  def find_signed!(*_arg0, **_arg1, &_arg2); end
+end
+
 class ActiveRecord::SoleRecordExceeded < ::ActiveRecord::ActiveRecordError
   def initialize(record = T.unsafe(nil)); end
 
@@ -8070,7 +8308,7 @@ end
 class ActiveRecord::StatementCache
   def initialize(query_builder, bind_map, klass); end
 
-  def execute(params, connection, &block); end
+  def execute(params, connection, allow_retry: T.unsafe(nil), &block); end
 
   private
 
@@ -8111,6 +8349,8 @@ class ActiveRecord::StatementCache::PartialQueryCollector
   def add_binds(binds, proc_for_binds = T.unsafe(nil)); end
   def preparable; end
   def preparable=(_arg0); end
+  def retryable; end
+  def retryable=(_arg0); end
   def value; end
 end
 
@@ -8244,7 +8484,7 @@ class ActiveRecord::Tasks::DatabaseNotSupported < ::StandardError; end
 module ActiveRecord::Tasks::DatabaseTasks
   extend ::ActiveRecord::Tasks::DatabaseTasks
 
-  def cache_dump_filename(db_config_name, schema_cache_path: T.unsafe(nil)); end
+  def cache_dump_filename(db_config_or_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!(environment = T.unsafe(nil)); end
@@ -8258,14 +8498,14 @@ module ActiveRecord::Tasks::DatabaseTasks
   def create_current(environment = T.unsafe(nil), name = T.unsafe(nil)); end
   def database_configuration; end
   def database_configuration=(_arg0); end
-  def db_configs_with_versions(db_configs); end
+  def db_configs_with_versions(environment = T.unsafe(nil)); 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_schema(db_config, format = T.unsafe(nil)); end
-  def dump_schema_cache(conn, filename); end
+  def dump_schema_cache(conn_or_pool, filename); end
   def env; end
   def env=(_arg0); end
   def fixtures_path; end
@@ -8278,6 +8518,7 @@ module ActiveRecord::Tasks::DatabaseTasks
   def migrate_status; end
   def migration_class; end
   def migration_connection; end
+  def migration_connection_pool; end
   def migrations_paths; end
   def migrations_paths=(_arg0); end
   def name; end
@@ -8299,8 +8540,8 @@ module ActiveRecord::Tasks::DatabaseTasks
   def structure_load(configuration, *arguments); end
   def target_version; end
   def truncate_all(environment = T.unsafe(nil)); end
-  def with_temporary_connection(db_config, clobber: T.unsafe(nil)); end
-  def with_temporary_connection_for_each(env: T.unsafe(nil), name: T.unsafe(nil), clobber: T.unsafe(nil), &block); end
+  def with_temporary_connection(db_config, clobber: T.unsafe(nil), &block); end
+  def with_temporary_pool_for_each(env: T.unsafe(nil), name: T.unsafe(nil), clobber: T.unsafe(nil), &block); end
 
   private
 
@@ -8309,9 +8550,11 @@ module ActiveRecord::Tasks::DatabaseTasks
   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_current_environment(environment, &block); end
   def each_local_configuration; end
   def local_database?(db_config); end
   def resolve_configuration(configuration); end
+  def schema_cache_env; end
   def schema_sha1(file); end
   def structure_dump_flags_for(adapter); end
   def structure_load_flags_for(adapter); end
@@ -8431,22 +8674,25 @@ module ActiveRecord::TestFixtures
 
   def after_teardown; end
   def before_setup; end
-  def enlist_fixture_connections; end
-  def fixture_path; end
-  def run_in_transaction?; end
-  def setup_fixtures(config = T.unsafe(nil)); end
-  def teardown_fixtures; end
+  def fixture(fixture_set_name, *fixture_names); end
 
   private
 
   def access_fixture(fs_name, *fixture_names); end
+  def active_record_fixture(fixture_set_name, *fixture_names); end
   def instantiate_fixtures; end
+  def invalidate_already_loaded_fixtures; end
   def load_fixtures(config); end
   def load_instances?; end
-  def method_missing(name, *args, **kwargs, &block); end
-  def respond_to_missing?(name, include_private = T.unsafe(nil)); end
+  def method_missing(method, *_arg1, **_arg2, &_arg3); end
+  def respond_to_missing?(method, include_private = T.unsafe(nil)); end
+  def run_in_transaction?; end
+  def setup_fixtures(config = T.unsafe(nil)); end
   def setup_shared_connection_pool; end
+  def setup_transactional_fixtures; end
+  def teardown_fixtures; end
   def teardown_shared_connection_pool; end
+  def teardown_transactional_fixtures; end
 
   module GeneratedClassMethods
     def fixture_class_names; end
@@ -8503,8 +8749,6 @@ module ActiveRecord::TestFixtures
 end
 
 module ActiveRecord::TestFixtures::ClassMethods
-  def fixture_path; end
-  def fixture_path=(path); end
   def fixtures(*fixture_set_names); end
   def set_fixture_class(class_names = T.unsafe(nil)); end
   def setup_fixture_accessors(fixture_set_names = T.unsafe(nil)); end
@@ -8598,6 +8842,11 @@ module ActiveRecord::TokenFor::ClassMethods
   def generates_token_for(purpose, expires_in: T.unsafe(nil), &block); end
 end
 
+module ActiveRecord::TokenFor::RelationMethods
+  def find_by_token_for(purpose, token); end
+  def find_by_token_for!(purpose, token); end
+end
+
 class ActiveRecord::TokenFor::TokenDefinition < ::Struct
   def block; end
   def block=(_); end
@@ -8635,6 +8884,18 @@ module ActiveRecord::TouchLater
   def touch_deferred_attributes; end
 end
 
+class ActiveRecord::Transaction
+  def initialize(internal_transaction); end
+
+  def after_commit(&block); end
+  def after_rollback(&block); end
+  def blank?; end
+  def closed?; end
+  def open?; end
+  def uuid; end
+end
+
+ActiveRecord::Transaction::NULL_TRANSACTION = T.let(T.unsafe(nil), ActiveRecord::Transaction)
 class ActiveRecord::TransactionIsolationError < ::ActiveRecord::ActiveRecordError; end
 class ActiveRecord::TransactionRollbackError < ::ActiveRecord::StatementInvalid; end
 
@@ -8680,6 +8941,8 @@ module ActiveRecord::Transactions::ClassMethods
   def after_save_commit(*args, &block); end
   def after_update_commit(*args, &block); end
   def before_commit(*args, &block); end
+  def current_transaction; end
+  def set_callback(name, *filter_list, &block); end
   def transaction(**options, &block); end
 
   private
@@ -8690,9 +8953,6 @@ module ActiveRecord::Transactions::ClassMethods
 end
 
 module ActiveRecord::Translation
-  include ::ActiveModel::Naming
-  include ::ActiveModel::Translation
-
   def i18n_scope; end
   def lookup_ancestors; end
 end
@@ -8895,7 +9155,6 @@ class ActiveRecord::TypeCaster::Connection
 
   private
 
-  def connection(*_arg0, **_arg1, &_arg2); end
   def table_name; end
 end
 
@@ -8924,29 +9183,20 @@ class ActiveRecord::UnknownPrimaryKey < ::ActiveRecord::ActiveRecordError
   def model; end
 end
 
+class ActiveRecord::UnmodifiableRelation < ::ActiveRecord::ActiveRecordError; end
 module ActiveRecord::VERSION; end
 ActiveRecord::VERSION::MAJOR = T.let(T.unsafe(nil), Integer)
 ActiveRecord::VERSION::MINOR = T.let(T.unsafe(nil), Integer)
-ActiveRecord::VERSION::PRE = T.let(T.unsafe(nil), String)
+ActiveRecord::VERSION::PRE = T.let(T.unsafe(nil), T.untyped)
 ActiveRecord::VERSION::STRING = T.let(T.unsafe(nil), String)
 ActiveRecord::VERSION::TINY = T.let(T.unsafe(nil), Integer)
 
 module ActiveRecord::Validations
   extend ::ActiveSupport::Concern
-  include GeneratedInstanceMethods
-  include ::ActiveSupport::Callbacks
-  include ::ActiveModel::Validations::HelperMethods
-  include ::ActiveModel::Validations
 
-  mixes_in_class_methods GeneratedClassMethods
-  mixes_in_class_methods ::ActiveModel::Validations::ClassMethods
-  mixes_in_class_methods ::ActiveModel::Callbacks
-  mixes_in_class_methods ::ActiveSupport::Callbacks::ClassMethods
-  mixes_in_class_methods ::ActiveSupport::DescendantsTracker
-  mixes_in_class_methods ::ActiveModel::Translation
-  mixes_in_class_methods ::ActiveModel::Validations::HelperMethods
   mixes_in_class_methods ::ActiveRecord::Validations::ClassMethods
 
+  def custom_validation_context?; end
   def save(**options); end
   def save!(**options); end
   def valid?(context = T.unsafe(nil)); end
@@ -8957,22 +9207,6 @@ module ActiveRecord::Validations
   def default_validation_context; end
   def perform_validations(options = T.unsafe(nil)); end
   def raise_validation_error; end
-
-  module GeneratedClassMethods
-    def __callbacks; end
-    def __callbacks=(value); end
-    def __callbacks?; end
-    def _validators; end
-    def _validators=(value); end
-    def _validators?; end
-  end
-
-  module GeneratedInstanceMethods
-    def __callbacks; end
-    def __callbacks?; end
-    def _validators; end
-    def _validators?; end
-  end
 end
 
 class ActiveRecord::Validations::AbsenceValidator < ::ActiveModel::Validations::AbsenceValidator
@@ -8984,7 +9218,8 @@ class ActiveRecord::Validations::AssociatedValidator < ::ActiveModel::EachValida
 
   private
 
-  def valid_object?(record); end
+  def record_validation_context_for_association(record); end
+  def valid_object?(record, context); end
 end
 
 module ActiveRecord::Validations::ClassMethods
@@ -9037,7 +9272,7 @@ module Arel
   class << self
     def arel_node?(value); end
     def fetch_attribute(value, &block); end
-    def sql(sql_string, *positional_binds, **named_binds); end
+    def sql(sql_string, *positional_binds, retryable: T.unsafe(nil), **named_binds); end
     def star; end
   end
 end
@@ -9075,6 +9310,8 @@ class Arel::Collectors::Bind
   def <<(str); end
   def add_bind(bind); end
   def add_binds(binds, proc_for_binds = T.unsafe(nil)); end
+  def retryable; end
+  def retryable=(_arg0); end
   def value; end
 end
 
@@ -9086,6 +9323,8 @@ class Arel::Collectors::Composite
   def add_binds(binds, proc_for_binds = T.unsafe(nil), &block); end
   def preparable; end
   def preparable=(_arg0); end
+  def retryable; end
+  def retryable=(retryable); end
   def value; end
 
   private
@@ -9108,6 +9347,8 @@ class Arel::Collectors::SQLString < ::Arel::Collectors::PlainString
   def add_binds(binds, proc_for_binds = T.unsafe(nil), &block); end
   def preparable; end
   def preparable=(_arg0); end
+  def retryable; end
+  def retryable=(_arg0); end
 end
 
 class Arel::Collectors::SubstituteBinds
@@ -9118,6 +9359,8 @@ class Arel::Collectors::SubstituteBinds
   def add_binds(binds, proc_for_binds = T.unsafe(nil)); end
   def preparable; end
   def preparable=(_arg0); end
+  def retryable; end
+  def retryable=(_arg0); end
   def value; end
 
   private
@@ -9207,17 +9450,7 @@ class Arel::Nodes::Addition < ::Arel::Nodes::InfixOperation
   def initialize(left, right); end
 end
 
-class Arel::Nodes::And < ::Arel::Nodes::NodeExpression
-  def initialize(children); end
-
-  def ==(other); end
-  def children; end
-  def eql?(other); end
-  def fetch_attribute(&block); end
-  def hash; end
-  def left; end
-  def right; end
-end
+class Arel::Nodes::And < ::Arel::Nodes::Nary; end
 
 class Arel::Nodes::As < ::Arel::Nodes::Binary
   def to_cte; end
@@ -9664,6 +9897,18 @@ class Arel::Nodes::NamedWindow < ::Arel::Nodes::Window
   def initialize_copy(other); end
 end
 
+class Arel::Nodes::Nary < ::Arel::Nodes::NodeExpression
+  def initialize(children); end
+
+  def ==(other); end
+  def children; end
+  def eql?(other); end
+  def fetch_attribute(&block); end
+  def hash; end
+  def left; end
+  def right; end
+end
+
 class Arel::Nodes::Node
   include ::Arel::FactoryMethods
 
@@ -9711,10 +9956,7 @@ end
 class Arel::Nodes::Offset < ::Arel::Nodes::Unary; end
 class Arel::Nodes::On < ::Arel::Nodes::Unary; end
 class Arel::Nodes::OptimizerHints < ::Arel::Nodes::Unary; end
-
-class Arel::Nodes::Or < ::Arel::Nodes::Binary
-  def fetch_attribute(&block); end
-end
+class Arel::Nodes::Or < ::Arel::Nodes::Nary; end
 
 class Arel::Nodes::Ordering < ::Arel::Nodes::Unary
   def nulls_first; end
@@ -9825,9 +10067,12 @@ class Arel::Nodes::SqlLiteral < ::String
   include ::Arel::AliasPredication
   include ::Arel::OrderPredications
 
+  def initialize(string, retryable: T.unsafe(nil)); end
+
   def +(other); end
   def encode_with(coder); end
   def fetch_attribute; end
+  def retryable; end
 end
 
 class Arel::Nodes::StringJoin < ::Arel::Nodes::Join
@@ -10167,6 +10412,7 @@ class Arel::Visitors::Dot < ::Arel::Visitors::Visitor
   def visit_Arel_Nodes_NamedFunction(o); end
   def visit_Arel_Nodes_NamedWindow(o); end
   def visit_Arel_Nodes_NotRegexp(o); end
+  def visit_Arel_Nodes_Or(o); end
   def visit_Arel_Nodes_Ordering(o); end
   def visit_Arel_Nodes_Regexp(o); end
   def visit_Arel_Nodes_SelectCore(o); end
@@ -10228,6 +10474,7 @@ class Arel::Visitors::MySQL < ::Arel::Visitors::ToSql
   def visit_Arel_Nodes_IsNotDistinctFrom(o, collector); end
   def visit_Arel_Nodes_NotRegexp(o, collector); end
   def visit_Arel_Nodes_NullsFirst(o, collector); end
+  def visit_Arel_Nodes_NullsLast(o, collector); end
   def visit_Arel_Nodes_Regexp(o, collector); end
   def visit_Arel_Nodes_SelectCore(o, collector); end
   def visit_Arel_Nodes_SelectStatement(o, collector); end
@@ -10239,7 +10486,6 @@ class Arel::Visitors::PostgreSQL < ::Arel::Visitors::ToSql
 
   def bind_block; end
   def grouping_array_or_grouping_element(o, collector); end
-  def grouping_parentheses(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
@@ -10259,6 +10505,7 @@ Arel::Visitors::PostgreSQL::BIND_BLOCK = T.let(T.unsafe(nil), Proc)
 class Arel::Visitors::SQLite < ::Arel::Visitors::ToSql
   private
 
+  def infix_value_with_paren(o, collector, value, suppress_parens = T.unsafe(nil)); end
   def visit_Arel_Nodes_False(o, collector); end
   def visit_Arel_Nodes_IsDistinctFrom(o, collector); end
   def visit_Arel_Nodes_IsNotDistinctFrom(o, collector); end
@@ -10280,6 +10527,7 @@ class Arel::Visitors::ToSql < ::Arel::Visitors::Visitor
   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 grouping_parentheses(o, collector, always_wrap_selects = T.unsafe(nil)); end
   def has_group_by_and_having?(o); end
   def has_join_sources?(o); end
   def has_limit_or_offset_or_orders?(o); end
@@ -10293,6 +10541,7 @@ class Arel::Visitors::ToSql < ::Arel::Visitors::Visitor
   def quote(value); end
   def quote_column_name(name); end
   def quote_table_name(name); end
+  def require_parentheses?(o); end
   def sanitize_as_sql_comment(value); end
   def unboundable?(value); end
   def unsupported(o, collector); end
diff --git a/sorbet/rbi/gems/activesupport@7.1.3.4.rbi b/sorbet/rbi/gems/activesupport@7.2.2.rbi
similarity index 95%
rename from sorbet/rbi/gems/activesupport@7.1.3.4.rbi
rename to sorbet/rbi/gems/activesupport@7.2.2.rbi
index ffaae2ab..f3fca450 100644
--- a/sorbet/rbi/gems/activesupport@7.1.3.4.rbi
+++ b/sorbet/rbi/gems/activesupport@7.2.2.rbi
@@ -4,6 +4,7 @@
 # This is an autogenerated file for types exported from the `activesupport` gem.
 # Please instead update this file by running `bin/tapioca gem activesupport`.
 
+
 module ActiveSupport
   extend ::ActiveSupport::LazyLoadHooks
   extend ::ActiveSupport::Autoload
@@ -81,7 +82,7 @@ class ActiveSupport::ArrayInquirer < ::Array
 
   private
 
-  def method_missing(name, *args); end
+  def method_missing(name, *_arg1, **_arg2, &_arg3); end
   def respond_to_missing?(name, include_private = T.unsafe(nil)); end
 end
 
@@ -91,10 +92,6 @@ module ActiveSupport::Autoload
   def autoload_under(path); end
   def eager_autoload; end
   def eager_load!; end
-
-  class << self
-    def extended(base); end
-  end
 end
 
 class ActiveSupport::BacktraceCleaner
@@ -110,10 +107,12 @@ class ActiveSupport::BacktraceCleaner
 
   private
 
+  def add_core_silencer; end
   def add_gem_filter; end
   def add_gem_silencer; end
   def add_stdlib_silencer; end
   def filter_backtrace(backtrace); end
+  def initialize_copy(_other); end
   def noise(backtrace); end
   def silence(backtrace); end
 end
@@ -135,36 +134,36 @@ class ActiveSupport::BroadcastLogger
   def initialize(*loggers); end
 
   def <<(message); end
-  def add(*args, &block); end
+  def add(*_arg0, **_arg1, &_arg2); end
   def broadcast_to(*loggers); end
   def broadcasts; end
   def close; end
-  def debug(*args, &block); end
+  def debug(*_arg0, **_arg1, &_arg2); end
   def debug!; end
   def debug?; end
-  def error(*args, &block); end
+  def error(*_arg0, **_arg1, &_arg2); end
   def error!; end
   def error?; end
-  def fatal(*args, &block); end
+  def fatal(*_arg0, **_arg1, &_arg2); end
   def fatal!; end
   def fatal?; end
   def formatter; end
   def formatter=(formatter); end
-  def info(*args, &block); end
+  def info(*_arg0, **_arg1, &_arg2); end
   def info!; end
   def info?; end
   def level; end
   def level=(level); end
   def local_level=(level); end
-  def log(*args, &block); end
+  def log(*_arg0, **_arg1, &_arg2); end
   def progname; end
   def progname=(_arg0); end
   def sev_threshold=(level); end
   def silencer; end
   def silencer=(val); end
   def stop_broadcasting_to(logger); end
-  def unknown(*args, &block); end
-  def warn(*args, &block); end
+  def unknown(*_arg0, **_arg1, &_arg2); end
+  def warn(*_arg0, **_arg1, &_arg2); end
   def warn!; end
   def warn?; end
 
@@ -172,7 +171,7 @@ class ActiveSupport::BroadcastLogger
 
   def dispatch(&block); end
   def initialize_copy(other); end
-  def method_missing(name, *args, **kwargs, &block); end
+  def method_missing(name, *_arg1, **_arg2, &_arg3); end
   def respond_to_missing?(method, include_all); end
 
   class << self
@@ -381,19 +380,6 @@ module ActiveSupport::Cache::SerializerWithFallback
   end
 end
 
-module ActiveSupport::Cache::SerializerWithFallback::Marshal61WithFallback
-  include ::ActiveSupport::Cache::SerializerWithFallback
-  extend ::ActiveSupport::Cache::SerializerWithFallback
-  extend ::ActiveSupport::Cache::SerializerWithFallback::Marshal61WithFallback
-
-  def _load(payload); end
-  def dump(entry); end
-  def dump_compressed(entry, threshold); end
-  def dumped?(dumped); end
-end
-
-ActiveSupport::Cache::SerializerWithFallback::Marshal61WithFallback::MARSHAL_SIGNATURE = T.let(T.unsafe(nil), String)
-
 module ActiveSupport::Cache::SerializerWithFallback::Marshal70WithFallback
   include ::ActiveSupport::Cache::SerializerWithFallback
   extend ::ActiveSupport::Cache::SerializerWithFallback
@@ -497,7 +483,7 @@ class ActiveSupport::Cache::Store
   def normalize_version(key, options = T.unsafe(nil)); end
   def read_entry(key, **options); end
   def read_multi_entries(names, **options); end
-  def save_block_result_to_cache(name, options); end
+  def save_block_result_to_cache(name, key, options); end
   def serialize_entry(entry, **options); end
   def validate_options(options); end
   def write_entry(key, entry, **options); end
@@ -672,6 +658,7 @@ class ActiveSupport::Callbacks::Callback
 
   def apply(callback_sequence); end
   def chain_config; end
+  def compiled; end
   def current_scopes; end
   def duplicates?(other); end
   def filter; end
@@ -727,9 +714,9 @@ end
 class ActiveSupport::Callbacks::CallbackSequence
   def initialize(nested = T.unsafe(nil), call_template = T.unsafe(nil), user_conditions = T.unsafe(nil)); end
 
-  def after(&after); end
+  def after(after); end
   def around(call_template, user_conditions); end
-  def before(&before); end
+  def before(before); end
   def expand_call_template(arg, block); end
   def final?; end
   def invoke_after(arg); end
@@ -763,27 +750,31 @@ end
 module ActiveSupport::Callbacks::Filters; end
 
 class ActiveSupport::Callbacks::Filters::After
-  class << self
-    def build(callback_sequence, user_callback, user_conditions, chain_config); end
+  def initialize(user_callback, user_conditions, chain_config); end
 
-    private
+  def apply(callback_sequence); end
+  def call(env); end
+  def halting; end
+  def user_callback; end
+  def user_conditions; end
+end
 
-    def conditional(callback_sequence, user_callback, user_conditions); end
-    def halting(callback_sequence, user_callback); end
-    def halting_and_conditional(callback_sequence, user_callback, user_conditions); end
-    def simple(callback_sequence, user_callback); end
-  end
+class ActiveSupport::Callbacks::Filters::Around
+  def initialize(user_callback, user_conditions); end
+
+  def apply(callback_sequence); end
 end
 
 class ActiveSupport::Callbacks::Filters::Before
-  class << self
-    def build(callback_sequence, user_callback, user_conditions, chain_config, filter, name); end
+  def initialize(user_callback, user_conditions, chain_config, filter, name); end
 
-    private
-
-    def halting(callback_sequence, user_callback, halted_lambda, filter, name); end
-    def halting_and_conditional(callback_sequence, user_callback, user_conditions, halted_lambda, filter, name); end
-  end
+  def apply(callback_sequence); end
+  def call(env); end
+  def filter; end
+  def halted_lambda; end
+  def name; end
+  def user_callback; end
+  def user_conditions; end
 end
 
 class ActiveSupport::Callbacks::Filters::Environment < ::Struct
@@ -806,7 +797,7 @@ end
 class ActiveSupport::CodeGenerator
   def initialize(owner, path, line); end
 
-  def define_cached_method(name, namespace:, as: T.unsafe(nil), &block); end
+  def define_cached_method(canonical_name, namespace:, as: T.unsafe(nil), &block); end
   def execute; end
 
   class << self
@@ -818,7 +809,7 @@ class ActiveSupport::CodeGenerator::MethodSet
   def initialize(namespace); end
 
   def apply(owner, path, line); end
-  def define_cached_method(name, as: T.unsafe(nil)); end
+  def define_cached_method(canonical_name, as: T.unsafe(nil)); end
 end
 
 ActiveSupport::CodeGenerator::MethodSet::METHOD_CACHES = T.let(T.unsafe(nil), Hash)
@@ -976,13 +967,14 @@ class ActiveSupport::CurrentAttributes
   def _run_reset_callbacks(&block); end
   def attributes; end
   def attributes=(_arg0); end
+  def defaults; end
+  def defaults?; end
   def reset; end
-  def set(set_attributes); end
+  def set(attributes, &block); end
 
   private
 
-  def assign_attributes(new_attributes); end
-  def compute_attributes(keys); end
+  def resolve_defaults; end
 
   class << self
     def __callbacks; end
@@ -991,9 +983,12 @@ class ActiveSupport::CurrentAttributes
     def _reset_callbacks; end
     def _reset_callbacks=(value); end
     def after_reset(*methods, &block); end
-    def attribute(*names); end
+    def attribute(*names, default: T.unsafe(nil)); end
     def before_reset(*methods, &block); end
     def clear_all; end
+    def defaults; end
+    def defaults=(value); end
+    def defaults?; end
     def instance; end
     def reset(*_arg0, **_arg1, &_arg2); end
     def reset_all; end
@@ -1005,12 +1000,14 @@ class ActiveSupport::CurrentAttributes
     def current_instances; end
     def current_instances_key; end
     def generated_attribute_methods; end
-    def method_missing(name, *args, **_arg2, &block); end
+    def method_added(name); end
+    def method_missing(name, *_arg1, **_arg2, &_arg3); end
     def respond_to_missing?(name, _); end
   end
 end
 
 ActiveSupport::CurrentAttributes::INVALID_ATTRIBUTE_NAMES = T.let(T.unsafe(nil), Array)
+ActiveSupport::CurrentAttributes::NOT_SET = T.let(T.unsafe(nil), Object)
 
 module ActiveSupport::DeepMergeable
   def deep_merge(other, &block); end
@@ -1018,6 +1015,22 @@ module ActiveSupport::DeepMergeable
   def deep_merge?(other); end
 end
 
+module ActiveSupport::Delegation
+  class << self
+    def generate(owner, methods, location: T.unsafe(nil), to: T.unsafe(nil), prefix: T.unsafe(nil), allow_nil: T.unsafe(nil), nilable: T.unsafe(nil), private: T.unsafe(nil), as: T.unsafe(nil), signature: T.unsafe(nil)); end
+    def generate_method_missing(owner, target, allow_nil: T.unsafe(nil)); end
+  end
+end
+
+ActiveSupport::Delegation::RESERVED_METHOD_NAMES = T.let(T.unsafe(nil), Set)
+ActiveSupport::Delegation::RUBY_RESERVED_KEYWORDS = T.let(T.unsafe(nil), Array)
+
+class ActiveSupport::DelegationError < ::NoMethodError
+  class << self
+    def nil_target(method_name, target); end
+  end
+end
+
 module ActiveSupport::Dependencies
   class << self
     def _autoloaded_tracked_classes; end
@@ -1060,13 +1073,10 @@ module ActiveSupport::Dependencies::RequireDependency
 end
 
 class ActiveSupport::Deprecation
-  include ::ActiveSupport::Deprecation::InstanceDelegator
   include ::ActiveSupport::Deprecation::Behavior
   include ::ActiveSupport::Deprecation::Reporting
   include ::ActiveSupport::Deprecation::Disallowed
   include ::ActiveSupport::Deprecation::MethodWrapper
-  extend ::ActiveSupport::Deprecation::InstanceDelegator::ClassMethods
-  extend ::ActiveSupport::Deprecation::InstanceDelegator::OverrideDelegators
 
   def initialize(deprecation_horizon = T.unsafe(nil), gem_name = T.unsafe(nil)); end
 
@@ -1074,27 +1084,7 @@ class ActiveSupport::Deprecation
   def deprecation_horizon=(_arg0); end
 
   class << self
-    def allow(*_arg0, **_arg1, &_arg2); end
-    def begin_silence(*_arg0, **_arg1, &_arg2); end
-    def behavior(*_arg0, **_arg1, &_arg2); end
-    def behavior=(arg); end
-    def debug(*_arg0, **_arg1, &_arg2); end
-    def debug=(arg); end
-    def deprecate_methods(*_arg0, **_arg1, &_arg2); end
-    def deprecation_horizon(*_arg0, **_arg1, &_arg2); end
-    def deprecation_horizon=(arg); end
-    def deprecation_warning(deprecated_method_name, message = T.unsafe(nil), caller_backtrace = T.unsafe(nil)); end
-    def disallowed_behavior(*_arg0, **_arg1, &_arg2); end
-    def disallowed_behavior=(arg); end
-    def disallowed_warnings(*_arg0, **_arg1, &_arg2); end
-    def disallowed_warnings=(arg); end
-    def end_silence(*_arg0, **_arg1, &_arg2); end
-    def gem_name(*_arg0, **_arg1, &_arg2); end
-    def gem_name=(arg); end
-    def silence(*_arg0, **_arg1, &_arg2); end
-    def silenced(*_arg0, **_arg1, &_arg2); end
-    def silenced=(arg); end
-    def warn(message = T.unsafe(nil), callstack = T.unsafe(nil)); end
+    def _instance; end
   end
 end
 
@@ -1121,7 +1111,7 @@ module ActiveSupport::Deprecation::DeprecatedConstantAccessor
 end
 
 class ActiveSupport::Deprecation::DeprecatedConstantProxy < ::Module
-  def initialize(old_const, new_const, deprecator = T.unsafe(nil), message: T.unsafe(nil)); end
+  def initialize(old_const, new_const, deprecator, message: T.unsafe(nil)); end
 
   def append_features(base); end
   def class; end
@@ -1136,7 +1126,7 @@ class ActiveSupport::Deprecation::DeprecatedConstantProxy < ::Module
   private
 
   def const_missing(name); end
-  def method_missing(called, *args, &block); end
+  def method_missing(*_arg0, **_arg1, &_arg2); end
   def target; end
 
   class << self
@@ -1145,7 +1135,7 @@ class ActiveSupport::Deprecation::DeprecatedConstantProxy < ::Module
 end
 
 class ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy < ::ActiveSupport::Deprecation::DeprecationProxy
-  def initialize(instance, method, var = T.unsafe(nil), deprecator = T.unsafe(nil)); end
+  def initialize(instance, method, var = T.unsafe(nil), deprecator:); end
 
   private
 
@@ -1154,7 +1144,7 @@ class ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy < ::ActiveSupp
 end
 
 class ActiveSupport::Deprecation::DeprecatedObjectProxy < ::ActiveSupport::Deprecation::DeprecationProxy
-  def initialize(object, message, deprecator = T.unsafe(nil)); end
+  def initialize(object, message, deprecator); end
 
   private
 
@@ -1170,7 +1160,7 @@ class ActiveSupport::Deprecation::DeprecationProxy
   def method_missing(called, *args, &block); end
 
   class << self
-    def new(*args, &block); end
+    def new(*args, **kwargs, &block); end
   end
 end
 
@@ -1203,28 +1193,7 @@ module ActiveSupport::Deprecation::Disallowed
   def explicitly_allowed?(message); end
 end
 
-module ActiveSupport::Deprecation::InstanceDelegator
-  mixes_in_class_methods ::ActiveSupport::Deprecation::InstanceDelegator::ClassMethods
-  mixes_in_class_methods ::ActiveSupport::Deprecation::InstanceDelegator::OverrideDelegators
-
-  class << self
-    def included(base); end
-  end
-end
-
-module ActiveSupport::Deprecation::InstanceDelegator::ClassMethods
-  def _instance; end
-  def include(included_module); end
-  def instance; end
-  def method_added(method_name); end
-end
-
-ActiveSupport::Deprecation::InstanceDelegator::ClassMethods::MUTEX = T.let(T.unsafe(nil), Thread::Mutex)
-
-module ActiveSupport::Deprecation::InstanceDelegator::OverrideDelegators
-  def deprecation_warning(deprecated_method_name, message = T.unsafe(nil), caller_backtrace = T.unsafe(nil)); end
-  def warn(message = T.unsafe(nil), callstack = T.unsafe(nil)); end
-end
+ActiveSupport::Deprecation::MUTEX = T.let(T.unsafe(nil), Thread::Mutex)
 
 module ActiveSupport::Deprecation::MethodWrapper
   def deprecate_methods(target_module, *method_names); end
@@ -1299,6 +1268,7 @@ class ActiveSupport::Duration
   def <=>(other); end
   def ==(other); end
   def _parts; end
+  def abs(&_arg0); end
   def after(time = T.unsafe(nil)); end
   def ago(time = T.unsafe(nil)); end
   def as_json(options = T.unsafe(nil)); end
@@ -1321,17 +1291,21 @@ class ActiveSupport::Duration
   def is_a?(klass); end
   def iso8601(precision: T.unsafe(nil)); end
   def kind_of?(klass); end
+  def negative?(&_arg0); end
   def parts; end
+  def positive?(&_arg0); end
   def since(time = T.unsafe(nil)); end
+  def to_f(&_arg0); end
   def to_i; end
   def to_s; end
   def until(time = T.unsafe(nil)); end
   def value; end
   def variable?; end
+  def zero?(&_arg0); end
 
   private
 
-  def method_missing(method, *args, &block); end
+  def method_missing(*_arg0, **_arg1, &_arg2); end
   def raise_type_error(other); end
   def respond_to_missing?(method, _); end
   def sum(sign, time = T.unsafe(nil)); end
@@ -1449,7 +1423,7 @@ class ActiveSupport::EncryptedConfiguration < ::ActiveSupport::EncryptedFile
 
   def config; end
   def inspect; end
-  def method_missing(method, *args, **_arg2, &block); end
+  def method_missing(method, *_arg1, **_arg2, &_arg3); end
   def read; end
   def validate!; end
 
@@ -1536,6 +1510,8 @@ ActiveSupport::EnvironmentInquirer::LOCAL_ENVIRONMENTS = T.let(T.unsafe(nil), Ar
 class ActiveSupport::ErrorReporter
   def initialize(*subscribers, logger: T.unsafe(nil)); end
 
+  def debug_mode; end
+  def debug_mode=(_arg0); end
   def disable(subscriber); end
   def handle(*error_classes, severity: T.unsafe(nil), context: T.unsafe(nil), fallback: T.unsafe(nil), source: T.unsafe(nil)); end
   def logger; end
@@ -1544,11 +1520,14 @@ class ActiveSupport::ErrorReporter
   def report(error, handled: T.unsafe(nil), severity: T.unsafe(nil), context: T.unsafe(nil), source: T.unsafe(nil)); end
   def set_context(*_arg0, **_arg1, &_arg2); end
   def subscribe(subscriber); end
+  def unexpected(error, severity: T.unsafe(nil), context: T.unsafe(nil), source: T.unsafe(nil)); end
   def unsubscribe(subscriber); end
 end
 
+ActiveSupport::ErrorReporter::DEFAULT_RESCUE = T.let(T.unsafe(nil), Array)
 ActiveSupport::ErrorReporter::DEFAULT_SOURCE = T.let(T.unsafe(nil), String)
 ActiveSupport::ErrorReporter::SEVERITIES = T.let(T.unsafe(nil), Array)
+class ActiveSupport::ErrorReporter::UnexpectedError < ::Exception; end
 
 module ActiveSupport::ExecutionContext
   class << self
@@ -1658,25 +1637,12 @@ module ActiveSupport::ForkTracker
   class << self
     def after_fork(&block); end
     def after_fork_callback; end
-    def check!; end
     def hook!; end
     def unregister(callback); end
   end
 end
 
 module ActiveSupport::ForkTracker::CoreExt
-  def fork(*_arg0, **_arg1, &_arg2); end
-end
-
-module ActiveSupport::ForkTracker::CoreExtPrivate
-  include ::ActiveSupport::ForkTracker::CoreExt
-
-  private
-
-  def fork(*_arg0, **_arg1, &_arg2); end
-end
-
-module ActiveSupport::ForkTracker::ModernCoreExt
   def _fork; end
 end
 
@@ -1734,6 +1700,7 @@ class ActiveSupport::HashWithIndifferentAccess < ::Hash
   def to_hash; end
   def to_options; end
   def to_options!; end
+  def to_proc; end
   def transform_keys(hash = T.unsafe(nil), &block); end
   def transform_keys!(hash = T.unsafe(nil), &block); end
   def transform_values(&block); end
@@ -1761,13 +1728,13 @@ ActiveSupport::HashWithIndifferentAccess::NOT_GIVEN = T.let(T.unsafe(nil), Objec
 module ActiveSupport::HtmlSafeTranslation
   extend ::ActiveSupport::HtmlSafeTranslation
 
+  def html_safe_translation_key?(key); end
   def translate(key, **options); end
 
   private
 
   def html_escape_translation_options(options); end
   def html_safe_translation(translation); end
-  def html_safe_translation_key?(key); end
   def i18n_option?(name); end
 end
 
@@ -1849,7 +1816,20 @@ end
 class ActiveSupport::InheritableOptions < ::ActiveSupport::OrderedOptions
   def initialize(parent = T.unsafe(nil)); end
 
+  def ==(other); end
+  def each(&block); end
   def inheritable_copy; end
+  def inspect; end
+  def key?(key); end
+  def overridden?(key); end
+  def pretty_print(pp); end
+  def to_a; end
+  def to_h; end
+  def to_s; end
+
+  private
+
+  def own_key?(_arg0); end
 end
 
 module ActiveSupport::IsolatedExecutionState
@@ -1985,8 +1965,6 @@ end
 
 ActiveSupport::LogSubscriber::BLACK = T.let(T.unsafe(nil), String)
 ActiveSupport::LogSubscriber::BLUE = T.let(T.unsafe(nil), String)
-ActiveSupport::LogSubscriber::BOLD = T.let(T.unsafe(nil), ActiveSupport::Deprecation::DeprecatedObjectProxy)
-ActiveSupport::LogSubscriber::CLEAR = T.let(T.unsafe(nil), ActiveSupport::Deprecation::DeprecatedObjectProxy)
 ActiveSupport::LogSubscriber::CYAN = T.let(T.unsafe(nil), String)
 ActiveSupport::LogSubscriber::GREEN = T.let(T.unsafe(nil), String)
 ActiveSupport::LogSubscriber::LEVEL_CHECKS = T.let(T.unsafe(nil), Hash)
@@ -2007,6 +1985,7 @@ class ActiveSupport::Logger < ::Logger
 
   class << self
     def logger_outputs_to?(logger, *sources); end
+    def normalize_sources(sources); end
     def silencer; end
     def silencer=(val); end
   end
@@ -2026,16 +2005,10 @@ end
 module ActiveSupport::LoggerThreadSafeLevel
   extend ::ActiveSupport::Concern
 
-  def debug?; end
-  def error?; end
-  def fatal?; end
-  def info?; end
   def level; end
   def local_level; end
   def local_level=(level); end
   def log_at(level); end
-  def unknown?; end
-  def warn?; end
 
   private
 
@@ -2329,7 +2302,7 @@ class ActiveSupport::Multibyte::Chars
   def grapheme_length; end
   def limit(limit); end
   def match?(*_arg0, **_arg1, &_arg2); end
-  def method_missing(method, *args, &block); end
+  def method_missing(method, *_arg1, **_arg2, &_arg3); end
   def reverse; end
   def reverse!(*args); end
   def slice!(*args); end
@@ -2385,14 +2358,13 @@ class ActiveSupport::Notifications::Event
   def initialize(name, start, ending, transaction_id, payload); end
 
   def allocations; end
-  def children; end
   def cpu_time; end
   def duration; end
   def end; end
   def finish!; end
+  def gc_time; end
   def idle_time; end
   def name; end
-  def parent_of?(event); end
   def payload; end
   def payload=(_arg0); end
   def record; end
@@ -2405,10 +2377,10 @@ class ActiveSupport::Notifications::Event
   def now; end
   def now_allocations; end
   def now_cpu; end
+  def now_gc; end
 end
 
 class ActiveSupport::Notifications::Fanout
-  include ::Mutex_m
   include ::ActiveSupport::Notifications::FanoutIteration
 
   def initialize; end
@@ -2421,15 +2393,10 @@ class ActiveSupport::Notifications::Fanout
   def inspect; end
   def listeners_for(name); end
   def listening?(name); end
-  def lock; end
-  def locked?; end
   def publish(name, *args); end
   def publish_event(event); end
   def start(name, id, payload); end
   def subscribe(pattern = T.unsafe(nil), callable = T.unsafe(nil), monotonic: T.unsafe(nil), &block); end
-  def synchronize(&block); end
-  def try_lock; end
-  def unlock; end
   def unsubscribe(subscriber_or_name); end
   def wait; end
 end
@@ -2760,7 +2727,7 @@ class ActiveSupport::OptionMerger
   private
 
   def method_missing(method, *arguments, &block); end
-  def respond_to_missing?(*arguments); end
+  def respond_to_missing?(*_arg0, **_arg1, &_arg2); end
 end
 
 class ActiveSupport::OrderedHash < ::Hash
@@ -2778,7 +2745,7 @@ class ActiveSupport::OrderedOptions < ::Hash
   def dig(key, *identifiers); end
   def extractable_options?; end
   def inspect; end
-  def method_missing(name, *args); end
+  def method_missing(method, *args); end
 
   protected
 
@@ -2810,6 +2777,10 @@ ActiveSupport::ParameterFilter::FILTERED = T.let(T.unsafe(nil), String)
 
 class ActiveSupport::ProxyObject < ::BasicObject
   def raise(*args); end
+
+  class << self
+    def inherited(_subclass); end
+  end
 end
 
 class ActiveSupport::Railtie < ::Rails::Railtie; end
@@ -2898,9 +2869,6 @@ module ActiveSupport::Rescuable::ClassMethods
   def find_rescue_handler(exception); end
 end
 
-module ActiveSupport::RubyFeatures; end
-ActiveSupport::RubyFeatures::CLASS_SUBCLASSES = T.let(T.unsafe(nil), TrueClass)
-
 class ActiveSupport::SafeBuffer < ::String
   def initialize(str = T.unsafe(nil)); end
 
@@ -2918,7 +2886,6 @@ class ActiveSupport::SafeBuffer < ::String
   def chop(*args, &block); end
   def chop!(*args); end
   def chr; end
-  def clone_empty; end
   def concat(value); end
   def delete(*args, &block); end
   def delete!(*args); end
@@ -3012,7 +2979,7 @@ end
 class ActiveSupport::StringInquirer < ::String
   private
 
-  def method_missing(method_name, *arguments); end
+  def method_missing(method_name, *_arg1, **_arg2, &_arg3); end
   def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
 end
 
@@ -3051,7 +3018,6 @@ class ActiveSupport::SyntaxErrorProxy
   private
 
   def parse_message_for_trace; end
-  def source_location_eval?; end
 end
 
 class ActiveSupport::SyntaxErrorProxy::BacktraceLocation < ::Struct
@@ -3109,6 +3075,7 @@ end
 
 class ActiveSupport::TestCase < ::Minitest::Test
   include ::ActiveSupport::Testing::SetupAndTeardown
+  include ::ActiveSupport::Testing::TestsWithoutAssertions
   include ::ActiveSupport::Testing::TaggedLogging
   include ::ActiveSupport::Callbacks
   include ::ActiveSupport::Testing::Assertions
@@ -3196,7 +3163,7 @@ module ActiveSupport::Testing::ConstantLookup::ClassMethods
 end
 
 module ActiveSupport::Testing::ConstantStubbing
-  def stub_const(mod, constant, new_value); end
+  def stub_const(mod, constant, new_value, exists: T.unsafe(nil)); end
 end
 
 module ActiveSupport::Testing::Declarative
@@ -3205,8 +3172,8 @@ end
 
 module ActiveSupport::Testing::Deprecation
   def assert_deprecated(match = T.unsafe(nil), deprecator = T.unsafe(nil), &block); end
-  def assert_not_deprecated(deprecator = T.unsafe(nil), &block); end
-  def collect_deprecations(deprecator = T.unsafe(nil)); end
+  def assert_not_deprecated(deprecator, &block); end
+  def collect_deprecations(deprecator); end
 end
 
 module ActiveSupport::Testing::ErrorReporterAssertions
@@ -3287,6 +3254,7 @@ module ActiveSupport::Testing::Isolation::Subprocess
 end
 
 ActiveSupport::Testing::Isolation::Subprocess::ORIG_ARGV = T.let(T.unsafe(nil), Array)
+class ActiveSupport::Testing::Isolation::SubprocessCrashed < ::StandardError; end
 
 class ActiveSupport::Testing::Parallelization
   def initialize(worker_count); end
@@ -3306,6 +3274,19 @@ class ActiveSupport::Testing::Parallelization
   end
 end
 
+class ActiveSupport::Testing::Parallelization::PrerecordResultClass < ::Struct
+  def name; end
+  def name=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
 class ActiveSupport::Testing::Parallelization::Server
   include ::DRb::DRbUndumped
 
@@ -3413,6 +3394,10 @@ module ActiveSupport::Testing::TaggedLogging
   def tagged_logger; end
 end
 
+module ActiveSupport::Testing::TestsWithoutAssertions
+  def after_teardown; end
+end
+
 module ActiveSupport::Testing::TimeHelpers
   def after_teardown; end
   def freeze_time(with_usec: T.unsafe(nil), &block); end
@@ -3484,6 +3469,7 @@ class ActiveSupport::TimeWithZone
   def nsec; end
   def past?; end
   def period; end
+  def present?; end
   def prev_day?; end
   def respond_to?(sym, include_priv = T.unsafe(nil)); end
   def rfc2822; end
@@ -3601,7 +3587,7 @@ end
 module ActiveSupport::VERSION; end
 ActiveSupport::VERSION::MAJOR = T.let(T.unsafe(nil), Integer)
 ActiveSupport::VERSION::MINOR = T.let(T.unsafe(nil), Integer)
-ActiveSupport::VERSION::PRE = T.let(T.unsafe(nil), String)
+ActiveSupport::VERSION::PRE = T.let(T.unsafe(nil), T.untyped)
 ActiveSupport::VERSION::STRING = T.let(T.unsafe(nil), String)
 ActiveSupport::VERSION::TINY = T.let(T.unsafe(nil), Integer)
 
@@ -3648,6 +3634,7 @@ module ActiveSupport::XmlMini
   def _dasherize(key); end
   def _parse_binary(bin, entity); end
   def _parse_file(file, entity); end
+  def _parse_hex_binary(bin); end
   def cast_backend_name_to_module(name); end
   def current_thread_backend; end
   def current_thread_backend=(name); end
@@ -3701,13 +3688,13 @@ class Array
   def in_groups_of(number, fill_with = T.unsafe(nil), &block); end
   def including(*elements); end
   def inquiry; end
+  def present?; end
   def second; end
   def second_to_last; end
   def split(value = T.unsafe(nil), &block); end
   def third; end
   def third_to_last; end
   def to(position); end
-  def to_default_s(*args, **_arg1, &block); end
   def to_formatted_s(format = T.unsafe(nil)); end
   def to_fs(format = T.unsafe(nil)); end
   def to_param; end
@@ -3772,9 +3759,9 @@ class Date
   def minus_with_duration(other); end
   def noon; end
   def plus_with_duration(other); end
+  def present?; end
   def readable_inspect; end
   def since(seconds); end
-  def to_default_s(*args, **_arg1, &block); end
   def to_formatted_s(format = T.unsafe(nil)); end
   def to_fs(format = T.unsafe(nil)); end
   def to_time(form = T.unsafe(nil)); end
@@ -3927,12 +3914,12 @@ class DateTime < ::Date
   def midnight; end
   def noon; end
   def nsec; end
+  def present?; end
   def readable_inspect; end
   def seconds_since_midnight; end
   def seconds_until_end_of_day; end
   def since(seconds); end
   def subsec; end
-  def to_default_s(*args, **_arg1, &block); end
   def to_f; end
   def to_formatted_s(format = T.unsafe(nil)); end
   def to_fs(format = T.unsafe(nil)); end
@@ -3960,6 +3947,7 @@ end
 
 module Digest::UUID
   class << self
+    def nil_uuid; end
     def uuid_from_hash(hash_class, namespace, name); end
     def uuid_v3(uuid_namespace, name); end
     def uuid_v4; end
@@ -4037,6 +4025,7 @@ end
 class FalseClass
   def as_json(options = T.unsafe(nil)); end
   def blank?; end
+  def present?; end
   def to_param; end
 end
 
@@ -4073,6 +4062,7 @@ class Hash
   def extract!(*keys); end
   def extractable_options?; end
   def nested_under_indifferent_access; end
+  def present?; end
   def reverse_merge(other_hash); end
   def reverse_merge!(other_hash); end
   def reverse_update(other_hash); end
@@ -4307,7 +4297,7 @@ class Module
   def deep_dup; end
   def delegate(*methods, to: T.unsafe(nil), prefix: T.unsafe(nil), allow_nil: T.unsafe(nil), private: T.unsafe(nil)); end
   def delegate_missing_to(target, allow_nil: T.unsafe(nil)); end
-  def deprecate(*method_names, deprecator: T.unsafe(nil), **options); end
+  def deprecate(*method_names, deprecator:, **options); end
   def mattr_accessor(*syms, instance_reader: T.unsafe(nil), instance_writer: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), &blk); end
   def mattr_reader(*syms, instance_reader: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), location: T.unsafe(nil)); end
   def mattr_writer(*syms, instance_writer: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), location: T.unsafe(nil)); end
@@ -4330,11 +4320,10 @@ class Module
   private
 
   def attr_internal_define(attr_name, type); end
-  def attr_internal_ivar_name(attr); end
 
   class << self
     def attr_internal_naming_format; end
-    def attr_internal_naming_format=(_arg0); end
+    def attr_internal_naming_format=(format); end
   end
 end
 
@@ -4343,10 +4332,7 @@ module Module::Concerning
   def concerning(topic, prepend: T.unsafe(nil), &block); end
 end
 
-Module::DELEGATION_RESERVED_KEYWORDS = T.let(T.unsafe(nil), Array)
-Module::DELEGATION_RESERVED_METHOD_NAMES = T.let(T.unsafe(nil), Set)
-class Module::DelegationError < ::NoMethodError; end
-Module::RUBY_RESERVED_KEYWORDS = T.let(T.unsafe(nil), Array)
+Module::DelegationError = ActiveSupport::DelegationError
 
 class NameError < ::StandardError
   include ::ErrorHighlight::CoreExt
@@ -4365,6 +4351,7 @@ NameError::UNBOUND_METHOD_MODULE_NAME = T.let(T.unsafe(nil), UnboundMethod)
 class NilClass
   def as_json(options = T.unsafe(nil)); end
   def blank?; end
+  def present?; end
   def to_param; end
   def try(*_arg0); end
   def try!(*_arg0); end
@@ -4397,6 +4384,7 @@ class Numeric
   def minutes; end
   def petabyte; end
   def petabytes; end
+  def present?; end
   def second; end
   def seconds; end
   def terabyte; end
@@ -4416,11 +4404,11 @@ Numeric::TERABYTE = T.let(T.unsafe(nil), Integer)
 Numeric::ZETTABYTE = T.let(T.unsafe(nil), Integer)
 
 class Object < ::BasicObject
-  include ::ActiveSupport::ToJsonWithActiveSupportEncoder
   include ::ActiveSupport::Dependencies::RequireDependency
   include ::Kernel
   include ::PP::ObjectMixin
   include ::ActiveSupport::Tryable
+  include ::ActiveSupport::ToJsonWithActiveSupportEncoder
 
   def acts_like?(duck); end
   def as_json(options = T.unsafe(nil)); end
@@ -4445,7 +4433,7 @@ class Pathname
 end
 
 module Process
-  extend ::ActiveSupport::ForkTracker::ModernCoreExt
+  extend ::ActiveSupport::ForkTracker::CoreExt
 
   class << self
     def _fork; end
@@ -4514,6 +4502,7 @@ class String
   def mb_chars; end
   def parameterize(separator: T.unsafe(nil), preserve_case: T.unsafe(nil), locale: T.unsafe(nil)); end
   def pluralize(count = T.unsafe(nil), locale = T.unsafe(nil)); end
+  def present?; end
   def remove(*patterns); end
   def remove!(*patterns); end
   def safe_constantize; end
@@ -4548,6 +4537,7 @@ class Symbol
   include ::Comparable
 
   def as_json(options = T.unsafe(nil)); end
+  def present?; end
 end
 
 class Thread
@@ -4606,6 +4596,8 @@ class Time
   def next_year(years = T.unsafe(nil)); end
   def noon; end
   def plus_with_duration(other); end
+  def present?; end
+  def preserve_timezone; end
   def prev_day(days = T.unsafe(nil)); end
   def prev_month(months = T.unsafe(nil)); end
   def prev_year(years = T.unsafe(nil)); end
@@ -4613,15 +4605,18 @@ class Time
   def seconds_since_midnight; end
   def seconds_until_end_of_day; end
   def since(seconds); end
-  def to_default_s(*args, **_arg1, &block); end
   def to_formatted_s(format = T.unsafe(nil)); end
   def to_fs(format = T.unsafe(nil)); end
   def to_time; end
 
+  private
+
+  def active_support_local_zone; end
+
   class << self
     def ===(other); end
-    def at(*args, **kwargs); end
-    def at_with_coercion(*args, **kwargs); end
+    def at(time_or_number, *args, **_arg2); end
+    def at_with_coercion(time_or_number, *args, **_arg2); end
     def current; end
     def days_in_month(month, year = T.unsafe(nil)); end
     def days_in_year(year = T.unsafe(nil)); end
@@ -4642,6 +4637,7 @@ Time::DATE_FORMATS = T.let(T.unsafe(nil), Hash)
 class TrueClass
   def as_json(options = T.unsafe(nil)); end
   def blank?; end
+  def present?; end
   def to_param; end
 end
 
diff --git a/sorbet/rbi/gems/benchmark@0.3.0.rbi b/sorbet/rbi/gems/benchmark@0.3.0.rbi
new file mode 100644
index 00000000..71b6c3c4
--- /dev/null
+++ b/sorbet/rbi/gems/benchmark@0.3.0.rbi
@@ -0,0 +1,69 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `benchmark` gem.
+# Please instead update this file by running `bin/tapioca gem benchmark`.
+
+
+module Benchmark
+  private
+
+  def benchmark(caption = T.unsafe(nil), label_width = T.unsafe(nil), format = T.unsafe(nil), *labels); end
+  def bm(label_width = T.unsafe(nil), *labels, &blk); end
+  def bmbm(width = T.unsafe(nil)); end
+  def measure(label = T.unsafe(nil)); end
+  def realtime; end
+
+  class << self
+    def benchmark(caption = T.unsafe(nil), label_width = T.unsafe(nil), format = T.unsafe(nil), *labels); end
+    def bm(label_width = T.unsafe(nil), *labels, &blk); end
+    def bmbm(width = T.unsafe(nil)); end
+    def measure(label = T.unsafe(nil)); end
+    def realtime; end
+  end
+end
+
+class Benchmark::Job
+  def initialize(width); end
+
+  def item(label = T.unsafe(nil), &blk); end
+  def list; end
+  def report(label = T.unsafe(nil), &blk); end
+  def width; end
+end
+
+class Benchmark::Report
+  def initialize(width = T.unsafe(nil), format = T.unsafe(nil)); end
+
+  def item(label = T.unsafe(nil), *format, &blk); end
+  def list; end
+  def report(label = T.unsafe(nil), *format, &blk); end
+end
+
+class Benchmark::Tms
+  def initialize(utime = T.unsafe(nil), stime = T.unsafe(nil), cutime = T.unsafe(nil), cstime = T.unsafe(nil), real = T.unsafe(nil), label = T.unsafe(nil)); end
+
+  def *(x); end
+  def +(other); end
+  def -(other); end
+  def /(x); end
+  def add(&blk); end
+  def add!(&blk); end
+  def cstime; end
+  def cutime; end
+  def format(format = T.unsafe(nil), *args); end
+  def label; end
+  def real; end
+  def stime; end
+  def to_a; end
+  def to_h; end
+  def to_s; end
+  def total; end
+  def utime; end
+
+  protected
+
+  def memberwise(op, x); end
+end
+
+Benchmark::VERSION = T.let(T.unsafe(nil), String)
diff --git a/sorbet/rbi/gems/concurrent-ruby@1.3.3.rbi b/sorbet/rbi/gems/concurrent-ruby@1.3.4.rbi
similarity index 99%
rename from sorbet/rbi/gems/concurrent-ruby@1.3.3.rbi
rename to sorbet/rbi/gems/concurrent-ruby@1.3.4.rbi
index f1438c68..ae2e000d 100644
--- a/sorbet/rbi/gems/concurrent-ruby@1.3.3.rbi
+++ b/sorbet/rbi/gems/concurrent-ruby@1.3.4.rbi
@@ -4,6 +4,7 @@
 # This is an autogenerated file for types exported from the `concurrent-ruby` gem.
 # Please instead update this file by running `bin/tapioca gem concurrent-ruby`.
 
+
 module Concurrent
   extend ::Concurrent::Utility::EngineDetector
   extend ::Concurrent::Utility::NativeExtensionLoader
@@ -29,6 +30,7 @@ module Concurrent
     def available_processor_count; end
     def call_dataflow(method, executor, *inputs, &block); end
     def cpu_quota; end
+    def cpu_shares; end
     def create_simple_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
     def create_stdlib_logger(level = T.unsafe(nil), output = T.unsafe(nil)); end
     def dataflow(*inputs, &block); end
@@ -2344,12 +2346,14 @@ class Concurrent::Utility::ProcessorCounter
 
   def available_processor_count; end
   def cpu_quota; end
+  def cpu_shares; end
   def physical_processor_count; end
   def processor_count; end
 
   private
 
   def compute_cpu_quota; end
+  def compute_cpu_shares; end
   def compute_physical_processor_count; end
   def compute_processor_count; end
   def run(command); end
diff --git a/sorbet/rbi/gems/i18n@1.14.5.rbi b/sorbet/rbi/gems/i18n@1.14.6.rbi
similarity index 99%
rename from sorbet/rbi/gems/i18n@1.14.5.rbi
rename to sorbet/rbi/gems/i18n@1.14.6.rbi
index 6b48b83b..6037095f 100644
--- a/sorbet/rbi/gems/i18n@1.14.5.rbi
+++ b/sorbet/rbi/gems/i18n@1.14.6.rbi
@@ -4,6 +4,7 @@
 # This is an autogenerated file for types exported from the `i18n` gem.
 # Please instead update this file by running `bin/tapioca gem i18n`.
 
+
 module GetText; end
 
 class GetText::PoParser < ::Racc::Parser
diff --git a/sorbet/rbi/gems/logger@1.6.1.rbi b/sorbet/rbi/gems/logger@1.6.1.rbi
new file mode 100644
index 00000000..8a331890
--- /dev/null
+++ b/sorbet/rbi/gems/logger@1.6.1.rbi
@@ -0,0 +1,114 @@
+# typed: false
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `logger` gem.
+# Please instead update this file by running `bin/tapioca gem logger`.
+
+
+class Logger
+  include ::Logger::Severity
+
+  def initialize(logdev, shift_age = T.unsafe(nil), shift_size = T.unsafe(nil), level: T.unsafe(nil), progname: T.unsafe(nil), formatter: T.unsafe(nil), datetime_format: T.unsafe(nil), binmode: T.unsafe(nil), shift_period_suffix: T.unsafe(nil), reraise_write_errors: T.unsafe(nil)); end
+
+  def <<(msg); end
+  def add(severity, message = T.unsafe(nil), progname = T.unsafe(nil)); end
+  def close; end
+  def datetime_format; end
+  def datetime_format=(datetime_format); end
+  def debug(progname = T.unsafe(nil), &block); end
+  def debug!; end
+  def debug?; end
+  def error(progname = T.unsafe(nil), &block); end
+  def error!; end
+  def error?; end
+  def fatal(progname = T.unsafe(nil), &block); end
+  def fatal!; end
+  def fatal?; end
+  def formatter; end
+  def formatter=(_arg0); end
+  def info(progname = T.unsafe(nil), &block); end
+  def info!; end
+  def info?; end
+  def level; end
+  def level=(severity); end
+  def log(severity, message = T.unsafe(nil), progname = T.unsafe(nil)); end
+  def progname; end
+  def progname=(_arg0); end
+  def reopen(logdev = T.unsafe(nil)); end
+  def sev_threshold; end
+  def sev_threshold=(severity); end
+  def unknown(progname = T.unsafe(nil), &block); end
+  def warn(progname = T.unsafe(nil), &block); end
+  def warn!; end
+  def warn?; end
+  def with_level(severity); end
+
+  private
+
+  def format_message(severity, datetime, progname, msg); end
+  def format_severity(severity); end
+  def level_override; end
+end
+
+class Logger::Formatter
+  def initialize; end
+
+  def call(severity, time, progname, msg); end
+  def datetime_format; end
+  def datetime_format=(_arg0); end
+
+  private
+
+  def format_datetime(time); end
+  def msg2str(msg); end
+end
+
+Logger::Formatter::DatetimeFormat = T.let(T.unsafe(nil), String)
+Logger::Formatter::Format = T.let(T.unsafe(nil), String)
+
+class Logger::LogDevice
+  include ::Logger::Period
+  include ::MonitorMixin
+
+  def initialize(log = T.unsafe(nil), shift_age: T.unsafe(nil), shift_size: T.unsafe(nil), shift_period_suffix: T.unsafe(nil), binmode: T.unsafe(nil), reraise_write_errors: T.unsafe(nil)); end
+
+  def close; end
+  def dev; end
+  def filename; end
+  def reopen(log = T.unsafe(nil)); end
+  def write(message); end
+
+  private
+
+  def add_log_header(file); end
+  def check_shift_log; end
+  def create_logfile(filename); end
+  def lock_shift_log; end
+  def open_logfile(filename); end
+  def set_dev(log); end
+  def shift_log_age; end
+  def shift_log_period(period_end); end
+end
+
+module Logger::Period
+  private
+
+  def next_rotate_time(now, shift_age); end
+  def previous_period_end(now, shift_age); end
+
+  class << self
+    def next_rotate_time(now, shift_age); end
+    def previous_period_end(now, shift_age); end
+  end
+end
+
+Logger::Period::SiD = T.let(T.unsafe(nil), Integer)
+Logger::SEV_LABEL = T.let(T.unsafe(nil), Array)
+
+module Logger::Severity
+  class << self
+    def coerce(severity); end
+  end
+end
+
+Logger::Severity::LEVELS = T.let(T.unsafe(nil), Hash)
diff --git a/sorbet/rbi/gems/minitest@5.24.1.rbi b/sorbet/rbi/gems/minitest@5.25.1.rbi
similarity index 99%
rename from sorbet/rbi/gems/minitest@5.24.1.rbi
rename to sorbet/rbi/gems/minitest@5.25.1.rbi
index bf460813..60ce58f6 100644
--- a/sorbet/rbi/gems/minitest@5.24.1.rbi
+++ b/sorbet/rbi/gems/minitest@5.25.1.rbi
@@ -4,6 +4,7 @@
 # This is an autogenerated file for types exported from the `minitest` gem.
 # Please instead update this file by running `bin/tapioca gem minitest`.
 
+
 module Minitest
   class << self
     def __run(reporter, options); end
@@ -313,7 +314,6 @@ class Minitest::Test < ::Minitest::Runnable
   def new_exception(klass, msg, bt, kill = T.unsafe(nil)); end
   def run; end
   def sanitize_exception(e); end
-  def with_info_handler(&block); end
 
   class << self
     def i_suck_and_my_tests_are_order_dependent!; end
diff --git a/sorbet/rbi/gems/mutex_m@0.2.0.rbi b/sorbet/rbi/gems/mutex_m@0.2.0.rbi
deleted file mode 100644
index e09a6072..00000000
--- a/sorbet/rbi/gems/mutex_m@0.2.0.rbi
+++ /dev/null
@@ -1,29 +0,0 @@
-# typed: false
-
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `mutex_m` gem.
-# Please instead update this file by running `bin/tapioca gem mutex_m`.
-
-module Mutex_m
-  def initialize(*args, **_arg1); end
-
-  def mu_extended; end
-  def mu_lock; end
-  def mu_locked?; end
-  def mu_synchronize(&block); end
-  def mu_try_lock; end
-  def mu_unlock; end
-  def sleep(timeout = T.unsafe(nil)); end
-
-  private
-
-  def mu_initialize; end
-
-  class << self
-    def append_features(cl); end
-    def define_aliases(cl); end
-    def extend_object(obj); end
-  end
-end
-
-Mutex_m::VERSION = T.let(T.unsafe(nil), String)
diff --git a/sorbet/rbi/gems/railties@7.1.3.4.rbi b/sorbet/rbi/gems/railties@7.2.2.rbi
similarity index 93%
rename from sorbet/rbi/gems/railties@7.1.3.4.rbi
rename to sorbet/rbi/gems/railties@7.2.2.rbi
index f9f1614b..af8222ed 100644
--- a/sorbet/rbi/gems/railties@7.1.3.4.rbi
+++ b/sorbet/rbi/gems/railties@7.2.2.rbi
@@ -4,6 +4,7 @@
 # This is an autogenerated file for types exported from the `railties` gem.
 # Please instead update this file by running `bin/tapioca gem railties`.
 
+
 module Rails
   extend ::ActiveSupport::Autoload
   extend ::ActiveSupport::Benchmarkable
@@ -66,6 +67,7 @@ class Rails::Application < ::Rails::Engine
   def message_verifier(verifier_name); end
   def message_verifiers; end
   def migration_railties; end
+  def name; end
   def rake_tasks(&block); end
   def reload_routes!; end
   def reloader; end
@@ -78,8 +80,6 @@ class Rails::Application < ::Rails::Engine
   def sandbox=(_arg0); end
   def sandbox?; end
   def secret_key_base; end
-  def secrets; end
-  def secrets=(_arg0); end
   def server(&blk); end
   def to_app; end
   def watchable_args; end
@@ -95,7 +95,6 @@ class Rails::Application < ::Rails::Engine
   def run_runner_blocks(app); end
   def run_server_blocks(app); end
   def run_tasks_blocks(app); end
-  def validate_secret_key_base(secret_key_base); end
 
   private
 
@@ -103,8 +102,6 @@ class Rails::Application < ::Rails::Engine
   def build_request(env); end
   def coerce_same_site_protection(protection); end
   def filter_parameters; end
-  def generate_local_secret; end
-  def secrets_secret_key_base; end
 
   class << self
     def add_lib_to_load_path!(root); end
@@ -171,8 +168,6 @@ class Rails::Application::Configuration < ::Rails::Engine::Configuration
   def dom_testing_default_html_version=(_arg0); end
   def eager_load; end
   def eager_load=(_arg0); end
-  def enable_dependency_loading; end
-  def enable_dependency_loading=(value); end
   def enable_reloading; end
   def enable_reloading=(value); end
   def encoding; end
@@ -218,7 +213,7 @@ class Rails::Application::Configuration < ::Rails::Engine::Configuration
   def rake_eager_load; end
   def rake_eager_load=(_arg0); end
   def read_encrypted_secrets; end
-  def read_encrypted_secrets=(_arg0); end
+  def read_encrypted_secrets=(value); end
   def relative_url_root; end
   def relative_url_root=(_arg0); end
   def reload_classes_only_on_change; end
@@ -229,7 +224,7 @@ class Rails::Application::Configuration < ::Rails::Engine::Configuration
   def sandbox_by_default; end
   def sandbox_by_default=(_arg0); end
   def secret_key_base; end
-  def secret_key_base=(_arg0); end
+  def secret_key_base=(new_secret_key_base); end
   def server_timing; end
   def server_timing=(_arg0); end
   def session_options; end
@@ -242,10 +237,14 @@ class Rails::Application::Configuration < ::Rails::Engine::Configuration
   def time_zone=(_arg0); end
   def x; end
   def x=(_arg0); end
+  def yjit; end
+  def yjit=(_arg0); end
 
   private
 
   def credentials_defaults; end
+  def generate_local_secret; end
+  def generate_local_secret?; end
 end
 
 class Rails::Application::Configuration::Custom
@@ -255,11 +254,9 @@ class Rails::Application::Configuration::Custom
 
   private
 
-  def respond_to_missing?(symbol, *_arg1); end
+  def respond_to_missing?(symbol, _); end
 end
 
-Rails::Application::Configuration::ENABLE_DEPENDENCY_LOADING_WARNING = T.let(T.unsafe(nil), String)
-
 class Rails::Application::DefaultMiddlewareStack
   def initialize(app, config, paths); end
 
@@ -369,6 +366,10 @@ end
 
 class Rails::BacktraceCleaner < ::ActiveSupport::BacktraceCleaner
   def initialize; end
+
+  def clean(backtrace, kind = T.unsafe(nil)); end
+  def clean_frame(frame, kind = T.unsafe(nil)); end
+  def filter(backtrace, kind = T.unsafe(nil)); end
 end
 
 Rails::BacktraceCleaner::APP_DIRS_PATTERN = T.let(T.unsafe(nil), Regexp)
@@ -384,6 +385,7 @@ class Rails::Configuration::Generators
   def aliases=(_arg0); end
   def api_only; end
   def api_only=(_arg0); end
+  def apply_rubocop_autocorrect_after_generate!; end
   def colorize_logging; end
   def colorize_logging=(_arg0); end
   def fallbacks; end
@@ -442,7 +444,7 @@ class Rails::Engine < ::Rails::Railtie
   def env_config; end
   def helpers; end
   def helpers_paths; end
-  def isolated?(&block); end
+  def isolated?(&_arg0); end
   def load_console(app = T.unsafe(nil)); end
   def load_generators(app = T.unsafe(nil)); end
   def load_runner(app = T.unsafe(nil)); end
@@ -468,7 +470,7 @@ class Rails::Engine < ::Rails::Railtie
   def build_middleware; end
   def build_request(env); end
   def default_middleware_stack; end
-  def fixtures_in_root_and_not_in_vendor?(fixtures); end
+  def fixtures_in_root_and_not_in_vendor_or_dot_dir?(fixtures); end
   def has_migrations?; end
   def load_config_initializer(initializer); end
 
@@ -603,6 +605,7 @@ class Rails::Generators::Base < ::Thor::Group
 
   def class_collisions(*class_names); end
   def extract_last_module(nesting); end
+  def gem_ruby_version; end
   def indent(content, multiplier = T.unsafe(nil)); end
   def module_namespacing(&block); end
   def namespace; end
@@ -666,11 +669,16 @@ class Rails::Generators::GeneratedAttribute
   def required?; end
   def rich_text?; end
   def singular_name; end
+  def to_s; end
   def token?; end
   def type; end
   def type=(_arg0); end
   def virtual?; end
 
+  private
+
+  def print_attribute_options; end
+
   class << self
     def dangerous_name?(name); end
     def parse(column_definition); end
@@ -807,6 +815,8 @@ class Rails::InfoController < ::Rails::ApplicationController
   end
 end
 
+Rails::InfoController::RFC2396_PARSER = T.let(T.unsafe(nil), URI::RFC2396_Parser)
+
 module Rails::Initializable
   mixes_in_class_methods ::Rails::Initializable::ClassMethods
 
@@ -858,6 +868,8 @@ class Rails::MailersController < ::Rails::ApplicationController
   private
 
   def _layout(lookup_context, formats); end
+  def attachment_url(attachment); end
+  def attachments_for(email); end
   def find_part(format); end
   def find_preferred_part(*formats); end
   def find_preview; end
@@ -876,8 +888,9 @@ end
 module Rails::MailersController::HelperMethods
   include ::ActionController::Base::HelperMethods
 
-  def locale_query(*args, **_arg1, &block); end
-  def part_query(*args, **_arg1, &block); end
+  def attachment_url(*_arg0, **_arg1, &_arg2); end
+  def locale_query(*_arg0, **_arg1, &_arg2); end
+  def part_query(*_arg0, **_arg1, &_arg2); end
 end
 
 module Rails::Paths; end
@@ -945,6 +958,20 @@ class Rails::Paths::Root
   def filter_by(&block); end
 end
 
+class Rails::PwaController < ::Rails::ApplicationController
+  def manifest; end
+  def service_worker; end
+
+  private
+
+  def _layout(lookup_context, formats); end
+
+  class << self
+    def __callbacks; end
+    def middleware_stack; end
+  end
+end
+
 module Rails::Rack; end
 
 class Rails::Rack::Logger < ::ActiveSupport::LogSubscriber
@@ -956,6 +983,7 @@ class Rails::Rack::Logger < ::ActiveSupport::LogSubscriber
 
   def call_app(request, env); end
   def compute_tags(request); end
+  def finish_request_instrumentation(handle, logger_tag_pop_count); end
   def logger; end
   def started_request_message(request); end
 end
@@ -1008,7 +1036,7 @@ class Rails::Railtie
     private
 
     def generate_railtie_name(string); end
-    def method_missing(name, *args, **_arg2, &block); end
+    def method_missing(name, *_arg1, **_arg2, &_arg3); end
     def new(*_arg0); end
     def register_block_for(type, &blk); end
     def respond_to_missing?(name, _); end
@@ -1044,33 +1072,6 @@ class Rails::Railtie::Configuration
   end
 end
 
-class Rails::Secrets
-  class << self
-    def decrypt(data); end
-    def encrypt(data); end
-    def key; end
-    def parse(paths, env:); end
-    def read; end
-    def read_for_editing(&block); end
-    def root=(_arg0); end
-    def write(contents); end
-
-    private
-
-    def encryptor; end
-    def handle_missing_key; end
-    def key_path; end
-    def path; end
-    def preprocess(path); end
-    def read_key_file; end
-    def writing(contents); end
-  end
-end
-
-class Rails::Secrets::MissingKeyError < ::RuntimeError
-  def initialize; end
-end
-
 class Rails::SourceAnnotationExtractor
   def initialize(tag); end
 
@@ -1137,6 +1138,10 @@ class Rails::TestUnit::Filter
   def definition_for(method); end
 end
 
+class Rails::TestUnit::InvalidTestError < ::StandardError
+  def initialize(path, suggestion); end
+end
+
 class Rails::TestUnit::Runner
   def filters; end
 
@@ -1164,30 +1169,9 @@ end
 Rails::TestUnit::Runner::PATH_ARGUMENT_PATTERN = T.let(T.unsafe(nil), Regexp)
 Rails::TestUnit::Runner::TEST_FOLDERS = T.let(T.unsafe(nil), Array)
 
-class Rails::TestUnit::TestParser < ::Ripper
-  def initialize(*_arg0); end
-
-  def first_arg(arg, *_arg1); end
-  def just_lineno(*_arg0); end
-  def on_arg_paren(arg, *_arg1); end
-  def on_args_add(parts, part); end
-  def on_args_add_block(args, *rest); end
-  def on_args_new; end
-  def on_bodystmt(arg, *_arg1); end
-  def on_brace_block(*_arg0); end
-  def on_command(arg, *_arg1); end
-  def on_command_call(*_arg0, begin_lineno, _args); end
-  def on_def(begin_line, *_arg1); end
-  def on_do_block(*_arg0); end
-  def on_ident(*_arg0); end
-  def on_method_add_arg(arg, *_arg1); end
-  def on_method_add_block(begin_line, end_line); end
-  def on_stmts_add(arg, *_arg1); end
-  def on_stmts_new(*_arg0); end
-  def parse; end
-
+module Rails::TestUnit::TestParser
   class << self
-    def definition_for(method_obj); end
+    def definition_for(method); end
   end
 end
 
@@ -1195,7 +1179,7 @@ class Rails::TestUnitRailtie < ::Rails::Railtie; end
 module Rails::VERSION; end
 Rails::VERSION::MAJOR = T.let(T.unsafe(nil), Integer)
 Rails::VERSION::MINOR = T.let(T.unsafe(nil), Integer)
-Rails::VERSION::PRE = T.let(T.unsafe(nil), String)
+Rails::VERSION::PRE = T.let(T.unsafe(nil), T.untyped)
 Rails::VERSION::STRING = T.let(T.unsafe(nil), String)
 Rails::VERSION::TINY = T.let(T.unsafe(nil), Integer)
 
diff --git a/sorbet/rbi/gems/securerandom@0.3.1.rbi b/sorbet/rbi/gems/securerandom@0.3.1.rbi
new file mode 100644
index 00000000..2a446105
--- /dev/null
+++ b/sorbet/rbi/gems/securerandom@0.3.1.rbi
@@ -0,0 +1,49 @@
+# typed: false
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `securerandom` gem.
+# Please instead update this file by running `bin/tapioca gem securerandom`.
+
+
+class Random::Base
+  include ::Random::Formatter
+  extend ::Random::Formatter
+
+  def initialize(*_arg0); end
+
+  def bytes(_arg0); end
+  def rand(*_arg0); end
+  def seed; end
+end
+
+module Random::Formatter
+  def alphanumeric(n = T.unsafe(nil), chars: T.unsafe(nil)); end
+  def base64(n = T.unsafe(nil)); end
+  def hex(n = T.unsafe(nil)); end
+  def random_bytes(n = T.unsafe(nil)); end
+  def urlsafe_base64(n = T.unsafe(nil), padding = T.unsafe(nil)); end
+  def uuid; end
+  def uuid_v4; end
+  def uuid_v7(extra_timestamp_bits: T.unsafe(nil)); end
+
+  private
+
+  def choose(source, n); end
+  def gen_random(n); end
+end
+
+module SecureRandom
+  extend ::Random::Formatter
+
+  class << self
+    def bytes(n); end
+    def gen_random(n); end
+
+    private
+
+    def gen_random_openssl(n); end
+    def gen_random_urandom(n); end
+  end
+end
+
+SecureRandom::VERSION = T.let(T.unsafe(nil), String)
diff --git a/sorbet/rbi/gems/useragent@0.16.10.rbi b/sorbet/rbi/gems/useragent@0.16.10.rbi
new file mode 100644
index 00000000..bf7b53fb
--- /dev/null
+++ b/sorbet/rbi/gems/useragent@0.16.10.rbi
@@ -0,0 +1,9 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `useragent` gem.
+# Please instead update this file by running `bin/tapioca gem useragent`.
+
+
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca#manually-requiring-parts-of-a-gem