diff --git a/Library/Homebrew/sorbet/rbi/gems/rack@2.2.3.rbi b/Library/Homebrew/sorbet/rbi/gems/rack@2.2.3.rbi
new file mode 100644
index 0000000000000000000000000000000000000000..a1119dbde94da6bca3c380a2ac1ade70912ad831
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/rack@2.2.3.rbi
@@ -0,0 +1,188 @@
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rack` gem.
+# Please instead update this file by running `tapioca sync`.
+
+# typed: true
+
+module Rack
+end
+
+class Rack::QueryParser
+  def initialize(params_class, key_space_limit, param_depth_limit); end
+
+  def key_space_limit; end
+  def make_params; end
+  def new_depth_limit(param_depth_limit); end
+  def new_space_limit(key_space_limit); end
+  def normalize_params(params, name, v, depth); end
+  def param_depth_limit; end
+  def parse_nested_query(qs, d = T.unsafe(nil)); end
+  def parse_query(qs, d = T.unsafe(nil), &unescaper); end
+
+  private
+
+  def params_hash_has_key?(hash, key); end
+  def params_hash_type?(obj); end
+  def unescape(s); end
+
+  class << self
+    def make_default(key_space_limit, param_depth_limit); end
+  end
+end
+
+Rack::QueryParser::COMMON_SEP = T.let(T.unsafe(nil), Hash)
+
+Rack::QueryParser::DEFAULT_SEP = T.let(T.unsafe(nil), Regexp)
+
+class Rack::QueryParser::InvalidParameterError < ::ArgumentError
+end
+
+class Rack::QueryParser::ParameterTypeError < ::TypeError
+end
+
+class Rack::QueryParser::Params
+  def initialize(limit); end
+
+  def [](key); end
+  def []=(key, value); end
+  def key?(key); end
+  def to_h; end
+  def to_params_hash; end
+end
+
+module Rack::Utils
+
+  private
+
+  def add_cookie_to_header(header, key, value); end
+  def add_remove_cookie_to_header(header, key, value = T.unsafe(nil)); end
+  def best_q_match(q_value_header, available_mimes); end
+  def build_nested_query(value, prefix = T.unsafe(nil)); end
+  def build_query(params); end
+  def byte_ranges(env, size); end
+  def clean_path_info(path_info); end
+  def clock_time; end
+  def delete_cookie_header!(header, key, value = T.unsafe(nil)); end
+  def escape(s); end
+  def escape_html(string); end
+  def escape_path(s); end
+  def get_byte_ranges(http_range, size); end
+  def make_delete_cookie_header(header, key, value); end
+  def parse_cookies(env); end
+  def parse_cookies_header(header); end
+  def parse_nested_query(qs, d = T.unsafe(nil)); end
+  def parse_query(qs, d = T.unsafe(nil), &unescaper); end
+  def q_values(q_value_header); end
+  def rfc2109(time); end
+  def rfc2822(time); end
+  def secure_compare(a, b); end
+  def select_best_encoding(available_encodings, accept_encoding); end
+  def set_cookie_header!(header, key, value); end
+  def status_code(status); end
+  def unescape(s, encoding = T.unsafe(nil)); end
+  def unescape_path(s); end
+  def valid_path?(path); end
+
+  class << self
+    def add_cookie_to_header(header, key, value); end
+    def add_remove_cookie_to_header(header, key, value = T.unsafe(nil)); end
+    def best_q_match(q_value_header, available_mimes); end
+    def build_nested_query(value, prefix = T.unsafe(nil)); end
+    def build_query(params); end
+    def byte_ranges(env, size); end
+    def clean_path_info(path_info); end
+    def clock_time; end
+    def default_query_parser; end
+    def default_query_parser=(_arg0); end
+    def delete_cookie_header!(header, key, value = T.unsafe(nil)); end
+    def escape(s); end
+    def escape_html(string); end
+    def escape_path(s); end
+    def get_byte_ranges(http_range, size); end
+    def key_space_limit; end
+    def key_space_limit=(v); end
+    def make_delete_cookie_header(header, key, value); end
+    def multipart_part_limit; end
+    def multipart_part_limit=(_arg0); end
+    def param_depth_limit; end
+    def param_depth_limit=(v); end
+    def parse_cookies(env); end
+    def parse_cookies_header(header); end
+    def parse_nested_query(qs, d = T.unsafe(nil)); end
+    def parse_query(qs, d = T.unsafe(nil), &unescaper); end
+    def q_values(q_value_header); end
+    def rfc2109(time); end
+    def rfc2822(time); end
+    def secure_compare(a, b); end
+    def select_best_encoding(available_encodings, accept_encoding); end
+    def set_cookie_header!(header, key, value); end
+    def status_code(status); end
+    def unescape(s, encoding = T.unsafe(nil)); end
+    def unescape_path(s); end
+    def valid_path?(path); end
+  end
+end
+
+Rack::Utils::COMMON_SEP = T.let(T.unsafe(nil), Hash)
+
+class Rack::Utils::Context
+  def initialize(app_f, app_r); end
+
+  def app; end
+  def call(env); end
+  def context(env, app = T.unsafe(nil)); end
+  def for; end
+  def recontext(app); end
+end
+
+Rack::Utils::DEFAULT_SEP = T.let(T.unsafe(nil), Regexp)
+
+Rack::Utils::ESCAPE_HTML = T.let(T.unsafe(nil), Hash)
+
+Rack::Utils::ESCAPE_HTML_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+Rack::Utils::HTTP_STATUS_CODES = T.let(T.unsafe(nil), Hash)
+
+class Rack::Utils::HeaderHash < ::Hash
+  def initialize(hash = T.unsafe(nil)); end
+
+  def [](k); end
+  def []=(k, v); end
+  def clear; end
+  def delete(k); end
+  def each; end
+  def has_key?(k); end
+  def include?(k); end
+  def key?(k); end
+  def member?(k); end
+  def merge(other); end
+  def merge!(other); end
+  def replace(other); end
+  def to_hash; end
+
+  protected
+
+  def names; end
+
+  private
+
+  def initialize_copy(other); end
+
+  class << self
+    def [](headers); end
+  end
+end
+
+Rack::Utils::InvalidParameterError = Rack::QueryParser::InvalidParameterError
+
+Rack::Utils::KeySpaceConstrainedParams = Rack::QueryParser::Params
+
+Rack::Utils::NULL_BYTE = T.let(T.unsafe(nil), String)
+
+Rack::Utils::PATH_SEPS = T.let(T.unsafe(nil), Regexp)
+
+Rack::Utils::ParameterTypeError = Rack::QueryParser::ParameterTypeError
+
+Rack::Utils::STATUS_WITH_NO_ENTITY_BODY = T.let(T.unsafe(nil), Hash)
+
+Rack::Utils::SYMBOL_TO_STATUS_CODE = T.let(T.unsafe(nil), Hash)
diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop-rails@2.8.1.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop-rails@2.8.1.rbi
new file mode 100644
index 0000000000000000000000000000000000000000..8a03e433def0fd533e8bd2be66636ef91ac896bd
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/rubocop-rails@2.8.1.rbi
@@ -0,0 +1,1642 @@
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rubocop-rails` gem.
+# Please instead update this file by running `tapioca sync`.
+
+# typed: true
+
+module RuboCop
+end
+
+module RuboCop::Cop
+end
+
+module RuboCop::Cop::ActiveRecordHelper
+  extend(::RuboCop::AST::NodePattern::Macros)
+
+  def external_dependency_checksum; end
+  def find_belongs_to(param0); end
+  def find_set_table_name(param0); end
+  def foreign_key_of(belongs_to); end
+  def in_where?(node); end
+  def resolve_relation_into_column(name:, class_node:, table:); end
+  def schema; end
+  def table_name(class_node); end
+end
+
+RuboCop::Cop::ActiveRecordHelper::WHERE_METHODS = T.let(T.unsafe(nil), Array)
+
+module RuboCop::Cop::IndexMethod
+  def autocorrect(node); end
+  def on_block(node); end
+  def on_csend(node); end
+  def on_send(node); end
+
+  private
+
+  def execute_correction(corrector, node, correction); end
+  def extract_captures(match); end
+  def handle_possible_offense(node, match, match_desc); end
+  def new_method_name; end
+  def on_bad_each_with_object(_node); end
+  def on_bad_hash_brackets_map(_node); end
+  def on_bad_map_to_h(_node); end
+  def on_bad_to_h(_node); end
+  def prepare_correction(node); end
+end
+
+class RuboCop::Cop::IndexMethod::Autocorrection < ::Struct
+  def block_node; end
+  def block_node=(_); end
+  def leading; end
+  def leading=(_); end
+  def match; end
+  def match=(_); end
+  def set_new_arg_name(transformed_argname, corrector); end
+  def set_new_body_expression(transforming_body_expr, corrector); end
+  def set_new_method_name(new_method_name, corrector); end
+  def strip_prefix_and_suffix(node, corrector); end
+  def trailing; end
+  def trailing=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def from_each_with_object(node, match); end
+    def from_hash_brackets_map(node, match); end
+    def from_map_to_h(node, match); end
+    def from_to_h(node, match); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class RuboCop::Cop::IndexMethod::Captures < ::Struct
+  def noop_transformation?; end
+  def transformed_argname; end
+  def transformed_argname=(_); end
+  def transforming_body_expr; end
+  def transforming_body_expr=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+module RuboCop::Cop::Rails
+end
+
+class RuboCop::Cop::Rails::ActionFilter < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::ConfigurableEnforcedStyle)
+
+  def autocorrect(node); end
+  def on_block(node); end
+  def on_send(node); end
+
+  private
+
+  def bad_methods; end
+  def check_method_node(node); end
+  def good_methods; end
+  def message(node); end
+  def preferred_method(method); end
+end
+
+RuboCop::Cop::Rails::ActionFilter::ACTION_METHODS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::ActionFilter::FILTER_METHODS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::ActionFilter::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::ActiveRecordAliases < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def on_csend(node); end
+  def on_send(node); end
+end
+
+RuboCop::Cop::Rails::ActiveRecordAliases::ALIASES = T.let(T.unsafe(nil), Hash)
+
+RuboCop::Cop::Rails::ActiveRecordAliases::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::ActiveRecordCallbacksOrder < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def on_class(class_node); end
+
+  private
+
+  def begin_pos_with_comment(node); end
+  def buffer; end
+  def callback?(node); end
+  def defined_callbacks(class_node); end
+  def end_position_for(node); end
+  def left_siblings_of(node); end
+  def siblings_of(node); end
+  def source_range_with_comment(node); end
+  def start_line_position(node); end
+end
+
+RuboCop::Cop::Rails::ActiveRecordCallbacksOrder::CALLBACKS_IN_ORDER = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::ActiveRecordCallbacksOrder::CALLBACKS_ORDER_MAP = T.let(T.unsafe(nil), Hash)
+
+RuboCop::Cop::Rails::ActiveRecordCallbacksOrder::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::ActiveRecordOverride < ::RuboCop::Cop::Cop
+  def on_def(node); end
+
+  private
+
+  def active_model?(parent_class_name); end
+  def callback_names(method_name); end
+  def find_parent_class_name(node); end
+  def message(method_name); end
+end
+
+RuboCop::Cop::Rails::ActiveRecordOverride::ACTIVE_RECORD_CLASSES = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::ActiveRecordOverride::BAD_METHODS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::ActiveRecordOverride::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::ActiveSupportAliases < ::RuboCop::Cop::Cop
+  def append(param0 = T.unsafe(nil)); end
+  def autocorrect(node); end
+  def ends_with?(param0 = T.unsafe(nil)); end
+  def on_send(node); end
+  def prepend(param0 = T.unsafe(nil)); end
+  def starts_with?(param0 = T.unsafe(nil)); end
+
+  private
+
+  def register_offense(node, method_name); end
+end
+
+RuboCop::Cop::Rails::ActiveSupportAliases::ALIASES = T.let(T.unsafe(nil), Hash)
+
+RuboCop::Cop::Rails::ActiveSupportAliases::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::AfterCommitOverride < ::RuboCop::Cop::Cop
+  def on_class(class_node); end
+
+  private
+
+  def after_commit_callback?(node); end
+  def class_send_nodes(class_node); end
+  def each_after_commit_callback(class_node); end
+  def named_callback?(node); end
+end
+
+RuboCop::Cop::Rails::AfterCommitOverride::AFTER_COMMIT_CALLBACKS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::AfterCommitOverride::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::ApplicationController < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::EnforceSuperclass)
+
+  def autocorrect(node); end
+  def class_definition(param0 = T.unsafe(nil)); end
+  def class_new_definition(param0 = T.unsafe(nil)); end
+end
+
+RuboCop::Cop::Rails::ApplicationController::BASE_PATTERN = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::ApplicationController::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::ApplicationController::SUPERCLASS = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::ApplicationJob < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::EnforceSuperclass)
+  extend(::RuboCop::Cop::TargetRailsVersion)
+
+  def autocorrect(node); end
+  def class_definition(param0 = T.unsafe(nil)); end
+  def class_new_definition(param0 = T.unsafe(nil)); end
+end
+
+RuboCop::Cop::Rails::ApplicationJob::BASE_PATTERN = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::ApplicationJob::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::ApplicationJob::SUPERCLASS = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::ApplicationMailer < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::EnforceSuperclass)
+  extend(::RuboCop::Cop::TargetRailsVersion)
+
+  def autocorrect(node); end
+  def class_definition(param0 = T.unsafe(nil)); end
+  def class_new_definition(param0 = T.unsafe(nil)); end
+end
+
+RuboCop::Cop::Rails::ApplicationMailer::BASE_PATTERN = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::ApplicationMailer::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::ApplicationMailer::SUPERCLASS = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::ApplicationRecord < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::EnforceSuperclass)
+  extend(::RuboCop::Cop::TargetRailsVersion)
+
+  def autocorrect(node); end
+  def class_definition(param0 = T.unsafe(nil)); end
+  def class_new_definition(param0 = T.unsafe(nil)); end
+end
+
+RuboCop::Cop::Rails::ApplicationRecord::BASE_PATTERN = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::ApplicationRecord::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::ApplicationRecord::SUPERCLASS = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::AssertNot < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def offensive?(param0 = T.unsafe(nil)); end
+  def on_send(node); end
+
+  private
+
+  def corrected_source(source); end
+end
+
+RuboCop::Cop::Rails::AssertNot::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::BelongsTo < ::RuboCop::Cop::Cop
+  extend(::RuboCop::Cop::TargetRailsVersion)
+
+  def autocorrect(node); end
+  def match_belongs_to_with_options(param0 = T.unsafe(nil)); end
+  def on_send(node); end
+end
+
+RuboCop::Cop::Rails::BelongsTo::SUPERFLOUS_REQUIRE_FALSE_MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::BelongsTo::SUPERFLOUS_REQUIRE_TRUE_MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::Blank < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def defining_blank?(param0 = T.unsafe(nil)); end
+  def nil_or_empty?(param0 = T.unsafe(nil)); end
+  def not_present?(param0 = T.unsafe(nil)); end
+  def on_if(node); end
+  def on_or(node); end
+  def on_send(node); end
+  def unless_present?(param0 = T.unsafe(nil)); end
+
+  private
+
+  def replacement(node); end
+  def unless_condition(node, method_call); end
+end
+
+RuboCop::Cop::Rails::Blank::MSG_NIL_OR_EMPTY = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::Blank::MSG_NOT_PRESENT = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::Blank::MSG_UNLESS_PRESENT = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::BulkChangeTable < ::RuboCop::Cop::Cop
+  def on_def(node); end
+  def on_send(node); end
+
+  private
+
+  def add_offense_for_alter_methods(node); end
+  def add_offense_for_change_table(node); end
+  def call_to_combinable_alter_method?(child_node); end
+  def combinable_alter_methods; end
+  def combinable_transformations; end
+  def database; end
+  def database_from_yaml; end
+  def database_yaml; end
+  def include_bulk_options?(node); end
+  def support_bulk_alter?; end
+end
+
+class RuboCop::Cop::Rails::BulkChangeTable::AlterMethodsRecorder
+  def initialize; end
+
+  def flush; end
+  def offensive_nodes; end
+  def process(new_node); end
+end
+
+RuboCop::Cop::Rails::BulkChangeTable::COMBINABLE_ALTER_METHODS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::BulkChangeTable::COMBINABLE_TRANSFORMATIONS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::BulkChangeTable::MIGRATION_METHODS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::BulkChangeTable::MSG_FOR_ALTER_METHODS = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::BulkChangeTable::MSG_FOR_CHANGE_TABLE = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::BulkChangeTable::MYSQL = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::BulkChangeTable::MYSQL_COMBINABLE_ALTER_METHODS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::BulkChangeTable::MYSQL_COMBINABLE_TRANSFORMATIONS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::BulkChangeTable::POSTGRESQL = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::BulkChangeTable::POSTGRESQL_COMBINABLE_ALTER_METHODS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::BulkChangeTable::POSTGRESQL_COMBINABLE_TRANSFORMATIONS = T.let(T.unsafe(nil), Array)
+
+class RuboCop::Cop::Rails::ContentTag < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::RangeHelp)
+  extend(::RuboCop::Cop::TargetRailsVersion)
+
+  def autocorrect(node); end
+  def on_send(node); end
+
+  private
+
+  def correction_range(node); end
+  def method_name?(node); end
+end
+
+RuboCop::Cop::Rails::ContentTag::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::CreateTableWithTimestamps < ::RuboCop::Cop::Cop
+  def create_table_with_block?(param0 = T.unsafe(nil)); end
+  def create_table_with_timestamps_proc?(param0 = T.unsafe(nil)); end
+  def created_at_or_updated_at_included?(param0); end
+  def on_send(node); end
+  def timestamps_included?(param0); end
+
+  private
+
+  def time_columns_included?(node); end
+end
+
+RuboCop::Cop::Rails::CreateTableWithTimestamps::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::Date < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::ConfigurableEnforcedStyle)
+
+  def on_const(node); end
+  def on_csend(node); end
+  def on_send(node); end
+
+  private
+
+  def bad_days; end
+  def bad_methods; end
+  def check_date_node(node); end
+  def check_deprecated_methods(node); end
+  def extract_method_chain(node); end
+  def good_days; end
+  def good_methods; end
+  def method_send?(node); end
+  def safe_chain?(node); end
+  def safe_to_time?(node); end
+end
+
+RuboCop::Cop::Rails::Date::BAD_DAYS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::Date::DEPRECATED_METHODS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::Date::DEPRECATED_MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::Date::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::Date::MSG_SEND = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::DefaultScope < ::RuboCop::Cop::Cop
+  def class_method_definition?(param0 = T.unsafe(nil)); end
+  def eigenclass_method_definition?(param0 = T.unsafe(nil)); end
+  def method_call?(param0 = T.unsafe(nil)); end
+  def on_defs(node); end
+  def on_sclass(node); end
+  def on_send(node); end
+end
+
+RuboCop::Cop::Rails::DefaultScope::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::Delegate < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def delegate?(param0 = T.unsafe(nil)); end
+  def on_def(node); end
+
+  private
+
+  def arguments_match?(arg_array, body); end
+  def include_prefix_case?; end
+  def method_name_matches?(method_name, body); end
+  def prefixed_method_name(body); end
+  def private_or_protected_before(line); end
+  def private_or_protected_delegation(node); end
+  def private_or_protected_inline(line); end
+  def trivial_delegate?(def_node); end
+end
+
+RuboCop::Cop::Rails::Delegate::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::DelegateAllowBlank < ::RuboCop::Cop::Cop
+  def allow_blank_option(param0 = T.unsafe(nil)); end
+  def autocorrect(pair_node); end
+  def on_send(node); end
+end
+
+RuboCop::Cop::Rails::DelegateAllowBlank::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::DynamicFindBy < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def on_csend(node); end
+  def on_send(node); end
+
+  private
+
+  def allowed_invocation?(node); end
+  def allowed_method?(node); end
+  def allowed_receiver?(node); end
+  def autocorrect_argument_keywords(corrector, node, keywords); end
+  def autocorrect_method_name(corrector, node); end
+  def column_keywords(method); end
+  def static_method_name(method_name); end
+  def whitelisted?(node); end
+end
+
+RuboCop::Cop::Rails::DynamicFindBy::METHOD_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+RuboCop::Cop::Rails::DynamicFindBy::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::EnumHash < ::RuboCop::Cop::Cop
+  def array_pair?(param0 = T.unsafe(nil)); end
+  def autocorrect(node); end
+  def enum?(param0 = T.unsafe(nil)); end
+  def on_send(node); end
+
+  private
+
+  def enum_name(key); end
+  def source(elem); end
+end
+
+RuboCop::Cop::Rails::EnumHash::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::EnumUniqueness < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::Duplication)
+
+  def enum?(param0 = T.unsafe(nil)); end
+  def enum_values(param0 = T.unsafe(nil)); end
+  def on_send(node); end
+
+  private
+
+  def enum_name(key); end
+end
+
+RuboCop::Cop::Rails::EnumUniqueness::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::EnvironmentComparison < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def comparing_str_env_with_rails_env_on_lhs?(param0 = T.unsafe(nil)); end
+  def comparing_str_env_with_rails_env_on_rhs?(param0 = T.unsafe(nil)); end
+  def comparing_sym_env_with_rails_env_on_lhs?(param0 = T.unsafe(nil)); end
+  def comparing_sym_env_with_rails_env_on_rhs?(param0 = T.unsafe(nil)); end
+  def content(param0 = T.unsafe(nil)); end
+  def on_send(node); end
+
+  private
+
+  def build_predicate_method(node); end
+  def build_predicate_method_for_rails_env_on_lhs(node); end
+  def build_predicate_method_for_rails_env_on_rhs(node); end
+  def rails_env_on_lhs?(node); end
+end
+
+RuboCop::Cop::Rails::EnvironmentComparison::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::EnvironmentComparison::SYM_MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::Exit < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::ConfigurableEnforcedStyle)
+
+  def on_send(node); end
+
+  private
+
+  def offending_node?(node); end
+  def right_argument_count?(arg_nodes); end
+  def right_method_name?(method_name); end
+  def right_receiver?(receiver_node); end
+end
+
+RuboCop::Cop::Rails::Exit::EXPLICIT_RECEIVERS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::Exit::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::Exit::TARGET_METHODS = T.let(T.unsafe(nil), Array)
+
+class RuboCop::Cop::Rails::FilePath < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::ConfigurableEnforcedStyle)
+  include(::RuboCop::Cop::RangeHelp)
+
+  def file_join_nodes?(param0 = T.unsafe(nil)); end
+  def on_dstr(node); end
+  def on_send(node); end
+  def rails_root_join_nodes?(param0 = T.unsafe(nil)); end
+  def rails_root_nodes?(param0); end
+
+  private
+
+  def check_for_file_join_with_rails_root(node); end
+  def check_for_rails_root_join_with_slash_separated_path(node); end
+  def check_for_rails_root_join_with_string_arguments(node); end
+  def message(_node); end
+  def register_offense(node); end
+  def string_with_slash?(node); end
+end
+
+RuboCop::Cop::Rails::FilePath::MSG_ARGUMENTS = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::FilePath::MSG_SLASHES = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::FindBy < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::RangeHelp)
+
+  def autocorrect(node); end
+  def on_csend(node); end
+  def on_send(node); end
+  def where_first?(param0 = T.unsafe(nil)); end
+end
+
+RuboCop::Cop::Rails::FindBy::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::FindBy::TARGET_SELECTORS = T.let(T.unsafe(nil), Array)
+
+class RuboCop::Cop::Rails::FindById < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::RangeHelp)
+
+  def autocorrect(node); end
+  def find_by?(param0 = T.unsafe(nil)); end
+  def on_send(node); end
+  def where_take?(param0 = T.unsafe(nil)); end
+
+  private
+
+  def build_find_by_bad_method(node, id_value); end
+  def build_good_method(id_value); end
+  def build_where_take_bad_method(id_value); end
+  def find_by_offense_range(node); end
+  def where_take_offense_range(node, where); end
+end
+
+RuboCop::Cop::Rails::FindById::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::FindEach < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def on_send(node); end
+
+  private
+
+  def ignored_by_find_each?(relation_method); end
+  def method_chain(node); end
+end
+
+RuboCop::Cop::Rails::FindEach::IGNORED_METHODS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::FindEach::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::FindEach::SCOPE_METHODS = T.let(T.unsafe(nil), Array)
+
+class RuboCop::Cop::Rails::HasAndBelongsToMany < ::RuboCop::Cop::Cop
+  def on_send(node); end
+end
+
+RuboCop::Cop::Rails::HasAndBelongsToMany::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::HasManyOrHasOneDependent < ::RuboCop::Cop::Cop
+  def active_resource_class?(param0); end
+  def association_with_options?(param0 = T.unsafe(nil)); end
+  def association_without_options?(param0 = T.unsafe(nil)); end
+  def dependent_option?(param0 = T.unsafe(nil)); end
+  def on_send(node); end
+  def present_option?(param0 = T.unsafe(nil)); end
+  def with_options_block(param0 = T.unsafe(nil)); end
+
+  private
+
+  def active_resource?(node); end
+  def contain_valid_options_in_with_options_block?(node); end
+  def valid_options?(options); end
+  def valid_options_in_with_options_block?(node); end
+end
+
+RuboCop::Cop::Rails::HasManyOrHasOneDependent::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::HelperInstanceVariable < ::RuboCop::Cop::Cop
+  def on_ivar(node); end
+  def on_ivasgn(node); end
+end
+
+RuboCop::Cop::Rails::HelperInstanceVariable::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::HttpPositionalArguments < ::RuboCop::Cop::Cop
+  extend(::RuboCop::Cop::TargetRailsVersion)
+
+  def autocorrect(node); end
+  def http_request?(param0 = T.unsafe(nil)); end
+  def kwsplat_hash?(param0 = T.unsafe(nil)); end
+  def on_send(node); end
+
+  private
+
+  def convert_hash_data(data, type); end
+  def correction(node); end
+  def correction_template(node); end
+  def format_arg?(node); end
+  def needs_conversion?(data); end
+  def special_keyword_arg?(node); end
+end
+
+RuboCop::Cop::Rails::HttpPositionalArguments::HTTP_METHODS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::HttpPositionalArguments::KEYWORD_ARGS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::HttpPositionalArguments::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::HttpStatus < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::ConfigurableEnforcedStyle)
+
+  def autocorrect(node); end
+  def http_status(param0 = T.unsafe(nil)); end
+  def on_send(node); end
+  def status_code(param0 = T.unsafe(nil)); end
+
+  private
+
+  def checker_class; end
+end
+
+class RuboCop::Cop::Rails::HttpStatus::NumericStyleChecker
+  def initialize(node); end
+
+  def message; end
+  def node; end
+  def offensive?; end
+  def preferred_style; end
+
+  private
+
+  def number; end
+  def permitted_symbol?; end
+  def symbol; end
+end
+
+RuboCop::Cop::Rails::HttpStatus::NumericStyleChecker::DEFAULT_MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::HttpStatus::NumericStyleChecker::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::HttpStatus::NumericStyleChecker::PERMITTED_STATUS = T.let(T.unsafe(nil), Array)
+
+class RuboCop::Cop::Rails::HttpStatus::SymbolicStyleChecker
+  def initialize(node); end
+
+  def message; end
+  def node; end
+  def offensive?; end
+  def preferred_style; end
+
+  private
+
+  def custom_http_status_code?; end
+  def number; end
+  def symbol; end
+end
+
+RuboCop::Cop::Rails::HttpStatus::SymbolicStyleChecker::DEFAULT_MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::HttpStatus::SymbolicStyleChecker::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::IgnoredSkipActionFilterOption < ::RuboCop::Cop::Cop
+  def filter_options(param0 = T.unsafe(nil)); end
+  def on_send(node); end
+
+  private
+
+  def if_and_except?(options); end
+  def if_and_only?(options); end
+  def options_hash(options); end
+end
+
+RuboCop::Cop::Rails::IgnoredSkipActionFilterOption::FILTERS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::IgnoredSkipActionFilterOption::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::IndexBy < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::IndexMethod)
+
+  def on_bad_each_with_object(param0 = T.unsafe(nil)); end
+  def on_bad_hash_brackets_map(param0 = T.unsafe(nil)); end
+  def on_bad_map_to_h(param0 = T.unsafe(nil)); end
+  def on_bad_to_h(param0 = T.unsafe(nil)); end
+
+  private
+
+  def new_method_name; end
+end
+
+class RuboCop::Cop::Rails::IndexWith < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::IndexMethod)
+  extend(::RuboCop::Cop::TargetRailsVersion)
+
+  def on_bad_each_with_object(param0 = T.unsafe(nil)); end
+  def on_bad_hash_brackets_map(param0 = T.unsafe(nil)); end
+  def on_bad_map_to_h(param0 = T.unsafe(nil)); end
+  def on_bad_to_h(param0 = T.unsafe(nil)); end
+
+  private
+
+  def new_method_name; end
+end
+
+class RuboCop::Cop::Rails::Inquiry < ::RuboCop::Cop::Cop
+  def on_send(node); end
+end
+
+RuboCop::Cop::Rails::Inquiry::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::InverseOf < ::RuboCop::Cop::Cop
+  def as_option?(param0 = T.unsafe(nil)); end
+  def association_recv_arguments(param0 = T.unsafe(nil)); end
+  def conditions_option?(param0 = T.unsafe(nil)); end
+  def foreign_key_option?(param0 = T.unsafe(nil)); end
+  def inverse_of_nil_option?(param0 = T.unsafe(nil)); end
+  def inverse_of_option?(param0 = T.unsafe(nil)); end
+  def on_send(node); end
+  def options_contain_inverse_of?(options); end
+  def options_from_argument(param0 = T.unsafe(nil)); end
+  def options_ignoring_inverse_of?(options); end
+  def options_requiring_inverse_of?(options); end
+  def polymorphic_option?(param0 = T.unsafe(nil)); end
+  def same_context_in_with_options?(arg, recv); end
+  def scope?(arguments); end
+  def through_option?(param0 = T.unsafe(nil)); end
+  def with_options_arguments(recv, node); end
+
+  private
+
+  def message(options); end
+end
+
+RuboCop::Cop::Rails::InverseOf::NIL_MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::InverseOf::SPECIFY_MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::LexicallyScopedActionFilter < ::RuboCop::Cop::Cop
+  def on_send(node); end
+  def only_or_except_filter_methods(param0 = T.unsafe(nil)); end
+
+  private
+
+  def array_values(node); end
+  def message(methods, parent); end
+end
+
+RuboCop::Cop::Rails::LexicallyScopedActionFilter::FILTERS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::LexicallyScopedActionFilter::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::LinkToBlank < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def blank_target?(param0 = T.unsafe(nil)); end
+  def includes_noopener?(param0 = T.unsafe(nil)); end
+  def on_send(node); end
+  def rel_node?(param0 = T.unsafe(nil)); end
+
+  private
+
+  def add_rel(send_node, offence_node, corrector); end
+  def append_to_rel(rel_node, corrector); end
+  def contains_noopener?(value); end
+end
+
+RuboCop::Cop::Rails::LinkToBlank::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::MailerName < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def class_definition?(param0 = T.unsafe(nil)); end
+  def class_new_definition?(param0 = T.unsafe(nil)); end
+  def mailer_base_class?(param0 = T.unsafe(nil)); end
+  def on_class(node); end
+  def on_send(node); end
+
+  private
+
+  def mailer_suffix?(mailer_name); end
+end
+
+RuboCop::Cop::Rails::MailerName::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::MatchRoute < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def match_method_call?(param0 = T.unsafe(nil)); end
+  def on_send(node); end
+  def routes_draw?(param0 = T.unsafe(nil)); end
+
+  private
+
+  def extract_via(node); end
+  def http_method?(method); end
+  def http_method_and_options(node); end
+  def replacement(path_node, options_node); end
+  def via_pair(node); end
+  def within_routes?(node); end
+end
+
+RuboCop::Cop::Rails::MatchRoute::HTTP_METHODS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::MatchRoute::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::NegateInclude < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def negate_include_call?(param0 = T.unsafe(nil)); end
+  def on_send(node); end
+end
+
+RuboCop::Cop::Rails::NegateInclude::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::NotNullColumn < ::RuboCop::Cop::Cop
+  def add_not_null_column?(param0 = T.unsafe(nil)); end
+  def add_not_null_reference?(param0 = T.unsafe(nil)); end
+  def default_option?(param0 = T.unsafe(nil)); end
+  def null_false?(param0 = T.unsafe(nil)); end
+  def on_send(node); end
+
+  private
+
+  def check_add_column(node); end
+  def check_add_reference(node); end
+  def check_pairs(pairs); end
+end
+
+RuboCop::Cop::Rails::NotNullColumn::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::OrderById < ::RuboCop::Cop::Base
+  include(::RuboCop::Cop::RangeHelp)
+
+  def on_send(node); end
+  def order_by_id?(param0 = T.unsafe(nil)); end
+
+  private
+
+  def offense_range(node); end
+end
+
+RuboCop::Cop::Rails::OrderById::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::Output < ::RuboCop::Cop::Cop
+  def io_output?(param0 = T.unsafe(nil)); end
+  def on_send(node); end
+  def output?(param0 = T.unsafe(nil)); end
+
+  private
+
+  def match_gvar?(sym); end
+end
+
+RuboCop::Cop::Rails::Output::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::OutputSafety < ::RuboCop::Cop::Cop
+  def on_csend(node); end
+  def on_send(node); end
+
+  private
+
+  def looks_like_rails_html_safe?(node); end
+  def looks_like_rails_raw?(node); end
+  def looks_like_rails_safe_concat?(node); end
+  def non_interpolated_string?(node); end
+end
+
+RuboCop::Cop::Rails::OutputSafety::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::Pick < ::RuboCop::Cop::Cop
+  extend(::RuboCop::Cop::TargetRailsVersion)
+
+  def autocorrect(node); end
+  def on_send(node); end
+  def pick_candidate?(param0 = T.unsafe(nil)); end
+
+  private
+
+  def message(node); end
+end
+
+RuboCop::Cop::Rails::Pick::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::Pluck < ::RuboCop::Cop::Cop
+  extend(::RuboCop::Cop::TargetRailsVersion)
+
+  def autocorrect(node); end
+  def on_block(node); end
+  def pluck_candidate?(param0 = T.unsafe(nil)); end
+
+  private
+
+  def message(method, argument, element, value); end
+  def offense_range(node); end
+end
+
+RuboCop::Cop::Rails::Pluck::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::PluckId < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::RangeHelp)
+  include(::RuboCop::Cop::ActiveRecordHelper)
+
+  def autocorrect(node); end
+  def on_send(node); end
+  def pluck_id_call?(param0 = T.unsafe(nil)); end
+
+  private
+
+  def offense_range(node); end
+end
+
+RuboCop::Cop::Rails::PluckId::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::PluckInWhere < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::ActiveRecordHelper)
+  include(::RuboCop::Cop::ConfigurableEnforcedStyle)
+
+  def autocorrect(node); end
+  def on_send(node); end
+
+  private
+
+  def root_receiver(node); end
+end
+
+RuboCop::Cop::Rails::PluckInWhere::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::PluralizationGrammar < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def on_send(node); end
+
+  private
+
+  def correct_method(method_name); end
+  def duration_method?(method_name); end
+  def literal_number?(node); end
+  def message(node); end
+  def offense?(node); end
+  def plural_method?(method_name); end
+  def plural_receiver?(number); end
+  def pluralize(method_name); end
+  def singular_method?(method_name); end
+  def singular_receiver?(number); end
+  def singularize(method_name); end
+end
+
+RuboCop::Cop::Rails::PluralizationGrammar::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::PluralizationGrammar::PLURAL_DURATION_METHODS = T.let(T.unsafe(nil), Hash)
+
+RuboCop::Cop::Rails::PluralizationGrammar::SINGULAR_DURATION_METHODS = T.let(T.unsafe(nil), Hash)
+
+class RuboCop::Cop::Rails::Presence < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::RangeHelp)
+
+  def autocorrect(node); end
+  def on_if(node); end
+  def redundant_negative_receiver_and_other(param0 = T.unsafe(nil)); end
+  def redundant_receiver_and_other(param0 = T.unsafe(nil)); end
+
+  private
+
+  def build_source_for_or_method(other); end
+  def ignore_if_node?(node); end
+  def ignore_other_node?(node); end
+  def message(node, receiver, other); end
+  def replacement(receiver, other); end
+end
+
+RuboCop::Cop::Rails::Presence::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::Present < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def exists_and_not_empty?(param0 = T.unsafe(nil)); end
+  def not_blank?(param0 = T.unsafe(nil)); end
+  def on_and(node); end
+  def on_if(node); end
+  def on_or(node); end
+  def on_send(node); end
+  def unless_blank?(param0 = T.unsafe(nil)); end
+
+  private
+
+  def replacement(node); end
+  def unless_condition(node, method_call); end
+end
+
+RuboCop::Cop::Rails::Present::MSG_EXISTS_AND_NOT_EMPTY = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::Present::MSG_NOT_BLANK = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::Present::MSG_UNLESS_BLANK = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::RakeEnvironment < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def on_block(node); end
+  def task_definition?(param0 = T.unsafe(nil)); end
+
+  private
+
+  def correct_task_dependency(task_name); end
+  def task_name(node); end
+  def with_dependencies?(node); end
+  def with_hash_style_dependencies?(hash_node); end
+end
+
+RuboCop::Cop::Rails::RakeEnvironment::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::ReadWriteAttribute < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def on_send(node); end
+  def read_write_attribute?(param0 = T.unsafe(nil)); end
+
+  private
+
+  def message(node); end
+  def read_attribute_replacement(node); end
+  def write_attribute_replacement(node); end
+end
+
+RuboCop::Cop::Rails::ReadWriteAttribute::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::RedundantAllowNil < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::RangeHelp)
+
+  def autocorrect(node); end
+  def on_send(node); end
+
+  private
+
+  def find_allow_nil_and_allow_blank(node); end
+  def next_sibling(node); end
+  def node_beg(node); end
+  def node_end(node); end
+  def offense(allow_nil_val, allow_blank_val, allow_nil); end
+  def previous_sibling(node); end
+end
+
+RuboCop::Cop::Rails::RedundantAllowNil::MSG_ALLOW_NIL_FALSE = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::RedundantAllowNil::MSG_SAME = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::RedundantForeignKey < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::RangeHelp)
+
+  def association_with_foreign_key(param0 = T.unsafe(nil)); end
+  def autocorrect(node); end
+  def on_send(node); end
+
+  private
+
+  def default_foreign_key(node, association_type, association_name, options); end
+  def find_as_option(options); end
+  def redundant?(node, association_type, association_name, options, foreign_key); end
+end
+
+RuboCop::Cop::Rails::RedundantForeignKey::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::RedundantReceiverInWithOptions < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::RangeHelp)
+
+  def all_block_nodes_in(param0); end
+  def all_send_nodes_in(param0); end
+  def autocorrect(node); end
+  def on_block(node); end
+  def with_options?(param0 = T.unsafe(nil)); end
+
+  private
+
+  def block_argument_range(node); end
+  def same_value?(arg_node, recv_node); end
+  def search_begin_pos_of_space_before_block_argument(begin_pos); end
+end
+
+RuboCop::Cop::Rails::RedundantReceiverInWithOptions::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::ReflectionClassName < ::RuboCop::Cop::Cop
+  def association_with_reflection(param0 = T.unsafe(nil)); end
+  def on_send(node); end
+  def reflection_class_name(param0 = T.unsafe(nil)); end
+end
+
+RuboCop::Cop::Rails::ReflectionClassName::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::RefuteMethods < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::ConfigurableEnforcedStyle)
+
+  def autocorrect(node); end
+  def offensive?(param0 = T.unsafe(nil)); end
+  def on_send(node); end
+
+  private
+
+  def bad_method?(method_name); end
+  def convert_good_method(bad_method); end
+  def offense_message(method_name); end
+end
+
+RuboCop::Cop::Rails::RefuteMethods::ASSERT_NOT_METHODS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::RefuteMethods::CORRECTIONS = T.let(T.unsafe(nil), Hash)
+
+RuboCop::Cop::Rails::RefuteMethods::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::RefuteMethods::REFUTE_METHODS = T.let(T.unsafe(nil), Array)
+
+class RuboCop::Cop::Rails::RelativeDateConstant < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::RangeHelp)
+
+  def autocorrect(node); end
+  def on_casgn(node); end
+  def on_masgn(node); end
+  def on_or_asgn(node); end
+  def relative_date?(param0 = T.unsafe(nil)); end
+  def relative_date_assignment?(param0 = T.unsafe(nil)); end
+  def relative_date_or_assignment?(param0 = T.unsafe(nil)); end
+
+  private
+
+  def offense_range(name, value); end
+end
+
+RuboCop::Cop::Rails::RelativeDateConstant::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::RenderInline < ::RuboCop::Cop::Cop
+  def on_send(node); end
+  def render_with_inline_option?(param0 = T.unsafe(nil)); end
+end
+
+RuboCop::Cop::Rails::RenderInline::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::RenderPlainText < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def on_send(node); end
+  def render_plain_text?(param0 = T.unsafe(nil)); end
+
+  private
+
+  def compatible_content_type?(node); end
+  def find_content_type(node); end
+  def replacement(rest_options, option_value); end
+end
+
+RuboCop::Cop::Rails::RenderPlainText::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::RequestReferer < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::ConfigurableEnforcedStyle)
+
+  def autocorrect(node); end
+  def on_send(node); end
+  def referer?(param0 = T.unsafe(nil)); end
+
+  private
+
+  def message(_node); end
+  def wrong_method_name; end
+end
+
+RuboCop::Cop::Rails::RequestReferer::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::ReversibleMigration < ::RuboCop::Cop::Cop
+  def change_table_call(param0 = T.unsafe(nil)); end
+  def drop_table_call(param0 = T.unsafe(nil)); end
+  def irreversible_schema_statement_call(param0 = T.unsafe(nil)); end
+  def on_block(node); end
+  def on_send(node); end
+  def remove_column_call(param0 = T.unsafe(nil)); end
+  def remove_columns_call(param0 = T.unsafe(nil)); end
+  def remove_foreign_key_call(param0 = T.unsafe(nil)); end
+  def remove_index_call(param0 = T.unsafe(nil)); end
+
+  private
+
+  def all_hash_key?(args, *keys); end
+  def check_change_table_node(node, block); end
+  def check_change_table_offense(receiver, node); end
+  def check_drop_table_node(node); end
+  def check_irreversible_schema_statement_node(node); end
+  def check_remove_column_node(node); end
+  def check_remove_columns_node(node); end
+  def check_remove_foreign_key_node(node); end
+  def check_remove_index_node(node); end
+  def check_reversible_hash_node(node); end
+  def reversible_change_table_call?(node); end
+  def within_change_method?(node); end
+  def within_reversible_or_up_only_block?(node); end
+end
+
+RuboCop::Cop::Rails::ReversibleMigration::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::SafeNavigation < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::RangeHelp)
+
+  def autocorrect(node); end
+  def on_send(node); end
+  def try_call(param0 = T.unsafe(nil)); end
+
+  private
+
+  def replacement(method, params); end
+end
+
+RuboCop::Cop::Rails::SafeNavigation::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::SafeNavigationWithBlank < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def on_if(node); end
+  def safe_navigation_blank_in_conditional?(param0 = T.unsafe(nil)); end
+end
+
+RuboCop::Cop::Rails::SafeNavigationWithBlank::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::SaveBang < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::NegativeConditional)
+
+  def after_leaving_scope(scope, _variable_table); end
+  def autocorrect(node); end
+  def check_assignment(assignment); end
+  def join_force?(force_class); end
+  def on_csend(node); end
+  def on_send(node); end
+
+  private
+
+  def add_offense_for_node(node, msg = T.unsafe(nil)); end
+  def allowed_receiver?(node); end
+  def argument?(node); end
+  def array_parent(node); end
+  def assignable_node(node); end
+  def call_to_persisted?(node); end
+  def check_used_in_condition_or_compound_boolean(node); end
+  def checked_immediately?(node); end
+  def conditional?(parent); end
+  def const_matches?(const, allowed_const); end
+  def expected_signature?(node); end
+  def explicit_return?(node); end
+  def find_method_with_sibling_index(node, sibling_index = T.unsafe(nil)); end
+  def hash_parent(node); end
+  def implicit_return?(node); end
+  def in_condition_or_compound_boolean?(node); end
+  def operator_or_single_negative?(node); end
+  def persist_method?(node, methods = T.unsafe(nil)); end
+  def persisted_referenced?(assignment); end
+  def receiver_chain_matches?(node, allowed_receiver); end
+  def return_value_assigned?(node); end
+  def right_assignment_node(assignment); end
+end
+
+RuboCop::Cop::Rails::SaveBang::CREATE_CONDITIONAL_MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::SaveBang::CREATE_MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::SaveBang::CREATE_PERSIST_METHODS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::SaveBang::MODIFY_PERSIST_METHODS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::SaveBang::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::SaveBang::PERSIST_METHODS = T.let(T.unsafe(nil), Array)
+
+class RuboCop::Cop::Rails::ScopeArgs < ::RuboCop::Cop::Cop
+  def on_send(node); end
+  def scope?(param0 = T.unsafe(nil)); end
+end
+
+RuboCop::Cop::Rails::ScopeArgs::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::ShortI18n < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::ConfigurableEnforcedStyle)
+
+  def autocorrect(node); end
+  def long_i18n?(param0 = T.unsafe(nil)); end
+  def on_send(node); end
+end
+
+RuboCop::Cop::Rails::ShortI18n::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::ShortI18n::PREFERRED_METHODS = T.let(T.unsafe(nil), Hash)
+
+class RuboCop::Cop::Rails::SkipsModelValidations < ::RuboCop::Cop::Cop
+  def initialize(*_arg0); end
+
+  def good_insert?(param0 = T.unsafe(nil)); end
+  def good_touch?(param0 = T.unsafe(nil)); end
+  def on_csend(node); end
+  def on_send(node); end
+
+  private
+
+  def allowed_method?(node); end
+  def allowed_methods; end
+  def forbidden_methods; end
+  def message(node); end
+end
+
+RuboCop::Cop::Rails::SkipsModelValidations::METHODS_WITH_ARGUMENTS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::SkipsModelValidations::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::SquishedSQLHeredocs < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::Heredoc)
+
+  def autocorrect(node); end
+  def on_heredoc(node); end
+
+  private
+
+  def message(node); end
+  def offense_detected?(node); end
+  def sql_heredoc?(node); end
+  def using_squish?(node); end
+end
+
+RuboCop::Cop::Rails::SquishedSQLHeredocs::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::SquishedSQLHeredocs::SQL = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::SquishedSQLHeredocs::SQUISH = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::TimeZone < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::ConfigurableEnforcedStyle)
+
+  def autocorrect(node); end
+  def on_const(node); end
+
+  private
+
+  def acceptable_methods(klass, method_name, node); end
+  def autocorrect_time_new(node, corrector); end
+  def build_message(klass, method_name, node); end
+  def check_localtime(node); end
+  def check_time_node(klass, node); end
+  def extract_method_chain(node); end
+  def flexible?; end
+  def good_methods; end
+  def method_from_time_class?(node); end
+  def method_send?(node); end
+  def need_check_localtime?(chain); end
+  def not_danger_chain?(chain); end
+  def offset_provided?(node); end
+  def remove_redundant_in_time_zone(corrector, node); end
+  def safe_method(method_name, node); end
+  def strict?; end
+end
+
+RuboCop::Cop::Rails::TimeZone::ACCEPTED_METHODS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::TimeZone::DANGEROUS_METHODS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::TimeZone::GOOD_METHODS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::TimeZone::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::TimeZone::MSG_ACCEPTABLE = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::TimeZone::MSG_LOCALTIME = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::UniqBeforePluck < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::ConfigurableEnforcedStyle)
+  include(::RuboCop::Cop::RangeHelp)
+
+  def aggressive_node_match(param0 = T.unsafe(nil)); end
+  def autocorrect(node); end
+  def conservative_node_match(param0 = T.unsafe(nil)); end
+  def on_send(node); end
+
+  private
+
+  def dot_method_begin_pos(method, node); end
+  def dot_method_with_whitespace(method, node); end
+  def style_parameter_name; end
+end
+
+RuboCop::Cop::Rails::UniqBeforePluck::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::UniqBeforePluck::NEWLINE = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::UniqBeforePluck::PATTERN = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::UniqueValidationWithoutIndex < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::ActiveRecordHelper)
+
+  def on_send(node); end
+
+  private
+
+  def array_node_to_array(node); end
+  def class_node(node); end
+  def column_names(node); end
+  def column_names_from_scope(node); end
+  def condition_part?(node); end
+  def find_schema_information(node); end
+  def find_scope(pairs); end
+  def include_column_names_in_expression_index?(index, column_names); end
+  def unfreeze_scope(scope); end
+  def uniqueness_part(node); end
+  def with_index?(klass, table, names); end
+end
+
+RuboCop::Cop::Rails::UniqueValidationWithoutIndex::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::UnknownEnv < ::RuboCop::Cop::Cop
+  def on_send(node); end
+  def rails_env?(param0 = T.unsafe(nil)); end
+  def unknown_environment_equal?(param0 = T.unsafe(nil)); end
+  def unknown_environment_predicate?(param0 = T.unsafe(nil)); end
+
+  private
+
+  def collect_variable_like_names(_scope); end
+  def environments; end
+  def message(name); end
+  def unknown_env_name?(name); end
+  def unknown_env_predicate?(name); end
+end
+
+RuboCop::Cop::Rails::UnknownEnv::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::UnknownEnv::MSG_SIMILAR = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::Validation < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def on_send(node); end
+
+  private
+
+  def braced_options(options); end
+  def correct_validate_type(corrector, node); end
+  def correct_validate_type_for_array(corrector, node, arguments, loc); end
+  def correct_validate_type_for_hash(corrector, node, arguments); end
+  def frozen_array_argument?(argument); end
+  def message(node); end
+  def preferred_method(method); end
+  def validate_type(node); end
+end
+
+RuboCop::Cop::Rails::Validation::ALLOWLIST = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::Validation::DENYLIST = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Rails::Validation::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::Validation::TYPES = T.let(T.unsafe(nil), Array)
+
+class RuboCop::Cop::Rails::WhereExists < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::ConfigurableEnforcedStyle)
+
+  def autocorrect(node); end
+  def exists_with_args?(param0 = T.unsafe(nil)); end
+  def on_send(node); end
+  def where_exists_call?(param0 = T.unsafe(nil)); end
+
+  private
+
+  def build_good_method(args); end
+  def build_good_method_exists(args); end
+  def build_good_method_where(args); end
+  def convertable_args?(args); end
+  def correction_range(node); end
+  def exists_style?; end
+  def find_offenses(node, &block); end
+  def where_style?; end
+end
+
+RuboCop::Cop::Rails::WhereExists::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Rails::WhereNot < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::RangeHelp)
+
+  def autocorrect(node); end
+  def on_send(node); end
+  def where_method_call?(param0 = T.unsafe(nil)); end
+
+  private
+
+  def build_good_method(column, value); end
+  def extract_column_and_value(template_node, value_node); end
+  def offense_range(node); end
+end
+
+RuboCop::Cop::Rails::WhereNot::IS_NOT_NULL_RE = T.let(T.unsafe(nil), Regexp)
+
+RuboCop::Cop::Rails::WhereNot::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Rails::WhereNot::NOT_EQ_ANONYMOUS_RE = T.let(T.unsafe(nil), Regexp)
+
+RuboCop::Cop::Rails::WhereNot::NOT_EQ_NAMED_RE = T.let(T.unsafe(nil), Regexp)
+
+RuboCop::Cop::Rails::WhereNot::NOT_IN_ANONYMOUS_RE = T.let(T.unsafe(nil), Regexp)
+
+RuboCop::Cop::Rails::WhereNot::NOT_IN_NAMED_RE = T.let(T.unsafe(nil), Regexp)
+
+module RuboCop::Cop::TargetRailsVersion
+  def minimum_target_rails_version(version); end
+  def support_target_rails_version?(version); end
+end
+
+RuboCop::NodePattern = RuboCop::AST::NodePattern
+
+RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource
+
+module RuboCop::Rails
+end
+
+RuboCop::Rails::CONFIG = T.let(T.unsafe(nil), Hash)
+
+module RuboCop::Rails::Inject
+  class << self
+    def defaults!; end
+  end
+end
+
+module RuboCop::Rails::SchemaLoader
+  extend(::RuboCop::Rails::SchemaLoader)
+
+  def db_schema_path; end
+  def load(target_ruby_version); end
+  def reset!; end
+
+  private
+
+  def load!(target_ruby_version); end
+  def parse(path, target_ruby_version); end
+end
+
+class RuboCop::Rails::SchemaLoader::AddIndex < ::RuboCop::Rails::SchemaLoader::Index
+  def initialize(node); end
+
+  def table_name; end
+end
+
+class RuboCop::Rails::SchemaLoader::Column
+  def initialize(node); end
+
+  def name; end
+  def not_null; end
+  def type; end
+
+  private
+
+  def analyze_keywords!(node); end
+end
+
+class RuboCop::Rails::SchemaLoader::Index
+  def initialize(node); end
+
+  def columns; end
+  def expression; end
+  def name; end
+  def unique; end
+
+  private
+
+  def analyze_keywords!(node); end
+  def build_columns_or_expr(columns); end
+end
+
+class RuboCop::Rails::SchemaLoader::Schema
+  def initialize(ast); end
+
+  def add_indicies; end
+  def add_indicies_by(table_name:); end
+  def table_by(name:); end
+  def tables; end
+
+  private
+
+  def build!(ast); end
+  def each_add_index(ast); end
+  def each_table(ast); end
+end
+
+class RuboCop::Rails::SchemaLoader::Table
+  def initialize(node); end
+
+  def columns; end
+  def indices; end
+  def name; end
+  def with_column?(name:); end
+
+  private
+
+  def build_columns(node); end
+  def build_indices(node); end
+  def each_content(node, &block); end
+end
+
+module RuboCop::Rails::Version
+end
+
+RuboCop::Rails::Version::STRING = T.let(T.unsafe(nil), String)
+
+RuboCop::Token = RuboCop::AST::Token
diff --git a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
index 50e1d69f24c0cc09e08a2919d770cb3823a95cfd..decbac3f71c333f12a130d54a12f6250cb13b7a5 100644
--- a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
+++ b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
@@ -245,6 +245,15 @@ module ActiveSupport::Cache
   def self.lookup_store(store=T.unsafe(nil), *parameters); end
 end
 
+class ActiveSupport::CachingKeyGenerator
+  def generate_key(*args); end
+
+  def initialize(key_generator); end
+end
+
+class ActiveSupport::CachingKeyGenerator
+end
+
 module ActiveSupport::Callbacks
   def run_callbacks(kind); end
   CALLBACK_FILTER_TYPES = ::T.let(nil, ::T.untyped)
@@ -1648,6 +1657,21 @@ end
 class ActiveSupport::MessageVerifier
 end
 
+module ActiveSupport::Messages
+end
+
+class ActiveSupport::Messages::Metadata
+  def initialize(message, expires_at=T.unsafe(nil), purpose=T.unsafe(nil)); end
+
+  def verify(purpose); end
+end
+
+class ActiveSupport::Messages::Metadata
+  def self.verify(message, purpose); end
+
+  def self.wrap(message, expires_at: T.unsafe(nil), expires_in: T.unsafe(nil), purpose: T.unsafe(nil)); end
+end
+
 module ActiveSupport::Messages::Rotator
   def initialize(*_, **options); end
 
@@ -1673,6 +1697,9 @@ end
 module ActiveSupport::Messages::Rotator
 end
 
+module ActiveSupport::Messages
+end
+
 module ActiveSupport::Multibyte
 end
 
@@ -2345,6 +2372,15 @@ end
 class ActiveSupport::SafeBuffer
 end
 
+module ActiveSupport::SecurityUtils
+end
+
+module ActiveSupport::SecurityUtils
+  def self.fixed_length_secure_compare(a, b); end
+
+  def self.secure_compare(a, b); end
+end
+
 class ActiveSupport::StringInquirer
 end
 
@@ -2472,6 +2508,7 @@ ActiveSupport::TestCase::Assertion = Minitest::Assertion
 class ActiveSupport::TestCase
   extend ::ActiveSupport::Callbacks::ClassMethods
   extend ::ActiveSupport::DescendantsTracker
+  extend ::ActiveSupport::Testing::Declarative
   def self.__callbacks(); end
 
   def self.__callbacks=(val); end
@@ -2501,6 +2538,9 @@ class ActiveSupport::TestCase
   def self.test_order=(new_order); end
 end
 
+module ActiveSupport::Testing
+end
+
 module ActiveSupport::Testing::Assertions
   def assert_changes(expression, message=T.unsafe(nil), from: T.unsafe(nil), to: T.unsafe(nil), &block); end
 
@@ -2519,6 +2559,27 @@ end
 module ActiveSupport::Testing::Assertions
 end
 
+module ActiveSupport::Testing::ConstantLookup
+end
+
+module ActiveSupport::Testing::ConstantLookup::ClassMethods
+  def determine_constant_from_test_name(test_name); end
+end
+
+module ActiveSupport::Testing::ConstantLookup::ClassMethods
+end
+
+module ActiveSupport::Testing::ConstantLookup
+  extend ::ActiveSupport::Concern
+end
+
+module ActiveSupport::Testing::Declarative
+  def test(name, &block); end
+end
+
+module ActiveSupport::Testing::Declarative
+end
+
 module ActiveSupport::Testing::Deprecation
   def assert_deprecated(match=T.unsafe(nil), deprecator=T.unsafe(nil), &block); end
 
@@ -2538,6 +2599,74 @@ module ActiveSupport::Testing::FileFixtures
   extend ::ActiveSupport::Concern
 end
 
+module ActiveSupport::Testing::Isolation
+  include ::ActiveSupport::Testing::Isolation::Forking
+  def run(); end
+end
+
+module ActiveSupport::Testing::Isolation::Forking
+  def run_in_isolation(&blk); end
+end
+
+module ActiveSupport::Testing::Isolation::Forking
+end
+
+module ActiveSupport::Testing::Isolation::Subprocess
+  def run_in_isolation(&blk); end
+  ORIG_ARGV = ::T.let(nil, ::T.untyped)
+end
+
+module ActiveSupport::Testing::Isolation::Subprocess
+end
+
+module ActiveSupport::Testing::Isolation
+  def self.forking_env?(); end
+
+  def self.included(klass); end
+end
+
+class ActiveSupport::Testing::Parallelization
+  def <<(work); end
+
+  def after_fork(worker); end
+
+  def after_fork_hooks(); end
+
+  def initialize(queue_size); end
+
+  def run_cleanup(worker); end
+
+  def run_cleanup_hooks(); end
+
+  def shutdown(); end
+
+  def start(); end
+end
+
+class ActiveSupport::Testing::Parallelization::Server
+  include ::DRb::DRbUndumped
+  def <<(o); end
+
+  def length(); end
+
+  def pop(); end
+
+  def record(reporter, result); end
+end
+
+class ActiveSupport::Testing::Parallelization::Server
+end
+
+class ActiveSupport::Testing::Parallelization
+  def self.after_fork_hook(&blk); end
+
+  def self.after_fork_hooks(); end
+
+  def self.run_cleanup_hook(&blk); end
+
+  def self.run_cleanup_hooks(); end
+end
+
 module ActiveSupport::Testing::SetupAndTeardown
   def after_teardown(); end
 
@@ -2548,6 +2677,37 @@ module ActiveSupport::Testing::SetupAndTeardown
   def self.prepended(klass); end
 end
 
+class ActiveSupport::Testing::SimpleStubs
+  def stub_object(object, method_name, &block); end
+
+  def stubbing(object, method_name); end
+
+  def unstub_all!(); end
+end
+
+class ActiveSupport::Testing::SimpleStubs::Stub
+  def method_name(); end
+
+  def method_name=(_); end
+
+  def object(); end
+
+  def object=(_); end
+
+  def original_method(); end
+
+  def original_method=(_); end
+end
+
+class ActiveSupport::Testing::SimpleStubs::Stub
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+class ActiveSupport::Testing::SimpleStubs
+end
+
 module ActiveSupport::Testing::TaggedLogging
   def before_setup(); end
 
@@ -2574,6 +2734,9 @@ end
 module ActiveSupport::Testing::TimeHelpers
 end
 
+module ActiveSupport::Testing
+end
+
 class ActiveSupport::TimeWithZone
   include ::DateAndTime::Compatibility
   include ::Comparable
@@ -13076,8 +13239,6 @@ class Net::HTTP::Persistent
   def self.detect_idle_timeout(uri, max=T.unsafe(nil)); end
 end
 
-Net::HTTP::ProxyMod = Net::HTTP::ProxyDelta
-
 class Net::HTTPAlreadyReported
   HAS_BODY = ::T.let(nil, ::T.untyped)
 end
@@ -13098,8 +13259,6 @@ end
 
 Net::HTTPFatalErrorCode = Net::HTTPClientError
 
-Net::HTTPInformation::EXCEPTION_TYPE = Net::HTTPError
-
 Net::HTTPInformationCode = Net::HTTPInformation
 
 class Net::HTTPLoopDetected
@@ -13455,6 +13614,10 @@ class OpenSSL::BN
   def negative?(); end
 end
 
+module OpenSSL::Buffering
+  include ::ActiveSupport::ToJsonWithActiveSupportEncoder
+end
+
 module OpenSSL::KDF
 end
 
@@ -25768,210 +25931,1959 @@ class Racc::Parser
   Racc_YY_Parse_Method = ::T.let(nil, ::T.untyped)
 end
 
-class Random
-  def self.bytes(_); end
+module Rack
+  CACHE_CONTROL = ::T.let(nil, ::T.untyped)
+  CONTENT_LENGTH = ::T.let(nil, ::T.untyped)
+  CONTENT_TYPE = ::T.let(nil, ::T.untyped)
+  DELETE = ::T.let(nil, ::T.untyped)
+  ETAG = ::T.let(nil, ::T.untyped)
+  EXPIRES = ::T.let(nil, ::T.untyped)
+  GET = ::T.let(nil, ::T.untyped)
+  HEAD = ::T.let(nil, ::T.untyped)
+  HTTPS = ::T.let(nil, ::T.untyped)
+  HTTP_COOKIE = ::T.let(nil, ::T.untyped)
+  HTTP_HOST = ::T.let(nil, ::T.untyped)
+  HTTP_PORT = ::T.let(nil, ::T.untyped)
+  HTTP_VERSION = ::T.let(nil, ::T.untyped)
+  LINK = ::T.let(nil, ::T.untyped)
+  OPTIONS = ::T.let(nil, ::T.untyped)
+  PATCH = ::T.let(nil, ::T.untyped)
+  PATH_INFO = ::T.let(nil, ::T.untyped)
+  POST = ::T.let(nil, ::T.untyped)
+  PUT = ::T.let(nil, ::T.untyped)
+  QUERY_STRING = ::T.let(nil, ::T.untyped)
+  RACK_ERRORS = ::T.let(nil, ::T.untyped)
+  RACK_HIJACK = ::T.let(nil, ::T.untyped)
+  RACK_HIJACK_IO = ::T.let(nil, ::T.untyped)
+  RACK_INPUT = ::T.let(nil, ::T.untyped)
+  RACK_IS_HIJACK = ::T.let(nil, ::T.untyped)
+  RACK_LOGGER = ::T.let(nil, ::T.untyped)
+  RACK_METHODOVERRIDE_ORIGINAL_METHOD = ::T.let(nil, ::T.untyped)
+  RACK_MULTIPART_BUFFER_SIZE = ::T.let(nil, ::T.untyped)
+  RACK_MULTIPART_TEMPFILE_FACTORY = ::T.let(nil, ::T.untyped)
+  RACK_MULTIPROCESS = ::T.let(nil, ::T.untyped)
+  RACK_MULTITHREAD = ::T.let(nil, ::T.untyped)
+  RACK_RECURSIVE_INCLUDE = ::T.let(nil, ::T.untyped)
+  RACK_REQUEST_COOKIE_HASH = ::T.let(nil, ::T.untyped)
+  RACK_REQUEST_COOKIE_STRING = ::T.let(nil, ::T.untyped)
+  RACK_REQUEST_FORM_HASH = ::T.let(nil, ::T.untyped)
+  RACK_REQUEST_FORM_INPUT = ::T.let(nil, ::T.untyped)
+  RACK_REQUEST_FORM_VARS = ::T.let(nil, ::T.untyped)
+  RACK_REQUEST_QUERY_HASH = ::T.let(nil, ::T.untyped)
+  RACK_REQUEST_QUERY_STRING = ::T.let(nil, ::T.untyped)
+  RACK_RUNONCE = ::T.let(nil, ::T.untyped)
+  RACK_SESSION = ::T.let(nil, ::T.untyped)
+  RACK_SESSION_OPTIONS = ::T.let(nil, ::T.untyped)
+  RACK_SESSION_UNPACKED_COOKIE_DATA = ::T.let(nil, ::T.untyped)
+  RACK_SHOWSTATUS_DETAIL = ::T.let(nil, ::T.untyped)
+  RACK_TEMPFILES = ::T.let(nil, ::T.untyped)
+  RACK_URL_SCHEME = ::T.let(nil, ::T.untyped)
+  RACK_VERSION = ::T.let(nil, ::T.untyped)
+  RELEASE = ::T.let(nil, ::T.untyped)
+  REQUEST_METHOD = ::T.let(nil, ::T.untyped)
+  REQUEST_PATH = ::T.let(nil, ::T.untyped)
+  SCRIPT_NAME = ::T.let(nil, ::T.untyped)
+  SERVER_NAME = ::T.let(nil, ::T.untyped)
+  SERVER_PORT = ::T.let(nil, ::T.untyped)
+  SERVER_PROTOCOL = ::T.let(nil, ::T.untyped)
+  SET_COOKIE = ::T.let(nil, ::T.untyped)
+  TRACE = ::T.let(nil, ::T.untyped)
+  TRANSFER_ENCODING = ::T.let(nil, ::T.untyped)
+  UNLINK = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
 end
 
-class Range
-  def %(_); end
-
-  def entries(); end
-
-  def sum(identity=T.unsafe(nil)); end
-
-  def to_a(); end
+module Rack::Auth
 end
 
-module RbConfig
-  def self.expand(val, config=T.unsafe(nil)); end
+class Rack::Auth::AbstractHandler
+  def initialize(app, realm=T.unsafe(nil), &authenticator); end
 
-  def self.fire_update!(key, val, mkconf=T.unsafe(nil), conf=T.unsafe(nil)); end
+  def realm(); end
 
-  def self.ruby(); end
+  def realm=(realm); end
 end
 
-module Readline
-  def self.completion_quote_character(); end
+class Rack::Auth::AbstractHandler
 end
 
-class Requirement
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
+class Rack::Auth::AbstractRequest
+  def initialize(env); end
 
-class Requirements
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
+  def params(); end
 
-class Resolv::DNS
-  def extract_resources(msg, name, typeclass); end
+  def parts(); end
 
-  def getname(address); end
-  RequestID = ::T.let(nil, ::T.untyped)
-  RequestIDMutex = ::T.let(nil, ::T.untyped)
-end
+  def provided?(); end
 
-class Resolv::DNS::Config
-  def initialize(config_info=T.unsafe(nil)); end
-end
+  def request(); end
 
-class Resolv::DNS::Label::Str
-  def initialize(string); end
+  def scheme(); end
+
+  def valid?(); end
+  AUTHORIZATION_KEYS = ::T.let(nil, ::T.untyped)
 end
 
-class Resolv::DNS::Message
-  def initialize(id=T.unsafe(nil)); end
+class Rack::Auth::AbstractRequest
 end
 
-class Resolv::DNS::Message::MessageDecoder
-  def initialize(data); end
+class Rack::Auth::Basic
+  def call(env); end
 end
 
-class Resolv::DNS::Requester::ConnectedUDP
-  def initialize(host, port=T.unsafe(nil)); end
+class Rack::Auth::Basic::Request
+  def basic?(); end
 
-  def lazy_initialize(); end
-end
+  def credentials(); end
 
-class Resolv::DNS::Requester::Sender
-  def initialize(msg, data, sock); end
+  def username(); end
 end
 
-class Resolv::DNS::Requester::TCP
-  def initialize(host, port=T.unsafe(nil)); end
+class Rack::Auth::Basic::Request
 end
 
-class Resolv::DNS::Requester::UnconnectedUDP
-  def initialize(*nameserver_port); end
-
-  def lazy_initialize(); end
+class Rack::Auth::Basic
 end
 
-class Resolv::DNS::Requester::UnconnectedUDP::Sender
-  def initialize(msg, data, sock, host, port); end
+module Rack::Auth::Digest
 end
 
-class Resolv::DNS::Resource
-  ClassValue = ::T.let(nil, ::T.untyped)
-end
+class Rack::Auth::Digest::MD5
+  def call(env); end
 
-class Resolv::DNS::Resource::LOC
-  def initialize(version, ssize, hprecision, vprecision, latitude, longitude, altitude); end
-end
+  def initialize(app, realm=T.unsafe(nil), opaque=T.unsafe(nil), &authenticator); end
 
-class Resolv::DNS
-  def self.allocate_request_id(host, port); end
+  def opaque(); end
 
-  def self.bind_random_port(udpsock, bind_host=T.unsafe(nil)); end
+  def opaque=(opaque); end
 
-  def self.free_request_id(host, port, id); end
+  def passwords_hashed=(passwords_hashed); end
 
-  def self.random(arg); end
+  def passwords_hashed?(); end
+  QOP = ::T.let(nil, ::T.untyped)
 end
 
-class Resource
-  include ::FileUtils::StreamUtils_
-  def sha256(val); end
+class Rack::Auth::Digest::MD5
 end
 
-class Resource::Partial
-  def self.[](*_); end
+class Rack::Auth::Digest::Nonce
+  def digest(); end
 
-  def self.members(); end
-end
+  def fresh?(); end
 
-class ResourceStageContext
-  extend ::T::Private::Methods::MethodHooks
-  extend ::T::Private::Methods::SingletonMethodHooks
-end
+  def initialize(timestamp=T.unsafe(nil), given_digest=T.unsafe(nil)); end
 
-module Ronn
-  REV = ::T.let(nil, ::T.untyped)
-  VERSION = ::T.let(nil, ::T.untyped)
+  def stale?(); end
+
+  def valid?(); end
 end
 
-class Ronn::Document
-  include ::Ronn::Utils
-  def basename(type=T.unsafe(nil)); end
+class Rack::Auth::Digest::Nonce
+  def self.parse(string); end
 
-  def convert(format); end
+  def self.private_key(); end
 
-  def data(); end
+  def self.private_key=(private_key); end
 
-  def date(); end
+  def self.time_limit(); end
 
-  def date=(date); end
+  def self.time_limit=(time_limit); end
+end
 
-  def html(); end
+class Rack::Auth::Digest::Params
+  def [](k); end
 
-  def html_filter_angle_quotes(); end
+  def []=(k, v); end
 
-  def html_filter_annotate_bare_links(); end
+  def initialize(); end
 
-  def html_filter_definition_lists(); end
+  def quote(str); end
+  UNQUOTED = ::T.let(nil, ::T.untyped)
+end
 
-  def html_filter_heading_anchors(); end
+class Rack::Auth::Digest::Params
+  def self.dequote(str); end
 
-  def html_filter_inject_name_section(); end
+  def self.parse(str); end
 
-  def html_filter_manual_reference_links(); end
+  def self.split_header_value(str); end
+end
 
-  def index(); end
+class Rack::Auth::Digest::Request
+  def correct_uri?(); end
 
-  def index=(index); end
+  def digest?(); end
 
-  def initialize(path=T.unsafe(nil), attributes=T.unsafe(nil), &block); end
+  def method(); end
 
-  def input_html(); end
+  def method_missing(sym, *args); end
 
-  def manual(); end
+  def nonce(); end
 
-  def manual=(manual); end
+  def respond_to?(sym, *_); end
+end
 
-  def markdown(); end
+class Rack::Auth::Digest::Request
+end
 
-  def markdown_filter_angle_quotes(markdown); end
+module Rack::Auth::Digest
+end
 
-  def markdown_filter_heading_anchors(markdown); end
+module Rack::Auth
+end
 
-  def markdown_filter_link_index(markdown); end
+class Rack::BodyProxy
+  def close(); end
 
-  def name(); end
+  def closed?(); end
 
-  def name=(name); end
+  def initialize(body, &block); end
 
-  def name?(); end
+  def method_missing(method_name, *args, &block); end
+end
 
-  def organization(); end
+class Rack::BodyProxy
+end
 
-  def organization=(organization); end
+class Rack::Builder
+  def call(env); end
 
-  def path(); end
+  def freeze_app(); end
 
-  def path_for(type=T.unsafe(nil)); end
+  def initialize(default_app=T.unsafe(nil), &block); end
 
-  def path_name(); end
+  def map(path, &block); end
 
-  def path_section(); end
+  def run(app); end
 
-  def preprocess!(); end
+  def to_app(); end
 
-  def process_html!(); end
+  def use(middleware, *args, &block); end
 
-  def process_markdown!(); end
+  def warmup(prc=T.unsafe(nil), &block); end
+  UTF_8_BOM = ::T.let(nil, ::T.untyped)
+end
 
-  def reference_name(); end
+class Rack::Builder
+  def self.app(default_app=T.unsafe(nil), &block); end
 
-  def section(); end
+  def self.load_file(path, opts=T.unsafe(nil)); end
 
-  def section=(section); end
+  def self.new_from_string(builder_script, file=T.unsafe(nil)); end
 
-  def section?(); end
+  def self.parse_file(config, opts=T.unsafe(nil)); end
+end
 
-  def section_heads(); end
+class Rack::Cascade
+  def <<(app); end
 
-  def sniff(); end
+  def add(app); end
+
+  def apps(); end
+
+  def call(env); end
+
+  def include?(app); end
+
+  def initialize(apps, cascade_for=T.unsafe(nil)); end
+  NotFound = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::Cascade
+end
+
+class Rack::Chunked
+  include ::Rack::Utils
+  def call(env); end
+
+  def chunkable_version?(ver); end
+
+  def initialize(app); end
+end
+
+class Rack::Chunked::Body
+  def close(); end
+
+  def each(&block); end
+
+  def initialize(body); end
+  TAIL = ::T.let(nil, ::T.untyped)
+  TERM = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::Chunked::Body
+end
+
+class Rack::Chunked::TrailerBody
+end
+
+class Rack::Chunked::TrailerBody
+end
+
+class Rack::Chunked
+end
+
+class Rack::CommonLogger
+  def call(env); end
+
+  def initialize(app, logger=T.unsafe(nil)); end
+  FORMAT = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::CommonLogger
+end
+
+class Rack::ConditionalGet
+  def call(env); end
+
+  def initialize(app); end
+end
+
+class Rack::ConditionalGet
+end
+
+class Rack::Config
+  def call(env); end
+
+  def initialize(app, &block); end
+end
+
+class Rack::Config
+end
+
+class Rack::ContentLength
+  include ::Rack::Utils
+  def call(env); end
+
+  def initialize(app); end
+end
+
+class Rack::ContentLength
+end
+
+class Rack::ContentType
+  include ::Rack::Utils
+  def call(env); end
+
+  def initialize(app, content_type=T.unsafe(nil)); end
+end
+
+class Rack::ContentType
+end
+
+class Rack::Deflater
+  def call(env); end
+
+  def initialize(app, options=T.unsafe(nil)); end
+end
+
+class Rack::Deflater::GzipStream
+  def close(); end
+
+  def each(&block); end
+
+  def initialize(body, mtime, sync); end
+
+  def write(data); end
+end
+
+class Rack::Deflater::GzipStream
+end
+
+class Rack::Deflater
+end
+
+class Rack::Directory
+  def call(env); end
+
+  def check_bad_request(path_info); end
+
+  def check_forbidden(path_info); end
+
+  def entity_not_found(path_info); end
+
+  def filesize_format(int); end
+
+  def get(env); end
+
+  def initialize(root, app=T.unsafe(nil)); end
+
+  def list_directory(path_info, path, script_name); end
+
+  def list_path(env, path, path_info, script_name); end
+
+  def root(); end
+
+  def stat(path); end
+  DIR_FILE = ::T.let(nil, ::T.untyped)
+  DIR_PAGE_FOOTER = ::T.let(nil, ::T.untyped)
+  DIR_PAGE_HEADER = ::T.let(nil, ::T.untyped)
+  FILESIZE_FORMAT = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::Directory::DirectoryBody
+end
+
+class Rack::Directory::DirectoryBody
+end
+
+class Rack::Directory
+end
+
+class Rack::ETag
+  def call(env); end
+
+  def initialize(app, no_cache_control=T.unsafe(nil), cache_control=T.unsafe(nil)); end
+  DEFAULT_CACHE_CONTROL = ::T.let(nil, ::T.untyped)
+  ETAG_STRING = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::ETag
+end
+
+class Rack::Events
+  def call(env); end
+
+  def initialize(app, handlers); end
+end
+
+module Rack::Events::Abstract
+  def on_commit(req, res); end
+
+  def on_error(req, res, e); end
+
+  def on_finish(req, res); end
+
+  def on_send(req, res); end
+
+  def on_start(req, res); end
+end
+
+module Rack::Events::Abstract
+end
+
+class Rack::Events::BufferedResponse
+  def body(); end
+
+  def initialize(status, headers, body); end
+
+  def to_a(); end
+end
+
+class Rack::Events::BufferedResponse
+end
+
+class Rack::Events::EventedBodyProxy
+  def each(&blk); end
+
+  def initialize(body, request, response, handlers, &block); end
+
+  def request(); end
+
+  def response(); end
+end
+
+class Rack::Events::EventedBodyProxy
+end
+
+class Rack::Events
+end
+
+Rack::File = Rack::Files
+
+class Rack::Files
+  def call(env); end
+
+  def get(env); end
+
+  def initialize(root, headers=T.unsafe(nil), default_mime=T.unsafe(nil)); end
+
+  def root(); end
+
+  def serving(request, path); end
+  ALLOWED_VERBS = ::T.let(nil, ::T.untyped)
+  ALLOW_HEADER = ::T.let(nil, ::T.untyped)
+  MULTIPART_BOUNDARY = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::Files::BaseIterator
+  def bytesize(); end
+
+  def close(); end
+
+  def each(&blk); end
+
+  def initialize(path, ranges, options); end
+
+  def options(); end
+
+  def path(); end
+
+  def ranges(); end
+end
+
+class Rack::Files::BaseIterator
+end
+
+class Rack::Files::Iterator
+  def to_path(); end
+end
+
+class Rack::Files::Iterator
+end
+
+class Rack::Files
+end
+
+class Rack::ForwardRequest
+  def env(); end
+
+  def initialize(url, env=T.unsafe(nil)); end
+
+  def url(); end
+end
+
+class Rack::ForwardRequest
+end
+
+module Rack::Handler
+end
+
+class Rack::Handler::CGI
+end
+
+class Rack::Handler::CGI
+  def self.run(app, **options); end
+
+  def self.send_body(body); end
+
+  def self.send_headers(status, headers); end
+
+  def self.serve(app); end
+end
+
+class Rack::Handler::WEBrick
+  def initialize(server, app); end
+end
+
+class Rack::Handler::WEBrick
+  def self.run(app, **options); end
+
+  def self.shutdown(); end
+
+  def self.valid_options(); end
+end
+
+module Rack::Handler
+  def self.default(); end
+
+  def self.get(server); end
+
+  def self.pick(server_names); end
+
+  def self.register(server, klass); end
+
+  def self.try_require(prefix, const_name); end
+end
+
+class Rack::Head
+  def call(env); end
+
+  def initialize(app); end
+end
+
+class Rack::Head
+end
+
+class Rack::Lint
+  include ::Rack::Lint::Assertion
+  def _call(env); end
+
+  def call(env=T.unsafe(nil)); end
+
+  def check_content_length(status, headers); end
+
+  def check_content_type(status, headers); end
+
+  def check_env(env); end
+
+  def check_error(error); end
+
+  def check_headers(header); end
+
+  def check_hijack(env); end
+
+  def check_hijack_response(headers, env); end
+
+  def check_input(input); end
+
+  def check_status(status); end
+
+  def close(); end
+
+  def each(&blk); end
+
+  def initialize(app); end
+
+  def verify_content_length(bytes); end
+end
+
+module Rack::Lint::Assertion
+  def assert(message); end
+end
+
+module Rack::Lint::Assertion
+end
+
+class Rack::Lint::ErrorWrapper
+  include ::Rack::Lint::Assertion
+  def close(*args); end
+
+  def flush(); end
+
+  def initialize(error); end
+
+  def puts(str); end
+
+  def write(str); end
+end
+
+class Rack::Lint::ErrorWrapper
+end
+
+class Rack::Lint::HijackWrapper
+  include ::Rack::Lint::Assertion
+  def close(*args, &block); end
+
+  def close_read(*args, &block); end
+
+  def close_write(*args, &block); end
+
+  def closed?(*args, &block); end
+
+  def flush(*args, &block); end
+
+  def initialize(io); end
+
+  def read(*args, &block); end
+
+  def read_nonblock(*args, &block); end
+
+  def write(*args, &block); end
+
+  def write_nonblock(*args, &block); end
+  REQUIRED_METHODS = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::Lint::HijackWrapper
+  extend ::Forwardable
+end
+
+class Rack::Lint::InputWrapper
+  include ::Rack::Lint::Assertion
+  def close(*args); end
+
+  def each(*args, &blk); end
+
+  def gets(*args); end
+
+  def initialize(input); end
+
+  def read(*args); end
+
+  def rewind(*args); end
+end
+
+class Rack::Lint::InputWrapper
+end
+
+class Rack::Lint::LintError
+end
+
+class Rack::Lint::LintError
+end
+
+class Rack::Lint
+end
+
+class Rack::Lock
+  def call(env); end
+
+  def initialize(app, mutex=T.unsafe(nil)); end
+end
+
+class Rack::Lock
+end
+
+class Rack::Logger
+  def call(env); end
+
+  def initialize(app, level=T.unsafe(nil)); end
+end
+
+class Rack::Logger
+end
+
+class Rack::MediaType
+  SPLIT_PATTERN = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::MediaType
+  def self.params(content_type); end
+
+  def self.type(content_type); end
+end
+
+class Rack::MethodOverride
+  def call(env); end
+
+  def initialize(app); end
+
+  def method_override(env); end
+  ALLOWED_METHODS = ::T.let(nil, ::T.untyped)
+  HTTP_METHODS = ::T.let(nil, ::T.untyped)
+  HTTP_METHOD_OVERRIDE_HEADER = ::T.let(nil, ::T.untyped)
+  METHOD_OVERRIDE_PARAM_KEY = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::MethodOverride
+end
+
+module Rack::Mime
+  MIME_TYPES = ::T.let(nil, ::T.untyped)
+end
+
+module Rack::Mime
+  def self.match?(value, matcher); end
+
+  def self.mime_type(ext, fallback=T.unsafe(nil)); end
+end
+
+class Rack::MockRequest
+  def delete(uri, opts=T.unsafe(nil)); end
+
+  def get(uri, opts=T.unsafe(nil)); end
+
+  def head(uri, opts=T.unsafe(nil)); end
+
+  def initialize(app); end
+
+  def options(uri, opts=T.unsafe(nil)); end
+
+  def patch(uri, opts=T.unsafe(nil)); end
+
+  def post(uri, opts=T.unsafe(nil)); end
+
+  def put(uri, opts=T.unsafe(nil)); end
+
+  def request(method=T.unsafe(nil), uri=T.unsafe(nil), opts=T.unsafe(nil)); end
+  DEFAULT_ENV = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::MockRequest::FatalWarner
+  def flush(); end
+
+  def puts(warning); end
+
+  def string(); end
+
+  def write(warning); end
+end
+
+class Rack::MockRequest::FatalWarner
+end
+
+class Rack::MockRequest::FatalWarning
+end
+
+class Rack::MockRequest::FatalWarning
+end
+
+class Rack::MockRequest
+  def self.env_for(uri=T.unsafe(nil), opts=T.unsafe(nil)); end
+
+  def self.parse_uri_rfc2396(uri); end
+end
+
+class Rack::MockResponse
+  def =~(other); end
+
+  def cookie(name); end
+
+  def cookies(); end
+
+  def errors(); end
+
+  def errors=(errors); end
+
+  def initialize(status, headers, body, errors=T.unsafe(nil)); end
+
+  def match(other); end
+
+  def original_headers(); end
+end
+
+class Rack::MockResponse
+  def self.[](*_); end
+end
+
+module Rack::Multipart
+  ATTRIBUTE = ::T.let(nil, ::T.untyped)
+  ATTRIBUTE_CHAR = ::T.let(nil, ::T.untyped)
+  BROKEN_QUOTED = ::T.let(nil, ::T.untyped)
+  BROKEN_UNQUOTED = ::T.let(nil, ::T.untyped)
+  CONDISP = ::T.let(nil, ::T.untyped)
+  DISPPARM = ::T.let(nil, ::T.untyped)
+  EOL = ::T.let(nil, ::T.untyped)
+  EXTENDED_INITIAL_NAME = ::T.let(nil, ::T.untyped)
+  EXTENDED_INITIAL_PARAMETER = ::T.let(nil, ::T.untyped)
+  EXTENDED_INITIAL_VALUE = ::T.let(nil, ::T.untyped)
+  EXTENDED_OTHER_NAME = ::T.let(nil, ::T.untyped)
+  EXTENDED_OTHER_PARAMETER = ::T.let(nil, ::T.untyped)
+  EXTENDED_OTHER_VALUE = ::T.let(nil, ::T.untyped)
+  EXTENDED_PARAMETER = ::T.let(nil, ::T.untyped)
+  MULTIPART = ::T.let(nil, ::T.untyped)
+  MULTIPART_BOUNDARY = ::T.let(nil, ::T.untyped)
+  MULTIPART_CONTENT_DISPOSITION = ::T.let(nil, ::T.untyped)
+  MULTIPART_CONTENT_ID = ::T.let(nil, ::T.untyped)
+  MULTIPART_CONTENT_TYPE = ::T.let(nil, ::T.untyped)
+  REGULAR_PARAMETER = ::T.let(nil, ::T.untyped)
+  REGULAR_PARAMETER_NAME = ::T.let(nil, ::T.untyped)
+  RFC2183 = ::T.let(nil, ::T.untyped)
+  SECTION = ::T.let(nil, ::T.untyped)
+  TOKEN = ::T.let(nil, ::T.untyped)
+  VALUE = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::Multipart::Generator
+  def dump(); end
+
+  def initialize(params, first=T.unsafe(nil)); end
+end
+
+class Rack::Multipart::Generator
+end
+
+class Rack::Multipart::MultipartPartLimitError
+end
+
+class Rack::Multipart::MultipartPartLimitError
+end
+
+class Rack::Multipart::Parser
+  def initialize(boundary, tempfile, bufsize, query_parser); end
+
+  def on_read(content); end
+
+  def result(); end
+
+  def state(); end
+  BOUNDARY_REGEX = ::T.let(nil, ::T.untyped)
+  BUFSIZE = ::T.let(nil, ::T.untyped)
+  CHARSET = ::T.let(nil, ::T.untyped)
+  EMPTY = ::T.let(nil, ::T.untyped)
+  TEMPFILE_FACTORY = ::T.let(nil, ::T.untyped)
+  TEXT_PLAIN = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::Multipart::Parser::BoundedIO
+  def initialize(io, content_length); end
+
+  def read(size, outbuf=T.unsafe(nil)); end
+
+  def rewind(); end
+end
+
+class Rack::Multipart::Parser::BoundedIO
+end
+
+class Rack::Multipart::Parser::Collector
+  include ::Enumerable
+  def each(&blk); end
+
+  def initialize(tempfile); end
+
+  def on_mime_body(mime_index, content); end
+
+  def on_mime_finish(mime_index); end
+
+  def on_mime_head(mime_index, head, filename, content_type, name); end
+end
+
+class Rack::Multipart::Parser::Collector::BufferPart
+  def close(); end
+
+  def file?(); end
+end
+
+class Rack::Multipart::Parser::Collector::BufferPart
+end
+
+class Rack::Multipart::Parser::Collector::MimePart
+  def get_data(); end
+end
+
+class Rack::Multipart::Parser::Collector::MimePart
+end
+
+class Rack::Multipart::Parser::Collector::TempfilePart
+  def close(); end
+
+  def file?(); end
+end
+
+class Rack::Multipart::Parser::Collector::TempfilePart
+end
+
+class Rack::Multipart::Parser::Collector
+end
+
+class Rack::Multipart::Parser::MultipartInfo
+  def params(); end
+
+  def params=(_); end
+
+  def tmp_files(); end
+
+  def tmp_files=(_); end
+end
+
+class Rack::Multipart::Parser::MultipartInfo
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+class Rack::Multipart::Parser
+  def self.parse(io, content_length, content_type, tmpfile, bufsize, qp); end
+
+  def self.parse_boundary(content_type); end
+end
+
+class Rack::Multipart::UploadedFile
+  def content_type(); end
+
+  def content_type=(content_type); end
+
+  def initialize(filepath=T.unsafe(nil), ct=T.unsafe(nil), bin=T.unsafe(nil), path: T.unsafe(nil), content_type: T.unsafe(nil), binary: T.unsafe(nil), filename: T.unsafe(nil), io: T.unsafe(nil)); end
+
+  def local_path(); end
+
+  def method_missing(method_name, *args, &block); end
+
+  def original_filename(); end
+
+  def path(); end
+
+  def respond_to?(*args); end
+end
+
+class Rack::Multipart::UploadedFile
+end
+
+module Rack::Multipart
+  def self.build_multipart(params, first=T.unsafe(nil)); end
+
+  def self.extract_multipart(req, params=T.unsafe(nil)); end
+
+  def self.parse_multipart(env, params=T.unsafe(nil)); end
+end
+
+class Rack::NullLogger
+  def <<(msg); end
+
+  def add(severity, message=T.unsafe(nil), progname=T.unsafe(nil), &block); end
+
+  def call(env); 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 error(progname=T.unsafe(nil), &block); end
+
+  def error?(); end
+
+  def fatal(progname=T.unsafe(nil), &block); end
+
+  def fatal?(); end
+
+  def formatter(); end
+
+  def formatter=(formatter); end
+
+  def info(progname=T.unsafe(nil), &block); end
+
+  def info?(); end
+
+  def initialize(app); end
+
+  def level(); end
+
+  def level=(level); end
+
+  def progname(); end
+
+  def progname=(progname); end
+
+  def sev_threshold(); end
+
+  def sev_threshold=(sev_threshold); end
+
+  def unknown(progname=T.unsafe(nil), &block); end
+
+  def warn(progname=T.unsafe(nil), &block); end
+
+  def warn?(); end
+end
+
+class Rack::NullLogger
+end
+
+class Rack::Recursive
+  def _call(env); end
+
+  def call(env); end
+
+  def include(env, path); end
+
+  def initialize(app); end
+end
+
+class Rack::Recursive
+end
+
+class Rack::Reloader
+  def call(env); end
+
+  def initialize(app, cooldown=T.unsafe(nil), backend=T.unsafe(nil)); end
+
+  def reload!(stderr=T.unsafe(nil)); end
+
+  def safe_load(file, mtime, stderr=T.unsafe(nil)); end
+end
+
+module Rack::Reloader::Stat
+  def figure_path(file, paths); end
+
+  def rotation(); end
+
+  def safe_stat(file); end
+end
+
+module Rack::Reloader::Stat
+end
+
+class Rack::Reloader
+end
+
+class Rack::Request
+  include ::Rack::Request::Env
+  include ::Rack::Request::Helpers
+  ALLOWED_SCHEMES = ::T.let(nil, ::T.untyped)
+  SCHEME_WHITELIST = ::T.let(nil, ::T.untyped)
+end
+
+module Rack::Request::Env
+  def add_header(key, v); end
+
+  def delete_header(name); end
+
+  def each_header(&block); end
+
+  def env(); end
+
+  def fetch_header(name, &block); end
+
+  def get_header(name); end
+
+  def has_header?(name); end
+
+  def initialize(env); end
+
+  def set_header(name, v); end
+end
+
+module Rack::Request::Env
+end
+
+module Rack::Request::Helpers
+  def GET(); end
+
+  def POST(); end
+
+  def [](key); end
+
+  def []=(key, value); end
+
+  def accept_encoding(); end
+
+  def accept_language(); end
+
+  def authority(); end
+
+  def base_url(); end
+
+  def body(); end
+
+  def content_charset(); end
+
+  def content_length(); end
+
+  def content_type(); end
+
+  def cookies(); end
+
+  def delete?(); end
+
+  def delete_param(k); end
+
+  def form_data?(); end
+
+  def forwarded_authority(); end
+
+  def forwarded_for(); end
+
+  def forwarded_port(); end
+
+  def fullpath(); end
+
+  def get?(); end
+
+  def head?(); end
+
+  def host(); end
+
+  def host_authority(); end
+
+  def host_with_port(authority=T.unsafe(nil)); end
+
+  def hostname(); end
+
+  def ip(); end
+
+  def link?(); end
+
+  def logger(); end
+
+  def media_type(); end
+
+  def media_type_params(); end
+
+  def multithread?(); end
+
+  def options?(); end
+
+  def params(); end
+
+  def parseable_data?(); end
+
+  def patch?(); end
+
+  def path(); end
+
+  def path_info(); end
+
+  def path_info=(s); end
+
+  def port(); end
+
+  def post?(); end
+
+  def put?(); end
+
+  def query_string(); end
+
+  def referer(); end
+
+  def referrer(); end
+
+  def request_method(); end
+
+  def scheme(); end
+
+  def script_name(); end
+
+  def script_name=(s); end
+
+  def server_authority(); end
+
+  def server_name(); end
+
+  def server_port(); end
+
+  def session(); end
+
+  def session_options(); end
+
+  def ssl?(); end
+
+  def trace?(); end
+
+  def trusted_proxy?(ip); end
+
+  def unlink?(); end
+
+  def update_param(k, v); end
+
+  def url(); end
+
+  def user_agent(); end
+
+  def values_at(*keys); end
+
+  def xhr?(); end
+  DEFAULT_PORTS = ::T.let(nil, ::T.untyped)
+  FORM_DATA_MEDIA_TYPES = ::T.let(nil, ::T.untyped)
+  HTTP_X_FORWARDED_FOR = ::T.let(nil, ::T.untyped)
+  HTTP_X_FORWARDED_HOST = ::T.let(nil, ::T.untyped)
+  HTTP_X_FORWARDED_PORT = ::T.let(nil, ::T.untyped)
+  HTTP_X_FORWARDED_PROTO = ::T.let(nil, ::T.untyped)
+  HTTP_X_FORWARDED_SCHEME = ::T.let(nil, ::T.untyped)
+  HTTP_X_FORWARDED_SSL = ::T.let(nil, ::T.untyped)
+  PARSEABLE_DATA_MEDIA_TYPES = ::T.let(nil, ::T.untyped)
+end
+
+module Rack::Request::Helpers
+end
+
+class Rack::Request
+  def self.ip_filter(); end
+
+  def self.ip_filter=(ip_filter); end
+end
+
+class Rack::Response
+  include ::Rack::Response::Helpers
+  def [](key); end
+
+  def []=(key, v); end
+
+  def body(); end
+
+  def body=(body); end
+
+  def chunked?(); end
+
+  def close(); end
+
+  def delete_header(key); end
+
+  def each(&callback); end
+
+  def empty?(); end
+
+  def finish(&block); end
+
+  def get_header(key); end
+
+  def has_header?(key); end
+
+  def header(); end
+
+  def headers(); end
+
+  def initialize(body=T.unsafe(nil), status=T.unsafe(nil), headers=T.unsafe(nil)); end
+
+  def length(); end
+
+  def length=(length); end
+
+  def redirect(target, status=T.unsafe(nil)); end
+
+  def set_header(key, v); end
+
+  def status(); end
+
+  def status=(status); end
+
+  def to_a(&block); end
+
+  def write(chunk); end
+  CHUNKED = ::T.let(nil, ::T.untyped)
+  STATUS_WITH_NO_ENTITY_BODY = ::T.let(nil, ::T.untyped)
+end
+
+module Rack::Response::Helpers
+  def accepted?(); end
+
+  def add_header(key, v); end
+
+  def append(chunk); end
+
+  def bad_request?(); end
+
+  def buffered_body!(); end
+
+  def cache!(duration=T.unsafe(nil), directive: T.unsafe(nil)); end
+
+  def cache_control(); end
+
+  def cache_control=(v); end
+
+  def client_error?(); end
+
+  def content_length(); end
+
+  def content_type(); end
+
+  def content_type=(content_type); end
+
+  def created?(); end
+
+  def delete_cookie(key, value=T.unsafe(nil)); end
+
+  def do_not_cache!(); end
+
+  def etag(); end
+
+  def etag=(v); end
+
+  def forbidden?(); end
+
+  def include?(header); end
+
+  def informational?(); end
+
+  def invalid?(); end
+
+  def location(); end
+
+  def location=(location); end
+
+  def media_type(); end
+
+  def media_type_params(); end
+
+  def method_not_allowed?(); end
+
+  def moved_permanently?(); end
+
+  def no_content?(); end
+
+  def not_found?(); end
+
+  def ok?(); end
+
+  def precondition_failed?(); end
+
+  def redirect?(); end
+
+  def redirection?(); end
+
+  def server_error?(); end
+
+  def set_cookie(key, value); end
+
+  def set_cookie_header(); end
+
+  def set_cookie_header=(v); end
+
+  def successful?(); end
+
+  def unauthorized?(); end
+
+  def unprocessable?(); end
+end
+
+module Rack::Response::Helpers
+end
+
+class Rack::Response::Raw
+  include ::Rack::Response::Helpers
+  def delete_header(key); end
+
+  def get_header(key); end
+
+  def has_header?(key); end
+
+  def headers(); end
+
+  def initialize(status, headers); end
+
+  def set_header(key, v); end
+
+  def status(); end
+
+  def status=(status); end
+end
+
+class Rack::Response::Raw
+end
+
+class Rack::Response
+  def self.[](status, headers, body); end
+end
+
+class Rack::RewindableInput
+  def close(); end
+
+  def each(&block); end
+
+  def gets(); end
+
+  def initialize(io); end
+
+  def read(*args); end
+
+  def rewind(); end
+end
+
+class Rack::RewindableInput
+end
+
+class Rack::Runtime
+  def call(env); end
+
+  def initialize(app, name=T.unsafe(nil)); end
+  FORMAT_STRING = ::T.let(nil, ::T.untyped)
+  HEADER_NAME = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::Runtime
+end
+
+class Rack::Sendfile
+  def call(env); end
+
+  def initialize(app, variation=T.unsafe(nil), mappings=T.unsafe(nil)); end
+end
+
+class Rack::Sendfile
+end
+
+class Rack::Server
+  def app(); end
+
+  def default_options(); end
+
+  def initialize(options=T.unsafe(nil)); end
+
+  def middleware(); end
+
+  def options(); end
+
+  def options=(options); end
+
+  def server(); end
+
+  def start(&block); end
+end
+
+class Rack::Server::Options
+  def handler_opts(options); end
+
+  def parse!(args); end
+end
+
+class Rack::Server::Options
+end
+
+class Rack::Server
+  def self.default_middleware_by_environment(); end
+
+  def self.logging_middleware(); end
+
+  def self.middleware(); end
+
+  def self.start(options=T.unsafe(nil)); end
+end
+
+module Rack::Session
+end
+
+module Rack::Session::Abstract
+end
+
+class Rack::Session::Abstract::ID
+  def find_session(req, sid); end
+end
+
+class Rack::Session::Abstract::ID
+  def self.inherited(klass); end
+end
+
+class Rack::Session::Abstract::Persisted
+  def call(env); end
+
+  def commit_session(req, res); end
+
+  def context(env, app=T.unsafe(nil)); end
+
+  def default_options(); end
+
+  def initialize(app, options=T.unsafe(nil)); end
+
+  def key(); end
+
+  def sid_secure(); end
+  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::Session::Abstract::Persisted
+end
+
+class Rack::Session::Abstract::PersistedSecure
+  def extract_session_id(*_); end
+
+  def generate_sid(*_); end
+end
+
+class Rack::Session::Abstract::PersistedSecure::SecureSessionHash
+end
+
+class Rack::Session::Abstract::PersistedSecure::SecureSessionHash
+end
+
+class Rack::Session::Abstract::PersistedSecure
+end
+
+class Rack::Session::Abstract::SessionHash
+  include ::Enumerable
+  def [](key); end
+
+  def []=(key, value); end
+
+  def clear(); end
+
+  def delete(key); end
+
+  def destroy(); end
+
+  def dig(key, *keys); end
+
+  def each(&block); end
+
+  def empty?(); end
+
+  def exists?(); end
+
+  def fetch(key, default=T.unsafe(nil), &block); end
+
+  def has_key?(key); end
+
+  def id(); end
+
+  def id=(id); end
+
+  def include?(key); end
+
+  def initialize(store, req); end
+
+  def key?(key); end
+
+  def keys(); end
+
+  def loaded?(); end
+
+  def merge!(hash); end
+
+  def options(); end
+
+  def replace(hash); end
+
+  def store(key, value); end
+
+  def to_hash(); end
+
+  def update(hash); end
+
+  def values(); end
+  Unspecified = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::Session::Abstract::SessionHash
+  def self.find(req); end
+
+  def self.set(req, session); end
+
+  def self.set_options(req, options); end
+end
+
+module Rack::Session::Abstract
+end
+
+class Rack::Session::Cookie
+  def coder(); end
+end
+
+class Rack::Session::Cookie::Base64
+  def decode(str); end
+
+  def encode(str); end
+end
+
+class Rack::Session::Cookie::Base64::JSON
+  def encode(obj); end
+end
+
+class Rack::Session::Cookie::Base64::JSON
+end
+
+class Rack::Session::Cookie::Base64::Marshal
+end
+
+class Rack::Session::Cookie::Base64::Marshal
+end
+
+class Rack::Session::Cookie::Base64::ZipJSON
+  def encode(obj); end
+end
+
+class Rack::Session::Cookie::Base64::ZipJSON
+end
+
+class Rack::Session::Cookie::Base64
+end
+
+class Rack::Session::Cookie::Identity
+  def decode(str); end
+
+  def encode(str); end
+end
+
+class Rack::Session::Cookie::Identity
+end
+
+class Rack::Session::Cookie::SessionId
+  def cookie_value(); end
+
+  def initialize(session_id, cookie_value); end
+end
+
+class Rack::Session::Cookie::SessionId
+end
+
+class Rack::Session::Cookie
+end
+
+class Rack::Session::Pool
+  def delete_session(req, session_id, options); end
+
+  def find_session(req, sid); end
+
+  def generate_sid(); end
+
+  def mutex(); end
+
+  def pool(); end
+
+  def with_lock(req); end
+
+  def write_session(req, session_id, new_session, options); end
+  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::Session::Pool
+end
+
+class Rack::Session::SessionId
+  def cookie_value(); end
+
+  def empty?(); end
+
+  def initialize(public_id); end
+
+  def private_id(); end
+
+  def public_id(); end
+  ID_VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::Session::SessionId
+end
+
+module Rack::Session
+end
+
+class Rack::ShowExceptions
+  def call(env); end
+
+  def dump_exception(exception); end
+
+  def h(obj); end
+
+  def initialize(app); end
+
+  def prefers_plaintext?(env); end
+
+  def pretty(env, exception); end
+
+  def template(); end
+  CONTEXT = ::T.let(nil, ::T.untyped)
+  TEMPLATE = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::ShowExceptions
+end
+
+class Rack::ShowStatus
+  def call(env); end
+
+  def h(obj); end
+
+  def initialize(app); end
+  TEMPLATE = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::ShowStatus
+end
+
+class Rack::Static
+  def add_index_root?(path); end
+
+  def applicable_rules(path); end
+
+  def call(env); end
+
+  def can_serve(path); end
+
+  def initialize(app, options=T.unsafe(nil)); end
+
+  def overwrite_file_path(path); end
+
+  def route_file(path); end
+end
+
+class Rack::Static
+end
+
+class Rack::TempfileReaper
+  def call(env); end
+
+  def initialize(app); end
+end
+
+class Rack::TempfileReaper
+end
+
+class Rack::URLMap
+  def call(env); end
+
+  def initialize(map=T.unsafe(nil)); end
+
+  def remap(map); end
+end
+
+class Rack::URLMap
+end
+
+module Rack
+  def self.release(); end
+
+  def self.version(); end
+end
+
+class Random
+  def self.bytes(_); end
+end
+
+class Range
+  def %(_); end
+
+  def entries(); end
+
+  def sum(identity=T.unsafe(nil)); end
+
+  def to_a(); end
+end
+
+module RbConfig
+  def self.expand(val, config=T.unsafe(nil)); end
+
+  def self.fire_update!(key, val, mkconf=T.unsafe(nil), conf=T.unsafe(nil)); end
+
+  def self.ruby(); end
+end
+
+module Readline
+  def self.completion_quote_character(); end
+end
+
+class Requirement
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
+
+class Requirements
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
+
+class Resolv::DNS
+  def extract_resources(msg, name, typeclass); end
+
+  def getname(address); end
+  RequestID = ::T.let(nil, ::T.untyped)
+  RequestIDMutex = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Config
+  def initialize(config_info=T.unsafe(nil)); end
+end
+
+class Resolv::DNS::Label::Str
+  def initialize(string); end
+end
+
+class Resolv::DNS::Message
+  def initialize(id=T.unsafe(nil)); end
+end
+
+class Resolv::DNS::Message::MessageDecoder
+  def initialize(data); end
+end
+
+class Resolv::DNS::Requester::ConnectedUDP
+  def initialize(host, port=T.unsafe(nil)); end
+
+  def lazy_initialize(); end
+end
+
+class Resolv::DNS::Requester::Sender
+  def initialize(msg, data, sock); end
+end
+
+class Resolv::DNS::Requester::TCP
+  def initialize(host, port=T.unsafe(nil)); end
+end
+
+class Resolv::DNS::Requester::UnconnectedUDP
+  def initialize(*nameserver_port); end
+
+  def lazy_initialize(); end
+end
+
+class Resolv::DNS::Requester::UnconnectedUDP::Sender
+  def initialize(msg, data, sock, host, port); end
+end
+
+class Resolv::DNS::Resource
+  ClassValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::LOC
+  def initialize(version, ssize, hprecision, vprecision, latitude, longitude, altitude); end
+end
+
+class Resolv::DNS
+  def self.allocate_request_id(host, port); end
+
+  def self.bind_random_port(udpsock, bind_host=T.unsafe(nil)); end
+
+  def self.free_request_id(host, port, id); end
+
+  def self.random(arg); end
+end
+
+class Resource
+  include ::FileUtils::StreamUtils_
+  def sha256(val); end
+end
+
+class Resource::Partial
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+class ResourceStageContext
+  extend ::T::Private::Methods::MethodHooks
+  extend ::T::Private::Methods::SingletonMethodHooks
+end
+
+module Ronn
+  REV = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class Ronn::Document
+  include ::Ronn::Utils
+  def basename(type=T.unsafe(nil)); end
+
+  def convert(format); end
+
+  def data(); end
+
+  def date(); end
+
+  def date=(date); end
+
+  def html(); end
+
+  def html_filter_angle_quotes(); end
+
+  def html_filter_annotate_bare_links(); end
+
+  def html_filter_definition_lists(); end
+
+  def html_filter_heading_anchors(); end
+
+  def html_filter_inject_name_section(); end
+
+  def html_filter_manual_reference_links(); end
+
+  def index(); end
+
+  def index=(index); end
+
+  def initialize(path=T.unsafe(nil), attributes=T.unsafe(nil), &block); end
+
+  def input_html(); end
+
+  def manual(); end
+
+  def manual=(manual); end
+
+  def markdown(); end
+
+  def markdown_filter_angle_quotes(markdown); end
+
+  def markdown_filter_heading_anchors(markdown); end
+
+  def markdown_filter_link_index(markdown); end
+
+  def name(); end
+
+  def name=(name); end
+
+  def name?(); end
+
+  def organization(); end
+
+  def organization=(organization); end
+
+  def path(); end
+
+  def path_for(type=T.unsafe(nil)); end
+
+  def path_name(); end
+
+  def path_section(); end
+
+  def preprocess!(); end
+
+  def process_html!(); end
+
+  def process_markdown!(); end
+
+  def reference_name(); end
+
+  def section(); end
+
+  def section=(section); end
+
+  def section?(); end
+
+  def section_heads(); end
+
+  def sniff(); end
 
   def strip_heading(html); end
 
@@ -26173,10 +28085,31 @@ class RuboCop::AST::NodePattern::Parser
 end
 
 module RuboCop::AST::NodePattern::Sets
+  SET_AFTER_ACTION_APPEND_AFTER_ACTION_APPEND_AROUND_ACTION_ETC = ::T.let(nil, ::T.untyped)
+  SET_AP_P_PP_ETC = ::T.let(nil, ::T.untyped)
+  SET_BELONGS_TO_HAS_ONE_HAS_MANY_HAS_AND_BELONGS_TO_MANY = ::T.let(nil, ::T.untyped)
+  SET_BINWRITE_SYSWRITE_WRITE_WRITE_NONBLOCK = ::T.let(nil, ::T.untyped)
   SET_BUILD_RECOMMENDED_TEST_OPTIONAL = ::T.let(nil, ::T.untyped)
+  SET_CREATED_AT_UPDATED_AT = ::T.let(nil, ::T.untyped)
+  SET_CREATED_AT_UPDATED_AT_2 = ::T.let(nil, ::T.untyped)
   SET_DEPENDS_ON_USES_FROM_MACOS = ::T.let(nil, ::T.untyped)
+  SET_EXECUTE_REMOVE_BELONGS_TO = ::T.let(nil, ::T.untyped)
+  SET_FIRST_TAKE = ::T.let(nil, ::T.untyped)
+  SET_GET_POST_PUT_ETC = ::T.let(nil, ::T.untyped)
+  SET_HAS_MANY_HAS_ONE = ::T.let(nil, ::T.untyped)
+  SET_HAS_MANY_HAS_ONE_BELONGS_TO = ::T.let(nil, ::T.untyped)
   SET_INCLUDE_WITH_WITHOUT = ::T.let(nil, ::T.untyped)
+  SET_INSERT_INSERT = ::T.let(nil, ::T.untyped)
+  SET_ONLY_EXCEPT = ::T.let(nil, ::T.untyped)
+  SET_REFERER_REFERRER = ::T.let(nil, ::T.untyped)
+  SET_RENDER_REDIRECT_TO = ::T.let(nil, ::T.untyped)
+  SET_RETURNING_UNIQUE_BY = ::T.let(nil, ::T.untyped)
+  SET_SINCE_FROM_NOW_AFTER_ETC = ::T.let(nil, ::T.untyped)
+  SET_SKIP_AFTER_ACTION_SKIP_AROUND_ACTION_SKIP_BEFORE_ACTION_SKIP_ACTION_CALLBACK = ::T.let(nil, ::T.untyped)
   SET_SYSTEM_SHELL_OUTPUT_PIPE_OUTPUT = ::T.let(nil, ::T.untyped)
+  SET_TRANSLATE_LOCALIZE = ::T.let(nil, ::T.untyped)
+  SET_TRY_TRY = ::T.let(nil, ::T.untyped)
+  SET_UNIQ_DISTINCT = ::T.let(nil, ::T.untyped)
   SET_WITH_WITHOUT = ::T.let(nil, ::T.untyped)
 end
 
@@ -26376,6 +28309,56 @@ class RuboCop::Cop::FormulaCop
   def required_dependency_name?(param0, param1); end
 end
 
+module RuboCop::Cop::RSpec::Rails
+end
+
+class RuboCop::Cop::RSpec::Rails::HttpStatus
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def http_status(param0=T.unsafe(nil)); end
+
+  def on_send(node); end
+end
+
+class RuboCop::Cop::RSpec::Rails::HttpStatus::NumericStyleChecker
+  def initialize(node); end
+
+  def message(); end
+
+  def node(); end
+
+  def offensive?(); end
+
+  def preferred_style(); end
+  ALLOWED_STATUSES = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::RSpec::Rails::HttpStatus::NumericStyleChecker
+end
+
+class RuboCop::Cop::RSpec::Rails::HttpStatus::SymbolicStyleChecker
+  def initialize(node); end
+
+  def message(); end
+
+  def node(); end
+
+  def offensive?(); end
+
+  def preferred_style(); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::RSpec::Rails::HttpStatus::SymbolicStyleChecker
+end
+
+class RuboCop::Cop::RSpec::Rails::HttpStatus
+  extend ::RuboCop::Cop::AutoCorrector
+end
+
+module RuboCop::Cop::RSpec::Rails
+end
+
 module RuboCop::RSpec::ExpectOffense
   def expect_correction(correction, loop: T.unsafe(nil)); end
 
@@ -28277,6 +30260,7 @@ class Socket
   IPV6_PATHMTU = ::T.let(nil, ::T.untyped)
   IPV6_RECVPATHMTU = ::T.let(nil, ::T.untyped)
   IPV6_USE_MIN_MTU = ::T.let(nil, ::T.untyped)
+  IP_DONTFRAG = ::T.let(nil, ::T.untyped)
   IP_PORTRANGE = ::T.let(nil, ::T.untyped)
   IP_RECVDSTADDR = ::T.let(nil, ::T.untyped)
   IP_RECVIF = ::T.let(nil, ::T.untyped)
@@ -28368,6 +30352,7 @@ module Socket::Constants
   IPV6_PATHMTU = ::T.let(nil, ::T.untyped)
   IPV6_RECVPATHMTU = ::T.let(nil, ::T.untyped)
   IPV6_USE_MIN_MTU = ::T.let(nil, ::T.untyped)
+  IP_DONTFRAG = ::T.let(nil, ::T.untyped)
   IP_PORTRANGE = ::T.let(nil, ::T.untyped)
   IP_RECVDSTADDR = ::T.let(nil, ::T.untyped)
   IP_RECVIF = ::T.let(nil, ::T.untyped)
@@ -30602,6 +32587,46 @@ class Version::Token
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
+WEBrick::HTTPAuth::Authenticator::AuthException = WEBrick::HTTPStatus::Unauthorized
+
+WEBrick::HTTPAuth::ProxyAuthenticator::AuthException = WEBrick::HTTPStatus::ProxyAuthenticationRequired
+
+class WEBrick::HTTPRequest
+  def body_reader(); end
+
+  def readpartial(size, buf=T.unsafe(nil)); end
+  MAX_HEADER_LENGTH = ::T.let(nil, ::T.untyped)
+end
+
+class WEBrick::HTTPResponse
+  def _rack_setup_header(); end
+
+  def rack(); end
+
+  def rack=(rack); end
+end
+
+class WEBrick::HTTPResponse::ChunkedWrapper
+  def <<(*buf); end
+
+  def initialize(socket, resp); end
+
+  def write(buf); end
+end
+
+class WEBrick::HTTPResponse::ChunkedWrapper
+end
+
+class WEBrick::HTTPServer
+  def create_request(with_webrick_config); end
+
+  def create_response(with_webrick_config); end
+end
+
+class WEBrick::HTTPServlet::DefaultFileHandler
+  def multipart_body(body, parts, boundary, mtype, filesize); end
+end
+
 module Warning
   extend ::Warning
 end