packwerk 1.1.0 → 1.3.0

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

@@ -1,6 +1,6 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `activestorage` gem.
-# Please instead update this file by running `dev typecheck update`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
@@ -27,6 +27,8 @@ module ActiveStorage
   def queues=(val); end
   def replace_on_assign_to_many; end
   def replace_on_assign_to_many=(val); end
+  def resolve_model_to_route; end
+  def resolve_model_to_route=(val); end
   def routes_prefix; end
   def routes_prefix=(val); end
   def service_urls_expire_in; end
@@ -67,6 +69,8 @@ module ActiveStorage
     def railtie_routes_url_helpers(include_path_helpers = T.unsafe(nil)); end
     def replace_on_assign_to_many; end
     def replace_on_assign_to_many=(val); end
+    def resolve_model_to_route; end
+    def resolve_model_to_route=(val); end
     def routes_prefix; end
     def routes_prefix=(val); end
     def service_urls_expire_in; end
@@ -143,6 +147,7 @@ class ActiveStorage::Analyzer::VideoAnalyzer < ::ActiveStorage::Analyzer
 
   def angle; end
   def computed_height; end
+  def container; end
   def display_aspect_ratio; end
   def display_height_scale; end
   def duration; end
@@ -264,12 +269,16 @@ module ActiveStorage::Attached::Model
 
   def attachment_changes; end
   def changed_for_autosave?; end
-  def reload(*_); end
+  def reload(*_arg0); end
+
+  private
+
+  def initialize_dup(*_arg0); end
 end
 
 module ActiveStorage::Attached::Model::ClassMethods
-  def has_many_attached(name, dependent: T.unsafe(nil), service: T.unsafe(nil)); end
-  def has_one_attached(name, dependent: T.unsafe(nil), service: T.unsafe(nil)); end
+  def has_many_attached(name, dependent: T.unsafe(nil), service: T.unsafe(nil), strict_loading: T.unsafe(nil)); end
+  def has_one_attached(name, dependent: T.unsafe(nil), service: T.unsafe(nil), strict_loading: T.unsafe(nil)); end
 
   private
 
@@ -292,32 +301,36 @@ class ActiveStorage::Attached::One < ::ActiveStorage::Attached
   def write_attachment(attachment); end
 end
 
-class ActiveStorage::Attachment < ::ActiveRecord::Base
+class ActiveStorage::Attachment < ::ActiveStorage::Record
   def autosave_associated_records_for_blob(*args); end
   def autosave_associated_records_for_record(*args); end
   def method_missing(method, *args, &block); end
   def purge; end
   def purge_later; end
+  def signed_id(*_arg0, &_arg1); end
+  def validate_associated_records_for_blob(*args); end
+  def variant(transformations); end
 
   private
 
   def analyze_blob_later; end
   def dependent; end
-  def identify_blob; end
   def mirror_blob_later; end
   def purge_dependent_blob_later; end
   def respond_to_missing?(name, include_private = T.unsafe(nil)); end
+  def variants; end
 
   class << self
     def __callbacks; end
     def _reflections; end
     def _validators; end
-    def attribute_type_decorations; end
     def defined_enums; end
   end
 end
 
 class ActiveStorage::BaseController < ::ActionController::Base
+  include(::ActionController::Live)
+  include(::ActiveStorage::Streaming)
   include(::ActiveStorage::SetCurrent)
 
 
@@ -327,55 +340,17 @@ class ActiveStorage::BaseController < ::ActionController::Base
 
   class << self
     def __callbacks; end
-    def _helpers; end
+    def etag_with_template_digest; end
     def middleware_stack; end
   end
 end
 
-module ActiveStorage::BaseController::HelperMethods
-  include(::ActionController::Base::HelperMethods)
-end
-
 class ActiveStorage::BaseJob < ::ActiveJob::Base
 end
 
-class ActiveStorage::Blob < ::ActiveRecord::Base
-  include(::ActiveStorage::Blob::Analyzable)
-  include(::ActiveStorage::Blob::Identifiable)
-  include(::ActiveStorage::Blob::Representable)
-
-  def after_add_for_variant_records; end
-  def after_add_for_variant_records=(_); end
-  def after_add_for_variant_records?; end
-  def after_remove_for_variant_records; end
-  def after_remove_for_variant_records=(_); end
-  def after_remove_for_variant_records?; end
-  def autosave_associated_records_for_variant_records(*args); end
-  def before_add_for_variant_records; end
-  def before_add_for_variant_records=(_); end
-  def before_add_for_variant_records?; end
-  def before_remove_for_variant_records; end
-  def before_remove_for_variant_records=(_); end
-  def before_remove_for_variant_records?; end
-  def validate_associated_records_for_variant_records(*args); end
-
+class ActiveStorage::Blob < ::ActiveStorage::Record
   class << self
-    def __callbacks; end
-    def _reflections; end
     def _validators; end
-    def after_add_for_variant_records; end
-    def after_add_for_variant_records=(value); end
-    def after_add_for_variant_records?; end
-    def after_remove_for_variant_records; end
-    def after_remove_for_variant_records=(value); end
-    def after_remove_for_variant_records?; end
-    def attribute_type_decorations; end
-    def before_add_for_variant_records; end
-    def before_add_for_variant_records=(value); end
-    def before_add_for_variant_records?; end
-    def before_remove_for_variant_records; end
-    def before_remove_for_variant_records=(value); end
-    def before_remove_for_variant_records?; end
     def defined_enums; end
   end
 end
@@ -395,12 +370,12 @@ end
 module ActiveStorage::Blob::Identifiable
   def identified?; end
   def identify; end
+  def identify_without_saving; end
 
   private
 
   def download_identifiable_chunk; end
   def identify_content_type; end
-  def update_service_metadata; end
 end
 
 module ActiveStorage::Blob::Representable
@@ -415,30 +390,12 @@ module ActiveStorage::Blob::Representable
 
   private
 
+  def default_variant_format; end
+  def default_variant_transformations; end
+  def format; end
   def variant_class; end
 end
 
-class ActiveStorage::BlobsController < ::ActiveStorage::BaseController
-  include(::ActiveStorage::SetBlob)
-
-  def show; end
-
-  private
-
-  def _layout(lookup_context, formats); end
-
-  class << self
-    def __callbacks; end
-    def _helpers; end
-    def middleware_stack; end
-  end
-end
-
-module ActiveStorage::BlobsController::HelperMethods
-  include(::ActionController::Base::HelperMethods)
-  include(::ActiveStorage::BaseController::HelperMethods)
-end
-
 class ActiveStorage::Current < ::ActiveSupport::CurrentAttributes
   class << self
     def host; end
@@ -457,16 +414,10 @@ class ActiveStorage::DirectUploadsController < ::ActiveStorage::BaseController
 
   class << self
     def __callbacks; end
-    def _helpers; end
     def middleware_stack; end
   end
 end
 
-module ActiveStorage::DirectUploadsController::HelperMethods
-  include(::ActionController::Base::HelperMethods)
-  include(::ActiveStorage::BaseController::HelperMethods)
-end
-
 class ActiveStorage::DiskController < ::ActiveStorage::BaseController
   include(::ActiveStorage::FileServer)
 
@@ -483,16 +434,10 @@ class ActiveStorage::DiskController < ::ActiveStorage::BaseController
 
   class << self
     def __callbacks; end
-    def _helpers; end
     def middleware_stack; end
   end
 end
 
-module ActiveStorage::DiskController::HelperMethods
-  include(::ActionController::Base::HelperMethods)
-  include(::ActiveStorage::BaseController::HelperMethods)
-end
-
 class ActiveStorage::Downloader
   def initialize(service); end
 
@@ -528,7 +473,7 @@ class ActiveStorage::Filename
   def initialize(filename); end
 
   def <=>(other); end
-  def as_json(*_); end
+  def as_json(*_arg0); end
   def base; end
   def extension; end
   def extension_with_delimiter; end
@@ -542,6 +487,23 @@ class ActiveStorage::Filename
   end
 end
 
+class ActiveStorage::FixtureSet
+  include(::ActiveSupport::Testing::FileFixtures)
+  include(::ActiveRecord::SecureToken)
+  extend(::ActiveRecord::SecureToken::ClassMethods)
+
+  def file_fixture_path; end
+  def file_fixture_path?; end
+  def prepare(instance, **attributes); end
+
+  class << self
+    def blob(filename:, **attributes); end
+    def file_fixture_path; end
+    def file_fixture_path=(value); end
+    def file_fixture_path?; end
+  end
+end
+
 class ActiveStorage::IntegrityError < ::ActiveStorage::Error
 end
 
@@ -580,7 +542,9 @@ class ActiveStorage::Preview
   def initialize(blob, variation_or_variation_key); end
 
   def blob; end
+  def download(&block); end
   def image; end
+  def key; end
   def processed; end
   def service_url(*args, &block); end
   def url(**options); end
@@ -598,6 +562,9 @@ end
 class ActiveStorage::Preview::UnprocessedError < ::StandardError
 end
 
+class ActiveStorage::PreviewError < ::ActiveStorage::Error
+end
+
 class ActiveStorage::Previewer
   def initialize(blob); end
 
@@ -670,6 +637,13 @@ class ActiveStorage::PurgeJob < ::ActiveStorage::BaseJob
   end
 end
 
+class ActiveStorage::Record < ::ActiveRecord::Base
+  class << self
+    def _validators; end
+    def defined_enums; end
+  end
+end
+
 module ActiveStorage::Reflection
 end
 
@@ -684,11 +658,16 @@ module ActiveStorage::Reflection::ActiveRecordExtensions::ClassMethods
   def reflect_on_attachment(attachment); end
 end
 
-class ActiveStorage::Reflection::HasManyAttachedReflection < ::ActiveRecord::Reflection::MacroReflection
+class ActiveStorage::Reflection::HasAttachedReflection < ::ActiveRecord::Reflection::MacroReflection
+  def variant(name, transformations); end
+  def variants; end
+end
+
+class ActiveStorage::Reflection::HasManyAttachedReflection < ::ActiveStorage::Reflection::HasAttachedReflection
   def macro; end
 end
 
-class ActiveStorage::Reflection::HasOneAttachedReflection < ::ActiveRecord::Reflection::MacroReflection
+class ActiveStorage::Reflection::HasOneAttachedReflection < ::ActiveStorage::Reflection::HasAttachedReflection
   def macro; end
 end
 
@@ -700,27 +679,6 @@ module ActiveStorage::Reflection::ReflectionExtension
   def reflection_class_for(macro); end
 end
 
-class ActiveStorage::RepresentationsController < ::ActiveStorage::BaseController
-  include(::ActiveStorage::SetBlob)
-
-  def show; end
-
-  private
-
-  def _layout(lookup_context, formats); end
-
-  class << self
-    def __callbacks; end
-    def _helpers; end
-    def middleware_stack; end
-  end
-end
-
-module ActiveStorage::RepresentationsController::HelperMethods
-  include(::ActionController::Base::HelperMethods)
-  include(::ActiveStorage::BaseController::HelperMethods)
-end
-
 class ActiveStorage::Service
   extend(::ActiveSupport::Autoload)
 
@@ -731,7 +689,7 @@ class ActiveStorage::Service
   def exist?(key); end
   def headers_for_direct_upload(key, filename:, content_type:, content_length:, checksum:); end
   def name; end
-  def name=(_); end
+  def name=(_arg0); end
   def open(*args, **options, &block); end
   def public?; end
   def update_metadata(key, **metadata); end
@@ -743,8 +701,8 @@ class ActiveStorage::Service
 
   def content_disposition_with(filename:, type: T.unsafe(nil)); end
   def instrument(operation, payload = T.unsafe(nil), &block); end
-  def private_url(key, expires_in:, filename:, disposition:, content_type:, **_); end
-  def public_url(key, **_); end
+  def private_url(key, expires_in:, filename:, disposition:, content_type:, **_arg5); end
+  def public_url(key, **_arg1); end
   def service_name; end
 
   class << self
@@ -794,6 +752,18 @@ module ActiveStorage::SetCurrent
   extend(::ActiveSupport::Concern)
 end
 
+module ActiveStorage::Streaming
+  include(::ActionController::Live)
+  extend(::ActionController::Live::ClassMethods)
+
+
+  private
+
+  def send_blob_stream(blob, disposition: T.unsafe(nil)); end
+end
+
+ActiveStorage::Streaming::DEFAULT_BLOB_STREAMING_DISPOSITION = T.let(T.unsafe(nil), String)
+
 module ActiveStorage::Transformers
   extend(::ActiveSupport::Autoload)
 end
@@ -832,13 +802,15 @@ class ActiveStorage::Variant
   def initialize(blob, variation_or_variation_key); end
 
   def blob; end
-  def content_type(*args, &block); end
-  def filename(*args, &block); end
-  def format(*args, &block); end
+  def content_type(*_arg0, &_arg1); end
+  def content_type_for_serving(*_arg0, &_arg1); end
+  def download(&block); end
+  def filename; end
+  def forced_disposition_for_serving; end
   def image; end
   def key; end
   def processed; end
-  def service(*args, &block); end
+  def service(*_arg0, &_arg1); end
   def service_url(*args, &block); end
   def url(expires_in: T.unsafe(nil), disposition: T.unsafe(nil)); end
   def variation; end
@@ -847,20 +819,15 @@ class ActiveStorage::Variant
 
   def process; end
   def processed?; end
-  def specification; end
-end
-
-class ActiveStorage::Variant::Specification < ::OpenStruct
 end
 
-class ActiveStorage::VariantRecord < ::ActiveRecord::Base
+class ActiveStorage::VariantRecord < ::ActiveStorage::Record
   def autosave_associated_records_for_blob(*args); end
 
   class << self
     def __callbacks; end
     def _reflections; end
     def _validators; end
-    def attribute_type_decorations; end
     def defined_enums; end
   end
 end
@@ -869,12 +836,14 @@ class ActiveStorage::VariantWithRecord
   def initialize(blob, variation); end
 
   def blob; end
+  def download(*_arg0, &_arg1); end
   def image; end
+  def key(*_arg0, &_arg1); end
   def process; end
   def processed; end
   def processed?; end
   def service_url(*args, &block); end
-  def url(**options); end
+  def url(*_arg0, &_arg1); end
   def variation; end
 
   private
@@ -887,9 +856,12 @@ end
 class ActiveStorage::Variation
   def initialize(transformations); end
 
+  def content_type; end
+  def default_to(defaults); end
   def digest; end
+  def format; end
   def key; end
-  def transform(file, format: T.unsafe(nil), &block); end
+  def transform(file, &block); end
   def transformations; end
 
   private

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

@@ -1,6 +1,6 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `activesupport` gem.
-# Please instead update this file by running `dev typecheck update`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: false
 
@@ -12,23 +12,28 @@ module ActiveSupport
   def parse_json_times=(val); end
   def test_order; end
   def test_order=(val); end
+  def test_parallelization_disabled; end
+  def test_parallelization_disabled=(val); end
 
   class << self
+    def disable_test_parallelization!; end
     def eager_load!; end
-    def escape_html_entities_in_json(*args, &block); end
+    def escape_html_entities_in_json(*_arg0, &_arg1); end
     def escape_html_entities_in_json=(arg); end
     def gem_version; end
-    def json_encoder(*args, &block); end
+    def json_encoder(*_arg0, &_arg1); end
     def json_encoder=(arg); end
     def parse_json_times; end
     def parse_json_times=(val); end
     def test_order; end
     def test_order=(val); end
-    def time_precision(*args, &block); end
+    def test_parallelization_disabled; end
+    def test_parallelization_disabled=(val); end
+    def time_precision(*_arg0, &_arg1); end
     def time_precision=(arg); end
     def to_time_preserves_timezone; end
     def to_time_preserves_timezone=(value); end
-    def use_standard_json_time_format(*args, &block); end
+    def use_standard_json_time_format(*_arg0, &_arg1); end
     def use_standard_json_time_format=(arg); end
     def utc_to_local_returns_utc_offset_times; end
     def utc_to_local_returns_utc_offset_times=(value); end
@@ -119,14 +124,14 @@ module ActiveSupport::Cache
 end
 
 class ActiveSupport::Cache::Entry
-  def initialize(value, compress: T.unsafe(nil), compress_threshold: T.unsafe(nil), version: T.unsafe(nil), expires_in: T.unsafe(nil), **_); end
+  def initialize(value, compress: T.unsafe(nil), compress_threshold: T.unsafe(nil), version: T.unsafe(nil), expires_in: T.unsafe(nil), **_arg5); end
 
+  def bytesize; end
   def dup_value!; end
   def expired?; end
   def expires_at; end
   def expires_at=(value); end
   def mismatched?(version); end
-  def size; end
   def value; end
   def version; end
 
@@ -142,10 +147,9 @@ ActiveSupport::Cache::Entry::DEFAULT_COMPRESS_LIMIT = T.let(T.unsafe(nil), Integ
 class ActiveSupport::Cache::FileStore < ::ActiveSupport::Cache::Store
   include(::ActiveSupport::Cache::Strategy::LocalCache)
 
-  def initialize(cache_path, options = T.unsafe(nil)); end
+  def initialize(cache_path, **options); end
 
   def cache_path; end
-  def delete_matched(matcher, options = T.unsafe(nil)); end
 
   private
 
@@ -185,7 +189,7 @@ class ActiveSupport::Cache::MemoryStore < ::ActiveSupport::Cache::Store
 
   private
 
-  def cached_size(key, entry); end
+  def cached_size(key, payload); end
   def delete_entry(key, **options); end
   def modify_value(name, amount, options); end
   def read_entry(key, **options); end
@@ -196,18 +200,34 @@ class ActiveSupport::Cache::MemoryStore < ::ActiveSupport::Cache::Store
   end
 end
 
+ActiveSupport::Cache::MemoryStore::DEFAULT_CODER = ActiveSupport::Cache::MemoryStore::DupCoder
+
+module ActiveSupport::Cache::MemoryStore::DupCoder
+  class << self
+    def dump(entry); end
+    def load(entry); end
+  end
+end
+
 ActiveSupport::Cache::MemoryStore::PER_ENTRY_OVERHEAD = T.let(T.unsafe(nil), Integer)
 
+module ActiveSupport::Cache::NullCoder
+  class << self
+    def dump(entry); end
+    def load(payload); end
+  end
+end
+
 class ActiveSupport::Cache::NullStore < ::ActiveSupport::Cache::Store
   include(::ActiveSupport::Cache::Strategy::LocalCache)
 
-  def delete_matched(matcher, options = T.unsafe(nil)); end
-
   class << self
     def supports_cache_versioning?; end
   end
 end
 
+ActiveSupport::Cache::OPTION_ALIASES = T.let(T.unsafe(nil), Hash)
+
 class ActiveSupport::Cache::Store
   def initialize(options = T.unsafe(nil)); end
 
@@ -237,6 +257,7 @@ class ActiveSupport::Cache::Store
 
   def delete_entry(key, **options); end
   def delete_multi_entries(entries, **options); end
+  def deserialize_entry(payload); end
   def expanded_key(key); end
   def expanded_version(key); end
   def get_entry_value(entry, name, options); end
@@ -246,10 +267,12 @@ class ActiveSupport::Cache::Store
   def merged_options(call_options); end
   def namespace_key(key, options = T.unsafe(nil)); end
   def normalize_key(key, options = T.unsafe(nil)); end
+  def normalize_options(options); end
   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 serialize_entry(entry); end
   def write_entry(key, entry, **options); end
   def write_multi_entries(hash, **options); end
 
@@ -264,6 +287,8 @@ class ActiveSupport::Cache::Store
   end
 end
 
+ActiveSupport::Cache::Store::DEFAULT_CODER = Marshal
+
 module ActiveSupport::Cache::Strategy
 end
 
@@ -271,6 +296,7 @@ module ActiveSupport::Cache::Strategy::LocalCache
   def cleanup(**options); end
   def clear(**options); end
   def decrement(name, amount = T.unsafe(nil), **options); end
+  def delete_matched(matcher, options = T.unsafe(nil)); end
   def increment(name, amount = T.unsafe(nil), **options); end
   def middleware; end
   def with_local_cache; end
@@ -366,17 +392,15 @@ class ActiveSupport::Callbacks::Callback
   def duplicates?(other); end
   def filter; end
   def kind; end
-  def kind=(_); end
+  def kind=(_arg0); end
   def matches?(_kind, _filter); end
   def merge_conditional_options(chain, if_option:, unless_option:); end
   def name; end
-  def name=(_); end
-  def raw_filter; end
+  def name=(_arg0); end
 
   private
 
   def check_conditionals(conditionals); end
-  def compute_identifier(filter); end
   def conditions_lambdas; end
 
   class << self
@@ -487,16 +511,15 @@ class ActiveSupport::Callbacks::Filters::Environment < ::Struct
   def value=(_); end
 
   class << self
-    def [](*_); end
+    def [](*_arg0); end
     def inspect; end
     def members; end
-    def new(*_); end
+    def new(*_arg0); end
   end
 end
 
 module ActiveSupport::CompareWithRange
   def ===(value); end
-  def cover?(value); end
   def include?(value); end
 end
 
@@ -605,7 +628,7 @@ class ActiveSupport::CurrentAttributes
   def _reset_callbacks; end
   def _run_reset_callbacks(&block); end
   def attributes; end
-  def attributes=(_); end
+  def attributes=(_arg0); end
   def reset; end
   def set(set_attributes); end
 
@@ -625,10 +648,10 @@ class ActiveSupport::CurrentAttributes
     def before_reset(&block); end
     def clear_all; end
     def instance; end
-    def reset(*args, &block); end
+    def reset(*_arg0, &_arg1); end
     def reset_all; end
     def resets(&block); end
-    def set(*args, &block); end
+    def set(*_arg0, &_arg1); end
 
     private
 
@@ -636,6 +659,7 @@ class ActiveSupport::CurrentAttributes
     def current_instances_key; end
     def generated_attribute_methods; end
     def method_missing(name, *args, &block); end
+    def respond_to_missing?(name, _); end
   end
 end
 
@@ -674,16 +698,12 @@ module ActiveSupport::Dependencies
   def loaded=(val); end
   def loading; end
   def loading=(val); end
-  def log(message); end
-  def logger; end
-  def logger=(val); end
   def mark_for_unload(const_desc); end
   def mechanism; end
   def mechanism=(val); end
   def new_constants_in(*descs); end
   def qualified_const_defined?(path); end
   def qualified_name_for(mod, name); end
-  def reference(klass); end
   def remove_constant(const); end
   def remove_unloadable_constants!; end
   def require_or_load(file_name, const_path = T.unsafe(nil)); end
@@ -691,15 +711,12 @@ module ActiveSupport::Dependencies
   def search_for_file(path_suffix); end
   def to_constant_name(desc); end
   def unhook!; end
-  def verbose; end
-  def verbose=(val); end
-  def warnings_on_first_load; end
-  def warnings_on_first_load=(val); end
   def will_unload?(const_desc); end
 
   private
 
   def real_mod_name(mod); end
+  def uninitialized_constant(qualified_name, const_name, receiver:); end
 
   class << self
     def _eager_load_paths; end
@@ -723,38 +740,13 @@ module ActiveSupport::Dependencies
     def loaded=(val); end
     def loading; end
     def loading=(val); end
-    def logger; end
-    def logger=(val); end
     def mechanism; end
     def mechanism=(val); end
     def run_interlock; end
     def unload_interlock; end
-    def verbose; end
-    def verbose=(val); end
-    def warnings_on_first_load; end
-    def warnings_on_first_load=(val); end
   end
 end
 
-module ActiveSupport::Dependencies::Blamable
-  def blame_file!(file); end
-  def blamed_files; end
-  def copy_blame!(exc); end
-  def describe_blame; end
-end
-
-class ActiveSupport::Dependencies::ClassCache
-  def initialize; end
-
-  def [](key); end
-  def clear!; end
-  def empty?; end
-  def get(key); end
-  def key?(key); end
-  def safe_get(key); end
-  def store(klass); end
-end
-
 class ActiveSupport::Dependencies::Interlock
   def initialize; end
 
@@ -798,8 +790,6 @@ module ActiveSupport::Dependencies::ModuleConstMissing
   end
 end
 
-ActiveSupport::Dependencies::Reference = T.let(T.unsafe(nil), ActiveSupport::Dependencies::ClassCache)
-
 class ActiveSupport::Dependencies::WatchStack
   include(::Enumerable)
 
@@ -865,26 +855,25 @@ class ActiveSupport::Deprecation
   def initialize(deprecation_horizon = T.unsafe(nil), gem_name = T.unsafe(nil)); end
 
   def deprecation_horizon; end
-  def deprecation_horizon=(_); end
+  def deprecation_horizon=(_arg0); end
 
   class << self
-    def allow(*args, &block); end
-    def behavior(*args, &block); end
+    def allow(*_arg0, &_arg1); end
+    def behavior(*_arg0, &_arg1); end
     def behavior=(arg); end
-    def debug(*args, &block); end
+    def debug(*_arg0, &_arg1); end
     def debug=(arg); end
-    def deprecate_methods(*args, &block); end
-    def deprecation_horizon(*args, &block); end
+    def deprecate_methods(*_arg0, &_arg1); end
+    def deprecation_horizon(*_arg0, &_arg1); end
     def deprecation_horizon=(arg); end
-    def disallowed_behavior(*args, &block); end
+    def disallowed_behavior(*_arg0, &_arg1); end
     def disallowed_behavior=(arg); end
-    def disallowed_warnings(*args, &block); end
+    def disallowed_warnings(*_arg0, &_arg1); end
     def disallowed_warnings=(arg); end
-    def gem_name(*args, &block); end
+    def gem_name(*_arg0, &_arg1); end
     def gem_name=(arg); end
-    def instance; end
-    def silence(*args, &block); end
-    def silenced(*args, &block); end
+    def silence(*_arg0, &_arg1); end
+    def silenced(*_arg0, &_arg1); end
     def silenced=(arg); end
   end
 end
@@ -893,7 +882,7 @@ module ActiveSupport::Deprecation::Behavior
   def behavior; end
   def behavior=(behavior); end
   def debug; end
-  def debug=(_); end
+  def debug=(_arg0); end
   def disallowed_behavior; end
   def disallowed_behavior=(behavior); end
 
@@ -914,11 +903,11 @@ class ActiveSupport::Deprecation::DeprecatedConstantProxy < ::Module
   def initialize(old_const, new_const, deprecator = T.unsafe(nil), message: T.unsafe(nil)); end
 
   def class; end
-  def hash(*args, &block); end
+  def hash(*_arg0, &_arg1); end
   def inspect; end
-  def instance_methods(*args, &block); end
-  def name(*args, &block); end
-  def respond_to?(*args, &block); end
+  def instance_methods(*_arg0, &_arg1); end
+  def name(*_arg0, &_arg1); end
+  def respond_to?(*_arg0, &_arg1); end
 
   private
 
@@ -965,7 +954,7 @@ end
 
 module ActiveSupport::Deprecation::Disallowed
   def disallowed_warnings; end
-  def disallowed_warnings=(_); end
+  def disallowed_warnings=(_arg0); end
 
   private
 
@@ -999,10 +988,10 @@ module ActiveSupport::Deprecation::Reporting
   def allow(allowed_warnings = T.unsafe(nil), if: T.unsafe(nil), &block); end
   def deprecation_warning(deprecated_method_name, message = T.unsafe(nil), caller_backtrace = T.unsafe(nil)); end
   def gem_name; end
-  def gem_name=(_); end
+  def gem_name=(_arg0); end
   def silence(&block); end
   def silenced; end
-  def silenced=(_); end
+  def silenced=(_arg0); end
   def warn(message = T.unsafe(nil), callstack = T.unsafe(nil)); end
 
   private
@@ -1024,12 +1013,14 @@ module ActiveSupport::DescendantsTracker
   def descendants; end
   def direct_descendants; end
   def inherited(base); end
+  def subclasses; end
 
   class << self
     def clear; end
     def descendants(klass); end
     def direct_descendants(klass); end
     def store_inherited(klass, descendant); end
+    def subclasses(klass); end
 
     private
 
@@ -1082,6 +1073,13 @@ class ActiveSupport::Duration
   def eql?(other); end
   def from_now(time = T.unsafe(nil)); end
   def hash; end
+  def in_days; end
+  def in_hours; end
+  def in_minutes; end
+  def in_months; end
+  def in_seconds; end
+  def in_weeks; end
+  def in_years; end
   def init_with(coder); end
   def inspect; end
   def instance_of?(klass); end
@@ -1089,13 +1087,13 @@ class ActiveSupport::Duration
   def iso8601(precision: T.unsafe(nil)); end
   def kind_of?(klass); end
   def parts; end
-  def parts=(_); end
+  def parts=(_arg0); end
   def since(time = T.unsafe(nil)); end
   def to_i; end
   def to_s; end
   def until(time = T.unsafe(nil)); end
   def value; end
-  def value=(_); end
+  def value=(_arg0); end
 
   private
 
@@ -1126,12 +1124,12 @@ class ActiveSupport::Duration::ISO8601Parser
   def initialize(string); end
 
   def mode; end
-  def mode=(_); end
+  def mode=(_arg0); end
   def parse!; end
   def parts; end
   def scanner; end
   def sign; end
-  def sign=(_); end
+  def sign=(_arg0); end
 
   private
 
@@ -1209,9 +1207,9 @@ class ActiveSupport::Duration::Scalar < ::Numeric
   def /(other); end
   def <=>(other); end
   def coerce(other); end
-  def to_f(*args, &block); end
-  def to_i(*args, &block); end
-  def to_s(*args, &block); end
+  def to_f(*_arg0, &_arg1); end
+  def to_i(*_arg0, &_arg1); end
+  def to_s(*_arg0, &_arg1); end
   def value; end
 
   private
@@ -1232,9 +1230,9 @@ end
 class ActiveSupport::EncryptedConfiguration < ::ActiveSupport::EncryptedFile
   def initialize(config_path:, key_path:, env_key:, raise_if_missing_key:); end
 
-  def [](*args, &block); end
+  def [](*_arg0, &_arg1); end
   def config; end
-  def fetch(*args, &block); end
+  def fetch(*_arg0, &_arg1); end
   def method_missing(method, *args, &block); end
   def read; end
   def write(contents); end
@@ -1260,6 +1258,7 @@ class ActiveSupport::EncryptedFile
 
   private
 
+  def check_key_length; end
   def decrypt(contents); end
   def encrypt(contents); end
   def encryptor; end
@@ -1269,12 +1268,17 @@ class ActiveSupport::EncryptedFile
   def writing(contents); end
 
   class << self
+    def expected_key_length; end
     def generate_key; end
   end
 end
 
 ActiveSupport::EncryptedFile::CIPHER = T.let(T.unsafe(nil), String)
 
+class ActiveSupport::EncryptedFile::InvalidKeyLengthError < ::RuntimeError
+  def initialize; end
+end
+
 class ActiveSupport::EncryptedFile::MissingContentError < ::RuntimeError
   def initialize(content_path); end
 end
@@ -1320,7 +1324,7 @@ class ActiveSupport::ExecutionWrapper
     def _run_callbacks; end
     def _run_callbacks=(value); end
     def active; end
-    def active=(_); end
+    def active=(_arg0); end
     def active?; end
     def inherited(other); end
     def register_hook(hook, outer: T.unsafe(nil)); end
@@ -1338,10 +1342,10 @@ class ActiveSupport::ExecutionWrapper::CompleteHook < ::Struct
   def hook=(_); end
 
   class << self
-    def [](*_); end
+    def [](*_arg0); end
     def inspect; end
     def members; end
-    def new(*_); end
+    def new(*_arg0); end
   end
 end
 
@@ -1353,10 +1357,10 @@ class ActiveSupport::ExecutionWrapper::RunHook < ::Struct
   def hook=(_); end
 
   class << self
-    def [](*_); end
+    def [](*_arg0); end
     def inspect; end
     def members; end
-    def new(*_); end
+    def new(*_arg0); end
   end
 end
 
@@ -1390,10 +1394,14 @@ module ActiveSupport::ForkTracker
 end
 
 module ActiveSupport::ForkTracker::CoreExt
-  def fork(*_); end
+  def fork(*_arg0, &_arg1); end
 end
 
 module ActiveSupport::ForkTracker::CoreExtPrivate
+
+  private
+
+  def fork(*_arg0, &_arg1); end
 end
 
 module ActiveSupport::Gzip
@@ -1404,7 +1412,7 @@ module ActiveSupport::Gzip
 end
 
 class ActiveSupport::Gzip::Stream < ::StringIO
-  def initialize(*_); end
+  def initialize(*_arg0); end
 
   def close; end
 end
@@ -1434,8 +1442,8 @@ class ActiveSupport::HashWithIndifferentAccess < ::Hash
   def merge(*hashes, &block); end
   def merge!(*other_hashes, &block); end
   def nested_under_indifferent_access; end
-  def regular_update(*_); end
-  def regular_writer(_, _); end
+  def regular_update(*_arg0); end
+  def regular_writer(_arg0, _arg1); end
   def reject(*args, &block); end
   def replace(other_hash); end
   def reverse_merge(other_hash); end
@@ -1533,6 +1541,7 @@ class ActiveSupport::Inflector::Inflections
 
   class << self
     def instance(locale = T.unsafe(nil)); end
+    def instance_or_fallback(locale); end
   end
 end
 
@@ -1574,13 +1583,13 @@ ActiveSupport::JSON::DATE_REGEX = T.let(T.unsafe(nil), Regexp)
 module ActiveSupport::JSON::Encoding
   class << self
     def escape_html_entities_in_json; end
-    def escape_html_entities_in_json=(_); end
+    def escape_html_entities_in_json=(_arg0); end
     def json_encoder; end
-    def json_encoder=(_); end
+    def json_encoder=(_arg0); end
     def time_precision; end
-    def time_precision=(_); end
+    def time_precision=(_arg0); end
     def use_standard_json_time_format; end
-    def use_standard_json_time_format=(_); end
+    def use_standard_json_time_format=(_arg0); end
   end
 end
 
@@ -1600,6 +1609,11 @@ class ActiveSupport::KeyGenerator
   def initialize(secret, options = T.unsafe(nil)); end
 
   def generate_key(salt, key_size = T.unsafe(nil)); end
+
+  class << self
+    def hash_digest_class; end
+    def hash_digest_class=(klass); end
+  end
 end
 
 module ActiveSupport::LazyLoadHooks
@@ -1625,6 +1639,7 @@ class ActiveSupport::LogSubscriber < ::ActiveSupport::Subscriber
   def finish(name, id, payload); end
   def info(progname = T.unsafe(nil), &block); end
   def logger; end
+  def publish_event(event); end
   def start(name, id, payload); end
   def unknown(progname = T.unsafe(nil), &block); end
   def warn(progname = T.unsafe(nil), &block); end
@@ -1632,6 +1647,7 @@ class ActiveSupport::LogSubscriber < ::ActiveSupport::Subscriber
   private
 
   def color(text, color, bold = T.unsafe(nil)); end
+  def log_exception(name, e); end
 
   class << self
     def colorize_logging; end
@@ -1639,7 +1655,11 @@ class ActiveSupport::LogSubscriber < ::ActiveSupport::Subscriber
     def flush_all!; end
     def log_subscribers; end
     def logger; end
-    def logger=(_); end
+    def logger=(_arg0); end
+
+    private
+
+    def fetch_public_methods(subscriber, inherit_all); end
   end
 end
 
@@ -1698,7 +1718,6 @@ module ActiveSupport::LoggerThreadSafeLevel
   extend(::ActiveSupport::Concern)
 
   def add(severity, message = T.unsafe(nil), progname = T.unsafe(nil), &block); end
-  def after_initialize; end
   def debug?; end
   def error?; end
   def fatal?; end
@@ -1785,6 +1804,7 @@ class ActiveSupport::Messages::Metadata
 
   def fresh?; end
   def match?(purpose); end
+  def parse_expires_at(expires_at); end
 
   class << self
     def verify(message, purpose); end
@@ -1849,17 +1869,16 @@ class ActiveSupport::Multibyte::Chars
 
   def initialize(string); end
 
-  def <=>(*args, &block); end
-  def =~(*args, &block); end
-  def acts_like_string?(*args, &block); end
+  def <=>(*_arg0, &_arg1); end
+  def =~(*_arg0, &_arg1); end
+  def acts_like_string?(*_arg0, &_arg1); end
   def as_json(options = T.unsafe(nil)); end
   def compose; end
   def decompose; end
   def grapheme_length; end
   def limit(limit); end
-  def match?(*args, &block); end
+  def match?(*_arg0, &_arg1); end
   def method_missing(method, *args, &block); end
-  def normalize(form = T.unsafe(nil)); end
   def reverse; end
   def reverse!(*args); end
   def slice!(*args); end
@@ -1876,10 +1895,6 @@ class ActiveSupport::Multibyte::Chars
 
   def chars(string); end
   def respond_to_missing?(method, include_private); end
-
-  class << self
-    def consumes?(string); end
-  end
 end
 
 module ActiveSupport::Multibyte::Unicode
@@ -1889,23 +1904,13 @@ module ActiveSupport::Multibyte::Unicode
   def decompose(type, codepoints); end
   def default_normalization_form; end
   def default_normalization_form=(_); end
-  def downcase(string); end
-  def normalize(string, form = T.unsafe(nil)); end
-  def pack_graphemes(unpacked); end
-  def swapcase(string); end
   def tidy_bytes(string, force = T.unsafe(nil)); end
-  def unpack_graphemes(string); end
-  def upcase(string); end
 
   private
 
   def recode_windows1252_chars(string); end
 end
 
-ActiveSupport::Multibyte::Unicode::NORMALIZATION_FORMS = T.let(T.unsafe(nil), Array)
-
-ActiveSupport::Multibyte::Unicode::NORMALIZATION_FORM_ALIASES = T.let(T.unsafe(nil), Hash)
-
 ActiveSupport::Multibyte::Unicode::UNICODE_VERSION = T.let(T.unsafe(nil), String)
 
 module ActiveSupport::Notifications
@@ -1914,8 +1919,9 @@ module ActiveSupport::Notifications
     def instrumenter; end
     def monotonic_subscribe(pattern = T.unsafe(nil), callback = T.unsafe(nil), &block); end
     def notifier; end
-    def notifier=(_); end
+    def notifier=(_arg0); end
     def publish(name, *args); end
+    def publish_event(event); end
     def subscribe(pattern = T.unsafe(nil), callback = T.unsafe(nil), &block); end
     def subscribed(callback, pattern = T.unsafe(nil), monotonic: T.unsafe(nil), &block); end
     def unsubscribe(subscriber_or_name); end
@@ -1931,13 +1937,13 @@ class ActiveSupport::Notifications::Event
   def cpu_time; end
   def duration; end
   def end; end
-  def end=(ending); end
   def finish!; end
   def idle_time; end
   def name; end
   def parent_of?(event); end
   def payload; end
-  def payload=(_); end
+  def payload=(_arg0); end
+  def record; end
   def start!; end
   def time; end
   def transaction_id; end
@@ -1947,13 +1953,6 @@ class ActiveSupport::Notifications::Event
   def now; end
   def now_allocations; end
   def now_cpu; end
-
-  class << self
-
-    private
-
-    def clock_gettime_supported?; end
-  end
 end
 
 class ActiveSupport::Notifications::Fanout
@@ -1967,6 +1966,7 @@ class ActiveSupport::Notifications::Fanout
   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
@@ -1987,15 +1987,16 @@ class ActiveSupport::Notifications::Fanout::Subscribers::AllMessages
   def initialize(delegate); end
 
   def finish(name, id, payload); end
-  def matches?(_); end
+  def matches?(_arg0); end
   def publish(name, *args); end
   def start(name, id, payload); end
   def subscribed_to?(name); end
-  def unsubscribe!(*_); end
+  def unsubscribe!(*_arg0); end
 end
 
 class ActiveSupport::Notifications::Fanout::Subscribers::EventObject < ::ActiveSupport::Notifications::Fanout::Subscribers::Evented
   def finish(name, id, payload); end
+  def publish_event(event); end
   def start(name, id, payload); end
 
   private
@@ -2010,6 +2011,7 @@ class ActiveSupport::Notifications::Fanout::Subscribers::Evented
   def matches?(name); end
   def pattern; end
   def publish(name, *args); end
+  def publish_event(event); end
   def start(name, id, payload); end
   def subscribed_to?(name); end
   def unsubscribe!(name); end
@@ -2051,10 +2053,12 @@ end
 class ActiveSupport::Notifications::Instrumenter
   def initialize(notifier); end
 
+  def buffer; end
   def finish(name, payload); end
   def finish_with_state(listeners_state, name, payload); end
   def id; end
   def instrument(name, payload = T.unsafe(nil)); end
+  def new_event(name, payload = T.unsafe(nil)); end
   def start(name, payload); end
 
   private
@@ -2062,6 +2066,13 @@ class ActiveSupport::Notifications::Instrumenter
   def unique_id; end
 end
 
+class ActiveSupport::Notifications::Instrumenter::Buffer
+  def initialize(instrumenter); end
+
+  def flush; end
+  def instrument(name, payload = T.unsafe(nil), &block); end
+end
+
 module ActiveSupport::NumberHelper
   extend(::ActiveSupport::Autoload)
   extend(::ActiveSupport::NumberHelper)
@@ -2080,12 +2091,12 @@ class ActiveSupport::NumberHelper::NumberConverter
 
   def execute; end
   def namespace; end
-  def namespace=(_); end
+  def namespace=(_arg0); end
   def namespace?; end
   def number; end
   def opts; end
   def validate_float; end
-  def validate_float=(_); end
+  def validate_float=(_arg0); end
   def validate_float?; end
 
   private
@@ -2228,7 +2239,6 @@ class ActiveSupport::NumberHelper::RoundingHelper
 
   def absolute_precision(number); end
   def convert_to_decimal(number); end
-  def significant; end
 end
 
 class ActiveSupport::OptionMerger
@@ -2237,7 +2247,6 @@ class ActiveSupport::OptionMerger
 
   private
 
-  def invoke_method(method, arguments, options, &block); end
   def method_missing(method, *arguments, &block); end
 end
 
@@ -2254,11 +2263,12 @@ class ActiveSupport::OrderedOptions < ::Hash
   def [](key); end
   def []=(key, value); end
   def extractable_options?; end
+  def inspect; end
   def method_missing(name, *args); end
 
   protected
 
-  def _get(_); end
+  def _get(_arg0); end
 
   private
 
@@ -2327,12 +2337,12 @@ class ActiveSupport::Reloader < ::ActiveSupport::ExecutionWrapper
   def _run_class_unload_callbacks(&block); end
   def _run_prepare_callbacks(&block); end
   def check; end
-  def check=(_); end
+  def check=(_arg0); end
   def check?; end
   def class_unload!(&block); end
   def complete!; end
   def executor; end
-  def executor=(_); end
+  def executor=(_arg0); end
   def executor?; end
   def release_unload_lock!; end
   def require_unload_lock!; end
@@ -2386,7 +2396,7 @@ class ActiveSupport::SafeBuffer < ::String
   def initialize(str = T.unsafe(nil)); end
 
   def %(args); end
-  def *(*_); end
+  def *(*_arg0); end
   def +(other); end
   def <<(value); end
   def [](*args); end
@@ -2423,6 +2433,8 @@ class ActiveSupport::SafeBuffer < ::String
   def rstrip(*args, &block); end
   def rstrip!(*args); end
   def safe_concat(value); end
+  def scrub(*args, &block); end
+  def scrub!(*args); end
   def slice(*args, &block); end
   def slice!(*args); end
   def squeeze(*args, &block); end
@@ -2450,7 +2462,7 @@ class ActiveSupport::SafeBuffer < ::String
 
   def html_escape_interpolated_argument(arg); end
   def initialize_copy(other); end
-  def original_concat(*_); end
+  def original_concat(*_arg0); end
   def set_block_back_references(block, match_data); end
 end
 
@@ -2502,6 +2514,7 @@ class ActiveSupport::Subscriber
 
   def finish(name, id, payload); end
   def patterns; end
+  def publish_event(event); end
   def start(name, id, payload); end
 
   private
@@ -2509,7 +2522,7 @@ class ActiveSupport::Subscriber
   def event_stack; end
 
   class << self
-    def attach_to(namespace, subscriber = T.unsafe(nil), notifier = T.unsafe(nil)); end
+    def attach_to(namespace, subscriber = T.unsafe(nil), notifier = T.unsafe(nil), inherit_all: T.unsafe(nil)); end
     def detach_from(namespace, notifier = T.unsafe(nil)); end
     def method_added(event); end
     def subscribers; end
@@ -2517,6 +2530,7 @@ class ActiveSupport::Subscriber
     private
 
     def add_event_subscriber(event); end
+    def fetch_public_methods(subscriber, inherit_all); end
     def find_attached_subscriber; end
     def invalid_event?(event); end
     def namespace; end
@@ -2537,10 +2551,10 @@ class ActiveSupport::SubscriberQueueRegistry
 end
 
 module ActiveSupport::TaggedLogging
-  def clear_tags!(*args, &block); end
+  def clear_tags!(*_arg0, &_arg1); end
   def flush; end
-  def pop_tags(*args, &block); end
-  def push_tags(*args, &block); end
+  def pop_tags(*_arg0, &_arg1); end
+  def push_tags(*_arg0, &_arg1); end
   def tagged(*tags); end
 
   class << self
@@ -2560,7 +2574,7 @@ end
 
 module ActiveSupport::TaggedLogging::LocalTagStorage
   def current_tags; end
-  def current_tags=(_); end
+  def current_tags=(_arg0); end
 
   class << self
     def extended(base); end
@@ -2769,16 +2783,16 @@ class ActiveSupport::Testing::SimpleStubs::Stub < ::Struct
   def original_method=(_); end
 
   class << self
-    def [](*_); end
+    def [](*_arg0); end
     def inspect; end
     def members; end
-    def new(*_); end
+    def new(*_arg0); end
   end
 end
 
 module ActiveSupport::Testing::TaggedLogging
   def before_setup; end
-  def tagged_logger=(_); end
+  def tagged_logger=(_arg0); end
 
   private
 
@@ -2809,10 +2823,10 @@ class ActiveSupport::TimeWithZone
   def <=>(other); end
   def acts_like_time?; end
   def advance(options); end
-  def after?(_); end
+  def after?(_arg0); end
   def ago(other); end
   def as_json(options = T.unsafe(nil)); end
-  def before?(_); end
+  def before?(_arg0); end
   def between?(min, max); end
   def blank?; end
   def change(options); end
@@ -2946,7 +2960,7 @@ class ActiveSupport::TimeZone
     def all; end
     def clear; end
     def country_zones(country_code); end
-    def create(*_); end
+    def create(*_arg0); end
     def find_tzinfo(name); end
     def new(name); end
     def seconds_to_utc_offset(seconds, colon = T.unsafe(nil)); end
@@ -3015,8 +3029,8 @@ module ActiveSupport::XmlMini
   def backend; end
   def backend=(name); end
   def depth; end
-  def depth=(_); end
-  def parse(*args, &block); end
+  def depth=(_arg0); end
+  def parse(*_arg0, &_arg1); end
   def rename_key(key, options = T.unsafe(nil)); end
   def to_tag(key, value, options); end
   def with_backend(name); end
@@ -3037,9 +3051,9 @@ ActiveSupport::XmlMini::FORMATTING = T.let(T.unsafe(nil), Hash)
 
 module ActiveSupport::XmlMini::FileLike
   def content_type; end
-  def content_type=(_); end
+  def content_type=(_arg0); end
   def original_filename; end
-  def original_filename=(_); end
+  def original_filename=(_arg0); end
 end
 
 ActiveSupport::XmlMini::PARSING = T.let(T.unsafe(nil), Hash)
@@ -3059,14 +3073,11 @@ module ActiveSupport::XmlMini_REXML
   def merge!(hash, key, value); end
   def merge_element!(hash, element, depth); end
   def merge_texts!(hash, element); end
+  def require_rexml; end
 end
 
 ActiveSupport::XmlMini_REXML::CONTENT_KEY = T.let(T.unsafe(nil), String)
 
-module ActiveSupport::MarshalWithAutoloading
-  def load(source, proc = T.unsafe(nil)); end
-end
-
 class Array
   include(::Enumerable)
   include(::JSON::Ext::Generator::GeneratorMethods::Array)
@@ -3082,13 +3093,9 @@ class Array
   def forty_two; end
   def fourth; end
   def from(position); end
-  def in_groups(number, fill_with = T.unsafe(nil)); end
-  def in_groups_of(number, fill_with = T.unsafe(nil)); end
   def including(*elements); end
-  def inquiry; end
   def second; end
   def second_to_last; end
-  def split(value = T.unsafe(nil)); end
   def sum(init = T.unsafe(nil), &block); end
   def third; end
   def third_to_last; end
@@ -3167,7 +3174,7 @@ class Date
     def beginning_of_week; end
     def beginning_of_week=(week_start); end
     def beginning_of_week_default; end
-    def beginning_of_week_default=(_); end
+    def beginning_of_week_default=(_arg0); end
     def current; end
     def find_beginning_of_week!(week_start); end
     def tomorrow; end
@@ -3355,15 +3362,45 @@ Digest::UUID::URL_NAMESPACE = T.let(T.unsafe(nil), String)
 
 Digest::UUID::X500_NAMESPACE = T.let(T.unsafe(nil), String)
 
+module ERB::Util
+
+  private
+
+  def h(s); end
+  def html_escape(s); end
+  def html_escape_once(s); end
+  def json_escape(s); end
+  def unwrapped_html_escape(s); end
+
+  class << self
+    def h(s); end
+    def html_escape(s); end
+    def html_escape_once(s); end
+    def json_escape(s); end
+    def unwrapped_html_escape(s); end
+  end
+end
+
+ERB::Util::HTML_ESCAPE = T.let(T.unsafe(nil), Hash)
+
+ERB::Util::HTML_ESCAPE_ONCE_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+ERB::Util::JSON_ESCAPE = T.let(T.unsafe(nil), Hash)
+
+ERB::Util::JSON_ESCAPE_REGEXP = T.let(T.unsafe(nil), Regexp)
+
 module Enumerable
   def as_json(options = T.unsafe(nil)); end
   def compact_blank; end
   def exclude?(object); end
   def excluding(*elements); end
+  def in_order_of(key, series); end
   def including(*elements); end
   def index_by; end
   def index_with(default = T.unsafe(nil)); end
   def many?; end
+  def maximum(key); end
+  def minimum(key); end
   def pick(*keys); end
   def pluck(*keys); end
   def sum(identity = T.unsafe(nil), &block); end
@@ -3371,8 +3408,6 @@ module Enumerable
 end
 
 class Exception
-  include(::ActiveSupport::Dependencies::Blamable)
-
   def as_json(options = T.unsafe(nil)); end
 end
 
@@ -3410,7 +3445,6 @@ class Hash
   def deep_transform_keys!(&block); end
   def deep_transform_values(&block); end
   def deep_transform_values!(&block); end
-  def except(*keys); end
   def except!(*keys); end
   def extract!(*keys); end
   def extractable_options?; end
@@ -3451,6 +3485,8 @@ module I18n
   extend(::I18n::Base)
 
   class << self
+    def fallbacks; end
+    def fallbacks=(fallbacks); end
     def interpolate(string, values); end
     def interpolate_hash(string, values); end
     def new_double_nested_cache; end
@@ -3469,6 +3505,7 @@ I18n::RESERVED_KEYS_PATTERN = T.let(T.unsafe(nil), Regexp)
 
 class I18n::Railtie < ::Rails::Railtie
   class << self
+    def forward_raise_on_missing_translations_config(app); end
     def include_fallbacks_module; end
     def init_fallbacks(fallbacks); end
     def initialize_i18n(app); end
@@ -3486,10 +3523,32 @@ class IO
   def as_json(options = T.unsafe(nil)); end
 end
 
+class IO::ConsoleMode
+  def echo=(_arg0); end
+  def raw(*_arg0); end
+  def raw!(*_arg0); end
+
+  private
+
+  def initialize_copy(_arg0); end
+end
+
 IO::EWOULDBLOCKWaitReadable = IO::EAGAINWaitReadable
 
 IO::EWOULDBLOCKWaitWritable = IO::EAGAINWaitWritable
 
+IO::PRIORITY = T.let(T.unsafe(nil), Integer)
+
+IO::READABLE = T.let(T.unsafe(nil), Integer)
+
+IO::WRITABLE = T.let(T.unsafe(nil), Integer)
+
+class IPAddr
+  include(::Comparable)
+
+  def as_json(options = T.unsafe(nil)); end
+end
+
 class Integer < ::Numeric
   include(::JSON::Ext::Generator::GeneratorMethods::Integer)
 
@@ -3500,7 +3559,6 @@ class Integer < ::Numeric
 end
 
 module Kernel
-  def class_eval(*args, &block); end
 
   private
 
@@ -3518,14 +3576,9 @@ module Kernel
 end
 
 class LoadError < ::ScriptError
-  def is_missing?(location); end
-end
-
-module LoggerSilence
-  extend(::ActiveSupport::Concern)
+  include(::DidYouMean::Correctable)
 
-  include(::ActiveSupport::LoggerThreadSafeLevel)
-  include(::ActiveSupport::LoggerSilence)
+  def is_missing?(location); end
 end
 
 class Method
@@ -3558,9 +3611,6 @@ class Module
   def module_parent; end
   def module_parent_name; end
   def module_parents; end
-  def parent; end
-  def parent_name; end
-  def parents; end
   def redefine_method(method, &block); end
   def redefine_singleton_method(method, &block); end
   def remove_possible_method(method); end
@@ -3580,7 +3630,7 @@ class Module
 
   class << self
     def attr_internal_naming_format; end
-    def attr_internal_naming_format=(_); end
+    def attr_internal_naming_format=(_arg0); end
   end
 end
 
@@ -3603,6 +3653,10 @@ class NameError < ::StandardError
 
   def missing_name; end
   def missing_name?(name); end
+
+  private
+
+  def real_mod_name(mod); end
 end
 
 class NilClass
@@ -3611,8 +3665,8 @@ class NilClass
   def as_json(options = T.unsafe(nil)); end
   def blank?; end
   def to_param; end
-  def try(_method_name = T.unsafe(nil), *_); end
-  def try!(_method_name = T.unsafe(nil), *_); end
+  def try(_method_name = T.unsafe(nil), *_arg1); end
+  def try!(_method_name = T.unsafe(nil), *_arg1); end
 end
 
 class Numeric
@@ -3667,6 +3721,8 @@ class Object < ::BasicObject
   include(::ActiveSupport::ForkTracker::CoreExt)
   include(::ActiveSupport::ForkTracker::CoreExtPrivate)
   include(::Kernel)
+  include(::ActiveSupport::ForkTracker::CoreExt)
+  include(::ActiveSupport::ForkTracker::CoreExtPrivate)
   include(::JSON::Ext::Generator::GeneratorMethods::Object)
   include(::ActiveSupport::Tryable)
   include(::ActiveSupport::Dependencies::Loadable)
@@ -3697,6 +3753,10 @@ class Pathname
   def as_json(options = T.unsafe(nil)); end
 end
 
+class Process::Status
+  def as_json(options = T.unsafe(nil)); end
+end
+
 class Range
   include(::ActiveSupport::RangeWithFormat)
   include(::ActiveSupport::CompareWithRange)
@@ -3714,12 +3774,20 @@ class Regexp
   def multiline?; end
 end
 
+module Singleton
+  mixes_in_class_methods(::Singleton::SingletonClassMethods)
+
+  def duplicable?; end
+end
+
+Singleton::VERSION = T.let(T.unsafe(nil), String)
+
 class String
   include(::Comparable)
-  include(::Colorize::InstanceMethods)
   include(::JSON::Ext::Generator::GeneratorMethods::String)
-  extend(::Colorize::ClassMethods)
+  include(::Colorize::InstanceMethods)
   extend(::JSON::Ext::Generator::GeneratorMethods::String::Extend)
+  extend(::Colorize::ClassMethods)
 
   def acts_like_string?; end
   def as_json(options = T.unsafe(nil)); end
@@ -3738,6 +3806,7 @@ class String
   def html_safe; end
   def humanize(capitalize: T.unsafe(nil), keep_id_suffix: T.unsafe(nil)); end
   def in_time_zone(zone = T.unsafe(nil)); end
+  def inquiry; end
   def is_utf8?; end
   def last(limit = T.unsafe(nil)); end
   def mb_chars; end
@@ -3779,16 +3848,10 @@ Struct::HTMLElementDescription = Struct
 
 Struct::Passwd = Etc::Passwd
 
-Struct::Tms = Process::Tms
-
 class Symbol
   include(::Comparable)
 
   def as_json(options = T.unsafe(nil)); end
-  def end_with?(*suffixes); end
-  def ends_with?(*suffixes); end
-  def start_with?(*prefixes); end
-  def starts_with?(*prefixes); end
 end
 
 class Time
@@ -3852,8 +3915,8 @@ class Time
 
   class << self
     def ===(other); end
-    def at(*args); end
-    def at_with_coercion(*args); end
+    def at(*args, **kwargs); end
+    def at_with_coercion(*args, **kwargs); end
     def current; end
     def days_in_month(month, year = T.unsafe(nil)); end
     def days_in_year(year = T.unsafe(nil)); end
@@ -3864,7 +3927,7 @@ class Time
     def zone; end
     def zone=(time_zone); end
     def zone_default; end
-    def zone_default=(_); end
+    def zone_default=(_arg0); end
   end
 end
 
@@ -3880,6 +3943,42 @@ class TrueClass
   def to_param; end
 end
 
+module URI
+  include(::URI::RFC2396_REGEXP)
+
+  class << self
+    def parser; end
+  end
+end
+
+class URI::File < ::URI::Generic
+  def check_password(user); end
+  def check_user(user); end
+  def check_userinfo(user); end
+  def set_host(v); end
+  def set_password(v); end
+  def set_port(v); end
+  def set_user(v); end
+  def set_userinfo(v); end
+
+  class << self
+    def build(args); end
+  end
+end
+
+URI::File::COMPONENT = T.let(T.unsafe(nil), Array)
+
+class URI::Generic
+  include(::URI::RFC2396_REGEXP)
+  include(::URI)
+
+  def as_json(options = T.unsafe(nil)); end
+end
+
+URI::Parser = URI::RFC2396_Parser
+
+URI::REGEXP = URI::RFC2396_REGEXP
+
 class UnboundMethod
   include(::MethodSource::SourceLocation::UnboundMethodExtensions)
   include(::MethodSource::MethodExtensions)