diff --git a/Library/Homebrew/sorbet/rbi/gems/activesupport@6.1.4.1.rbi b/Library/Homebrew/sorbet/rbi/gems/activesupport@6.1.4.1.rbi
index c2ba590a2a..dec7ab860a 100644
--- a/Library/Homebrew/sorbet/rbi/gems/activesupport@6.1.4.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/activesupport@6.1.4.1.rbi
@@ -6,12 +6,1286 @@
 
 module ActiveSupport
   extend ::ActiveSupport::LazyLoadHooks
+  extend ::ActiveSupport::Autoload
+
+  def test_order; end
+  def test_order=(val); end
+
+  class << self
+    def eager_load!; end
+    def gem_version; end
+    def test_order; end
+    def test_order=(val); end
+    def to_time_preserves_timezone; end
+    def to_time_preserves_timezone=(value); end
+    def utc_to_local_returns_utc_offset_times; end
+    def utc_to_local_returns_utc_offset_times=(value); end
+    def version; end
+  end
+end
+
+module ActiveSupport::ActionableError
+  extend ::ActiveSupport::Concern
+
+  mixes_in_class_methods ::ActiveSupport::ActionableError::ClassMethods
+
+  class << self
+    def actions(error); end
+    def dispatch(error, name); end
+  end
+end
+
+module ActiveSupport::ActionableError::ClassMethods
+  def action(name, &block); end
+end
+
+class ActiveSupport::ActionableError::NonActionable < ::StandardError; end
+
+class ActiveSupport::ArrayInquirer < ::Array
+  def any?(*candidates); end
+
+  private
+
+  def method_missing(name, *args); end
+  def respond_to_missing?(name, include_private = T.unsafe(nil)); end
+end
+
+module ActiveSupport::Autoload
+  def autoload(const_name, path = T.unsafe(nil)); end
+  def autoload_at(path); end
+  def autoload_under(path); end
+  def autoloads; end
+  def eager_autoload; end
+  def eager_load!; end
+
+  class << self
+    def extended(base); end
+  end
+end
+
+class ActiveSupport::BacktraceCleaner
+  def initialize; end
+
+  def add_filter(&block); end
+  def add_silencer(&block); end
+  def clean(backtrace, kind = T.unsafe(nil)); end
+  def filter(backtrace, kind = T.unsafe(nil)); end
+  def remove_filters!; end
+  def remove_silencers!; end
+
+  private
+
+  def add_gem_filter; end
+  def add_gem_silencer; end
+  def add_stdlib_silencer; end
+  def filter_backtrace(backtrace); end
+  def noise(backtrace); end
+  def silence(backtrace); end
+end
+
+ActiveSupport::BacktraceCleaner::FORMATTED_GEMS_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+module ActiveSupport::Benchmarkable
+  def benchmark(message = T.unsafe(nil), options = T.unsafe(nil)); end
 end
 
 module ActiveSupport::BigDecimalWithDefaultFormat
   def to_s(format = T.unsafe(nil)); end
 end
 
+module ActiveSupport::Cache
+  class << self
+    def expand_cache_key(key, namespace = T.unsafe(nil)); end
+    def lookup_store(store = T.unsafe(nil), *parameters); end
+
+    private
+
+    def retrieve_cache_key(key); end
+    def retrieve_store_class(store); end
+  end
+end
+
+class ActiveSupport::Cache::Entry
+  def initialize(value, compress: T.unsafe(nil), compress_threshold: T.unsafe(nil), version: T.unsafe(nil), expires_in: T.unsafe(nil), **_arg5); end
+
+  def bytesize; end
+  def dup_value!; end
+  def expired?; end
+  def expires_at; end
+  def expires_at=(value); end
+  def mismatched?(version); end
+  def value; end
+  def version; end
+
+  private
+
+  def compress!(compress_threshold); end
+  def compressed?; end
+  def uncompress(value); end
+end
+
+ActiveSupport::Cache::Entry::DEFAULT_COMPRESS_LIMIT = T.let(T.unsafe(nil), Integer)
+
+class ActiveSupport::Cache::FileStore < ::ActiveSupport::Cache::Store
+  include ::ActiveSupport::Cache::Strategy::LocalCache
+
+  def initialize(cache_path, **options); end
+
+  def cache_path; end
+
+  private
+
+  def delete_empty_directories(dir); end
+  def ensure_cache_path(path); end
+  def file_path_key(path); end
+  def lock_file(file_name, &block); end
+  def modify_value(name, amount, options); end
+  def normalize_key(key, options); end
+  def search_dir(dir, &callback); end
+
+  class << self
+    def supports_cache_versioning?; end
+  end
+end
+
+ActiveSupport::Cache::FileStore::DIR_FORMATTER = T.let(T.unsafe(nil), String)
+ActiveSupport::Cache::FileStore::FILENAME_MAX_SIZE = T.let(T.unsafe(nil), Integer)
+ActiveSupport::Cache::FileStore::FILEPATH_MAX_SIZE = T.let(T.unsafe(nil), Integer)
+ActiveSupport::Cache::FileStore::GITKEEP_FILES = T.let(T.unsafe(nil), Array)
+
+class ActiveSupport::Cache::MemoryStore < ::ActiveSupport::Cache::Store
+  def initialize(options = T.unsafe(nil)); end
+
+  def cleanup(options = T.unsafe(nil)); end
+  def clear(options = T.unsafe(nil)); end
+  def decrement(name, amount = T.unsafe(nil), options = T.unsafe(nil)); end
+  def delete_matched(matcher, options = T.unsafe(nil)); end
+  def increment(name, amount = T.unsafe(nil), options = T.unsafe(nil)); end
+  def inspect; end
+  def prune(target_size, max_time = T.unsafe(nil)); end
+  def pruning?; end
+  def synchronize(&block); end
+
+  private
+
+  def cached_size(key, payload); end
+  def delete_entry(key, **options); end
+  def modify_value(name, amount, options); end
+  def read_entry(key, **options); end
+  def write_entry(key, entry, **options); end
+
+  class << self
+    def supports_cache_versioning?; end
+  end
+end
+
+ActiveSupport::Cache::MemoryStore::DEFAULT_CODER = ActiveSupport::Cache::MemoryStore::DupCoder
+
+module ActiveSupport::Cache::MemoryStore::DupCoder
+  class << self
+    def dump(entry); end
+    def load(entry); end
+  end
+end
+
+ActiveSupport::Cache::MemoryStore::PER_ENTRY_OVERHEAD = T.let(T.unsafe(nil), Integer)
+
+module ActiveSupport::Cache::NullCoder
+  class << self
+    def dump(entry); end
+    def load(payload); end
+  end
+end
+
+class ActiveSupport::Cache::NullStore < ::ActiveSupport::Cache::Store
+  include ::ActiveSupport::Cache::Strategy::LocalCache
+
+  class << self
+    def supports_cache_versioning?; end
+  end
+end
+
+class ActiveSupport::Cache::Store
+  def initialize(options = T.unsafe(nil)); end
+
+  def cleanup(options = T.unsafe(nil)); end
+  def clear(options = T.unsafe(nil)); end
+  def decrement(name, amount = T.unsafe(nil), options = T.unsafe(nil)); end
+  def delete(name, options = T.unsafe(nil)); end
+  def delete_matched(matcher, options = T.unsafe(nil)); end
+  def delete_multi(names, options = T.unsafe(nil)); end
+  def exist?(name, options = T.unsafe(nil)); end
+  def fetch(name, options = T.unsafe(nil), &block); end
+  def fetch_multi(*names); end
+  def increment(name, amount = T.unsafe(nil), options = T.unsafe(nil)); end
+  def logger; end
+  def logger=(val); end
+  def mute; end
+  def options; end
+  def read(name, options = T.unsafe(nil)); end
+  def read_multi(*names); end
+  def silence; end
+  def silence!; end
+  def silence?; end
+  def write(name, value, options = T.unsafe(nil)); end
+  def write_multi(hash, options = T.unsafe(nil)); end
+
+  private
+
+  def delete_entry(key, **options); end
+  def delete_multi_entries(entries, **options); end
+  def deserialize_entry(payload); end
+  def expanded_key(key); end
+  def expanded_version(key); end
+  def get_entry_value(entry, name, options); end
+  def handle_expired_entry(entry, key, options); end
+  def instrument(operation, key, options = T.unsafe(nil)); end
+  def key_matcher(pattern, options); end
+  def merged_options(call_options); end
+  def namespace_key(key, options = T.unsafe(nil)); end
+  def normalize_key(key, options = T.unsafe(nil)); end
+  def normalize_version(key, options = T.unsafe(nil)); end
+  def read_entry(key, **options); end
+  def read_multi_entries(names, **options); end
+  def save_block_result_to_cache(name, options); end
+  def serialize_entry(entry); end
+  def write_entry(key, entry, **options); end
+  def write_multi_entries(hash, **options); end
+
+  class << self
+    def logger; end
+    def logger=(val); end
+
+    private
+
+    def ensure_connection_pool_added!; end
+    def retrieve_pool_options(options); end
+  end
+end
+
+ActiveSupport::Cache::Store::DEFAULT_CODER = Marshal
+module ActiveSupport::Cache::Strategy; end
+
+module ActiveSupport::Cache::Strategy::LocalCache
+  def cleanup(**options); end
+  def clear(**options); end
+  def decrement(name, amount = T.unsafe(nil), **options); end
+  def delete_matched(matcher, options = T.unsafe(nil)); end
+  def increment(name, amount = T.unsafe(nil), **options); end
+  def middleware; end
+  def with_local_cache; end
+
+  private
+
+  def bypass_local_cache; end
+  def delete_entry(key, **options); end
+  def local_cache; end
+  def local_cache_key; end
+  def read_entry(key, **options); end
+  def read_multi_entries(keys, **options); end
+  def use_temporary_local_cache(temporary_cache); end
+  def write_cache_value(name, value, **options); end
+  def write_entry(key, entry, **options); end
+end
+
+class ActiveSupport::Cache::Strategy::LocalCache::LocalCacheRegistry
+  extend ::ActiveSupport::PerThreadRegistry
+
+  def initialize; end
+
+  def cache_for(local_cache_key); end
+  def set_cache_for(local_cache_key, value); end
+
+  class << self
+    def cache_for(l); end
+    def set_cache_for(l, v); end
+  end
+end
+
+class ActiveSupport::Cache::Strategy::LocalCache::LocalStore < ::ActiveSupport::Cache::Store
+  def initialize; end
+
+  def clear(options = T.unsafe(nil)); end
+  def delete_entry(key, **options); end
+  def fetch_entry(key, options = T.unsafe(nil)); end
+  def read_entry(key, **options); end
+  def read_multi_entries(keys, **options); end
+  def synchronize; end
+  def write_entry(key, entry, **options); end
+end
+
+class ActiveSupport::Cache::Strategy::LocalCache::Middleware
+  def initialize(name, local_cache_key); end
+
+  def call(env); end
+  def local_cache_key; end
+  def name; end
+  def new(app); end
+end
+
+ActiveSupport::Cache::UNIVERSAL_OPTIONS = T.let(T.unsafe(nil), Array)
+
+class ActiveSupport::CachingKeyGenerator
+  def initialize(key_generator); end
+
+  def generate_key(*args); end
+end
+
+module ActiveSupport::Callbacks
+  extend ::ActiveSupport::Concern
+
+  mixes_in_class_methods ::ActiveSupport::Callbacks::ClassMethods
+
+  def run_callbacks(kind); end
+
+  private
+
+  def halted_callback_hook(filter, name); end
+end
+
+ActiveSupport::Callbacks::CALLBACK_FILTER_TYPES = T.let(T.unsafe(nil), Array)
+
+class ActiveSupport::Callbacks::CallTemplate
+  def initialize(target, method, arguments, block); end
+
+  def expand(target, value, block); end
+  def inverted_lambda; end
+  def make_lambda; end
+
+  class << self
+    def build(filter, callback); end
+  end
+end
+
+class ActiveSupport::Callbacks::Callback
+  def initialize(name, filter, kind, options, chain_config); end
+
+  def apply(callback_sequence); end
+  def chain_config; end
+  def current_scopes; end
+  def duplicates?(other); end
+  def filter; end
+  def kind; end
+  def kind=(_arg0); end
+  def matches?(_kind, _filter); end
+  def merge_conditional_options(chain, if_option:, unless_option:); end
+  def name; end
+  def name=(_arg0); end
+  def raw_filter; end
+
+  private
+
+  def check_conditionals(conditionals); end
+  def compute_identifier(filter); end
+  def conditions_lambdas; end
+
+  class << self
+    def build(chain, filter, kind, options); end
+  end
+end
+
+ActiveSupport::Callbacks::Callback::EMPTY_ARRAY = T.let(T.unsafe(nil), Array)
+
+class ActiveSupport::Callbacks::CallbackChain
+  include ::Enumerable
+
+  def initialize(name, config); end
+
+  def append(*callbacks); end
+  def clear; end
+  def compile; end
+  def config; end
+  def delete(o); end
+  def each(&block); end
+  def empty?; end
+  def index(o); end
+  def insert(index, o); end
+  def name; end
+  def prepend(*callbacks); end
+
+  protected
+
+  def chain; end
+
+  private
+
+  def append_one(callback); end
+  def default_terminator; end
+  def initialize_copy(other); end
+  def prepend_one(callback); end
+  def remove_duplicates(callback); end
+end
+
+class ActiveSupport::Callbacks::CallbackSequence
+  def initialize(nested = T.unsafe(nil), call_template = T.unsafe(nil), user_conditions = T.unsafe(nil)); end
+
+  def after(&after); end
+  def around(call_template, user_conditions); end
+  def before(&before); end
+  def expand_call_template(arg, block); end
+  def final?; end
+  def invoke_after(arg); end
+  def invoke_before(arg); end
+  def nested; end
+  def skip?(arg); end
+end
+
+module ActiveSupport::Callbacks::ClassMethods
+  def __update_callbacks(name); end
+  def define_callbacks(*names); end
+  def normalize_callback_params(filters, block); end
+  def reset_callbacks(name); end
+  def set_callback(name, *filter_list, &block); end
+  def skip_callback(name, *filter_list, &block); end
+
+  protected
+
+  def get_callbacks(name); end
+  def set_callbacks(name, callbacks); end
+end
+
+module ActiveSupport::Callbacks::Conditionals; end
+
+class ActiveSupport::Callbacks::Conditionals::Value
+  def initialize(&block); end
+
+  def call(target, value); end
+end
+
+module ActiveSupport::Callbacks::Filters; end
+
+class ActiveSupport::Callbacks::Filters::After
+  class << self
+    def build(callback_sequence, user_callback, user_conditions, chain_config); end
+
+    private
+
+    def conditional(callback_sequence, user_callback, user_conditions); end
+    def halting(callback_sequence, user_callback); end
+    def halting_and_conditional(callback_sequence, user_callback, user_conditions); end
+    def simple(callback_sequence, user_callback); end
+  end
+end
+
+class ActiveSupport::Callbacks::Filters::Before
+  class << self
+    def build(callback_sequence, user_callback, user_conditions, chain_config, filter, name); end
+
+    private
+
+    def halting(callback_sequence, user_callback, halted_lambda, filter, name); end
+    def halting_and_conditional(callback_sequence, user_callback, user_conditions, halted_lambda, filter, name); end
+  end
+end
+
+class ActiveSupport::Callbacks::Filters::Environment < ::Struct
+  def halted; end
+  def halted=(_); end
+  def target; end
+  def target=(_); end
+  def value; end
+  def value=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+module ActiveSupport::Concern
+  def append_features(base); end
+  def class_methods(&class_methods_module_definition); end
+  def included(base = T.unsafe(nil), &block); end
+  def prepend_features(base); end
+  def prepended(base = T.unsafe(nil), &block); end
+
+  class << self
+    def extended(base); end
+  end
+end
+
+class ActiveSupport::Concern::MultipleIncludedBlocks < ::StandardError
+  def initialize; end
+end
+
+class ActiveSupport::Concern::MultiplePrependBlocks < ::StandardError
+  def initialize; end
+end
+
+module ActiveSupport::Concurrency; end
+
+class ActiveSupport::Concurrency::ShareLock
+  include ::MonitorMixin
+
+  def initialize; end
+
+  def exclusive(purpose: T.unsafe(nil), compatible: T.unsafe(nil), after_compatible: T.unsafe(nil), no_wait: T.unsafe(nil)); end
+  def raw_state; end
+  def sharing; end
+  def start_exclusive(purpose: T.unsafe(nil), compatible: T.unsafe(nil), no_wait: T.unsafe(nil)); end
+  def start_sharing; end
+  def stop_exclusive(compatible: T.unsafe(nil)); end
+  def stop_sharing; end
+  def yield_shares(purpose: T.unsafe(nil), compatible: T.unsafe(nil), block_share: T.unsafe(nil)); end
+
+  private
+
+  def busy_for_exclusive?(purpose); end
+  def busy_for_sharing?(purpose); end
+  def eligible_waiters?(compatible); end
+  def wait_for(method); end
+end
+
+module ActiveSupport::Configurable
+  extend ::ActiveSupport::Concern
+
+  mixes_in_class_methods ::ActiveSupport::Configurable::ClassMethods
+
+  def config; end
+end
+
+module ActiveSupport::Configurable::ClassMethods
+  def config; end
+  def configure; end
+
+  private
+
+  def config_accessor(*names, instance_reader: T.unsafe(nil), instance_writer: T.unsafe(nil), instance_accessor: T.unsafe(nil)); end
+end
+
+class ActiveSupport::Configurable::Configuration < ::ActiveSupport::InheritableOptions
+  def compile_methods!; end
+
+  class << self
+    def compile_methods!(keys); end
+  end
+end
+
+class ActiveSupport::ConfigurationFile
+  def initialize(content_path); end
+
+  def parse(context: T.unsafe(nil), **options); end
+
+  private
+
+  def read(content_path); end
+  def render(context); end
+
+  class << self
+    def parse(content_path, **options); end
+  end
+end
+
+class ActiveSupport::ConfigurationFile::FormatError < ::StandardError; end
+
+class ActiveSupport::CurrentAttributes
+  include ::ActiveSupport::Callbacks
+  extend ::ActiveSupport::Callbacks::ClassMethods
+  extend ::ActiveSupport::DescendantsTracker
+
+  def initialize; end
+
+  def __callbacks; end
+  def __callbacks?; end
+  def _reset_callbacks; end
+  def _run_reset_callbacks(&block); end
+  def attributes; end
+  def attributes=(_arg0); end
+  def reset; end
+  def set(set_attributes); end
+
+  private
+
+  def assign_attributes(new_attributes); end
+  def compute_attributes(keys); end
+
+  class << self
+    def __callbacks; end
+    def __callbacks=(value); end
+    def __callbacks?; end
+    def _reset_callbacks; end
+    def _reset_callbacks=(value); end
+    def after_reset(&block); end
+    def attribute(*names); end
+    def before_reset(&block); end
+    def clear_all; end
+    def instance; end
+    def reset(*args, &block); end
+    def reset_all; end
+    def resets(&block); end
+    def set(*args, &block); end
+
+    private
+
+    def current_instances; end
+    def current_instances_key; end
+    def generated_attribute_methods; end
+    def method_missing(name, *args, &block); end
+  end
+end
+
+module ActiveSupport::Dependencies
+  extend ::ActiveSupport::Dependencies
+
+  def _eager_load_paths; end
+  def _eager_load_paths=(val); end
+  def autoload_module!(into, const_name, qualified_name, path_suffix); end
+  def autoload_once_paths; end
+  def autoload_once_paths=(val); end
+  def autoload_paths; end
+  def autoload_paths=(val); end
+  def autoloadable_module?(path_suffix); end
+  def autoloaded?(desc); end
+  def autoloaded_constants; end
+  def autoloaded_constants=(val); end
+  def clear; end
+  def constant_watch_stack; end
+  def constant_watch_stack=(val); end
+  def constantize(name); end
+  def depend_on(file_name, message = T.unsafe(nil)); end
+  def explicitly_unloadable_constants; end
+  def explicitly_unloadable_constants=(val); end
+  def history; end
+  def history=(val); end
+  def hook!; end
+  def interlock; end
+  def interlock=(val); end
+  def load?; end
+  def load_file(path, const_paths = T.unsafe(nil)); end
+  def load_missing_constant(from_mod, const_name); end
+  def load_once_path?(path); end
+  def loadable_constants_for_path(path, bases = T.unsafe(nil)); end
+  def loaded; end
+  def loaded=(val); end
+  def loading; end
+  def loading=(val); end
+  def log(message); end
+  def logger; end
+  def logger=(val); end
+  def mark_for_unload(const_desc); end
+  def mechanism; end
+  def mechanism=(val); end
+  def new_constants_in(*descs); end
+  def qualified_const_defined?(path); end
+  def qualified_name_for(mod, name); end
+  def reference(klass); end
+  def remove_constant(const); end
+  def remove_unloadable_constants!; end
+  def require_or_load(file_name, const_path = T.unsafe(nil)); end
+  def safe_constantize(name); end
+  def search_for_file(path_suffix); end
+  def to_constant_name(desc); end
+  def unhook!; end
+  def verbose; end
+  def verbose=(val); end
+  def warnings_on_first_load; end
+  def warnings_on_first_load=(val); end
+  def will_unload?(const_desc); end
+
+  private
+
+  def real_mod_name(mod); end
+  def uninitialized_constant(qualified_name, const_name, receiver:); end
+
+  class << self
+    def _eager_load_paths; end
+    def _eager_load_paths=(val); end
+    def autoload_once_paths; end
+    def autoload_once_paths=(val); end
+    def autoload_paths; end
+    def autoload_paths=(val); end
+    def autoloaded_constants; end
+    def autoloaded_constants=(val); end
+    def constant_watch_stack; end
+    def constant_watch_stack=(val); end
+    def explicitly_unloadable_constants; end
+    def explicitly_unloadable_constants=(val); end
+    def history; end
+    def history=(val); end
+    def interlock; end
+    def interlock=(val); end
+    def load_interlock; end
+    def loaded; end
+    def loaded=(val); end
+    def loading; end
+    def loading=(val); end
+    def logger; end
+    def logger=(val); end
+    def mechanism; end
+    def mechanism=(val); end
+    def run_interlock; end
+    def unload_interlock; end
+    def verbose; end
+    def verbose=(val); end
+    def warnings_on_first_load; end
+    def warnings_on_first_load=(val); end
+  end
+end
+
+module ActiveSupport::Dependencies::Blamable
+  def blame_file!(file); end
+  def blamed_files; end
+  def copy_blame!(exc); end
+  def describe_blame; end
+end
+
+class ActiveSupport::Dependencies::ClassCache
+  def initialize; end
+
+  def [](key); end
+  def clear!; end
+  def empty?; end
+  def get(key); end
+  def key?(key); end
+  def safe_get(key); end
+  def store(klass); end
+end
+
+class ActiveSupport::Dependencies::Interlock
+  def initialize; end
+
+  def done_running; end
+  def done_unloading; end
+  def loading; end
+  def permit_concurrent_loads; end
+  def raw_state(&block); end
+  def running; end
+  def start_running; end
+  def start_unloading; end
+  def unloading; end
+end
+
+module ActiveSupport::Dependencies::Loadable
+  def load_dependency(file); end
+  def require_dependency(file_name, message = T.unsafe(nil)); end
+  def require_or_load(file_name); end
+  def unloadable(const_desc); end
+
+  private
+
+  def load(file, wrap = T.unsafe(nil)); end
+  def require(file); end
+
+  class << self
+    def exclude_from(base); end
+    def include_into(base); end
+  end
+end
+
+module ActiveSupport::Dependencies::ModuleConstMissing
+  def const_missing(const_name); end
+  def guess_for_anonymous(const_name); end
+  def unloadable(const_desc = T.unsafe(nil)); end
+
+  class << self
+    def append_features(base); end
+    def exclude_from(base); end
+    def include_into(base); end
+  end
+end
+
+ActiveSupport::Dependencies::Reference = T.let(T.unsafe(nil), ActiveSupport::Dependencies::ClassCache)
+ActiveSupport::Dependencies::UNBOUND_METHOD_MODULE_NAME = T.let(T.unsafe(nil), UnboundMethod)
+
+class ActiveSupport::Dependencies::WatchStack
+  include ::Enumerable
+
+  def initialize; end
+
+  def each(&block); end
+  def new_constants; end
+  def watch_namespaces(namespaces); end
+  def watching; end
+  def watching?; end
+
+  private
+
+  def pop_modules(modules); end
+end
+
+class ActiveSupport::Deprecation
+  include ::Singleton
+  include ::ActiveSupport::Deprecation::InstanceDelegator
+  include ::ActiveSupport::Deprecation::Behavior
+  include ::ActiveSupport::Deprecation::Reporting
+  include ::ActiveSupport::Deprecation::Disallowed
+  include ::ActiveSupport::Deprecation::MethodWrapper
+  extend ::Singleton::SingletonClassMethods
+  extend ::ActiveSupport::Deprecation::InstanceDelegator::ClassMethods
+  extend ::ActiveSupport::Deprecation::InstanceDelegator::OverrideDelegators
+
+  def initialize(deprecation_horizon = T.unsafe(nil), gem_name = T.unsafe(nil)); end
+
+  def deprecation_horizon; end
+  def deprecation_horizon=(_arg0); end
+
+  class << self
+    def allow(*args, &block); end
+    def behavior(*args, &block); end
+    def behavior=(arg); end
+    def debug(*args, &block); end
+    def debug=(arg); end
+    def deprecate_methods(*args, &block); end
+    def deprecation_horizon(*args, &block); end
+    def deprecation_horizon=(arg); end
+    def disallowed_behavior(*args, &block); end
+    def disallowed_behavior=(arg); end
+    def disallowed_warnings(*args, &block); end
+    def disallowed_warnings=(arg); end
+    def gem_name(*args, &block); end
+    def gem_name=(arg); end
+    def instance; end
+    def silence(*args, &block); end
+    def silenced(*args, &block); end
+    def silenced=(arg); end
+  end
+end
+
+module ActiveSupport::Deprecation::Behavior
+  def behavior; end
+  def behavior=(behavior); end
+  def debug; end
+  def debug=(_arg0); end
+  def disallowed_behavior; end
+  def disallowed_behavior=(behavior); end
+
+  private
+
+  def arity_coerce(behavior); end
+end
+
+ActiveSupport::Deprecation::DEFAULT_BEHAVIORS = T.let(T.unsafe(nil), Hash)
+
+module ActiveSupport::Deprecation::DeprecatedConstantAccessor
+  class << self
+    def included(base); end
+  end
+end
+
+class ActiveSupport::Deprecation::DeprecatedConstantProxy < ::Module
+  def initialize(old_const, new_const, deprecator = T.unsafe(nil), message: T.unsafe(nil)); end
+
+  def class; end
+  def hash(*args, &block); end
+  def inspect; end
+  def instance_methods(*args, &block); end
+  def name(*args, &block); end
+  def respond_to?(*args, &block); end
+
+  private
+
+  def const_missing(name); end
+  def method_missing(called, *args, &block); end
+  def target; end
+
+  class << self
+    def new(*args, **options, &block); end
+  end
+end
+
+class ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy < ::ActiveSupport::Deprecation::DeprecationProxy
+  def initialize(instance, method, var = T.unsafe(nil), deprecator = T.unsafe(nil)); end
+
+  private
+
+  def target; end
+  def warn(callstack, called, args); end
+end
+
+class ActiveSupport::Deprecation::DeprecatedObjectProxy < ::ActiveSupport::Deprecation::DeprecationProxy
+  def initialize(object, message, deprecator = T.unsafe(nil)); end
+
+  private
+
+  def target; end
+  def warn(callstack, called, args); end
+end
+
+class ActiveSupport::Deprecation::DeprecationProxy
+  def inspect; end
+
+  private
+
+  def method_missing(called, *args, &block); end
+
+  class << self
+    def new(*args, &block); end
+  end
+end
+
+module ActiveSupport::Deprecation::Disallowed
+  def disallowed_warnings; end
+  def disallowed_warnings=(_arg0); end
+
+  private
+
+  def deprecation_disallowed?(message); end
+  def explicitly_allowed?(message); end
+end
+
+module ActiveSupport::Deprecation::InstanceDelegator
+  mixes_in_class_methods ::ActiveSupport::Deprecation::InstanceDelegator::OverrideDelegators
+
+  class << self
+    def included(base); end
+  end
+end
+
+module ActiveSupport::Deprecation::InstanceDelegator::ClassMethods
+  def include(included_module); end
+  def method_added(method_name); end
+end
+
+module ActiveSupport::Deprecation::InstanceDelegator::OverrideDelegators
+  def deprecation_warning(deprecated_method_name, message = T.unsafe(nil), caller_backtrace = T.unsafe(nil)); end
+  def warn(message = T.unsafe(nil), callstack = T.unsafe(nil)); end
+end
+
+module ActiveSupport::Deprecation::MethodWrapper
+  def deprecate_methods(target_module, *method_names); end
+end
+
+module ActiveSupport::Deprecation::Reporting
+  def allow(allowed_warnings = T.unsafe(nil), if: T.unsafe(nil), &block); end
+  def deprecation_warning(deprecated_method_name, message = T.unsafe(nil), caller_backtrace = T.unsafe(nil)); end
+  def gem_name; end
+  def gem_name=(_arg0); end
+  def silence(&block); end
+  def silenced; end
+  def silenced=(_arg0); end
+  def warn(message = T.unsafe(nil), callstack = T.unsafe(nil)); end
+
+  private
+
+  def _extract_callstack(callstack); end
+  def deprecated_method_warning(method_name, message = T.unsafe(nil)); end
+  def deprecation_caller_message(callstack); end
+  def deprecation_message(callstack, message = T.unsafe(nil)); end
+  def extract_callstack(callstack); end
+  def ignored_callstack(path); end
+end
+
+ActiveSupport::Deprecation::Reporting::RAILS_GEM_ROOT = T.let(T.unsafe(nil), String)
+class ActiveSupport::DeprecationException < ::StandardError; end
+
+module ActiveSupport::DescendantsTracker
+  def descendants; end
+  def direct_descendants; end
+  def inherited(base); end
+  def subclasses; end
+
+  class << self
+    def clear; end
+    def descendants(klass); end
+    def direct_descendants(klass); end
+    def store_inherited(klass, descendant); end
+    def subclasses(klass); end
+
+    private
+
+    def accumulate_descendants(klass, acc); end
+  end
+end
+
+class ActiveSupport::DescendantsTracker::DescendantsArray
+  include ::Enumerable
+
+  def initialize; end
+
+  def <<(klass); end
+  def cleanup!; end
+  def each; end
+  def refs_size; end
+  def reject!; end
+
+  private
+
+  def initialize_copy(orig); end
+end
+
+class ActiveSupport::Digest
+  class << self
+    def hash_digest_class; end
+    def hash_digest_class=(klass); end
+    def hexdigest(arg); end
+  end
+end
+
+class ActiveSupport::Duration
+  def initialize(value, parts); end
+
+  def %(other); end
+  def *(other); end
+  def +(other); end
+  def +@; end
+  def -(other); end
+  def -@; end
+  def /(other); end
+  def <=>(other); end
+  def ==(other); end
+  def after(time = T.unsafe(nil)); end
+  def ago(time = T.unsafe(nil)); end
+  def as_json(options = T.unsafe(nil)); end
+  def before(time = T.unsafe(nil)); end
+  def coerce(other); end
+  def encode_with(coder); end
+  def eql?(other); end
+  def from_now(time = T.unsafe(nil)); end
+  def hash; end
+  def in_days; end
+  def in_hours; end
+  def in_minutes; end
+  def in_months; end
+  def in_seconds; end
+  def in_weeks; end
+  def in_years; end
+  def init_with(coder); end
+  def inspect; end
+  def instance_of?(klass); end
+  def is_a?(klass); end
+  def iso8601(precision: T.unsafe(nil)); end
+  def kind_of?(klass); end
+  def parts; end
+  def parts=(_arg0); end
+  def since(time = T.unsafe(nil)); end
+  def to_i; end
+  def to_s; end
+  def until(time = T.unsafe(nil)); end
+  def value; end
+  def value=(_arg0); end
+
+  private
+
+  def method_missing(method, *args, &block); end
+  def raise_type_error(other); end
+  def respond_to_missing?(method, _); end
+  def sum(sign, time = T.unsafe(nil)); end
+
+  class << self
+    def ===(other); end
+    def build(value); end
+    def days(value); end
+    def hours(value); end
+    def minutes(value); end
+    def months(value); end
+    def parse(iso8601duration); end
+    def seconds(value); end
+    def weeks(value); end
+    def years(value); end
+
+    private
+
+    def calculate_total_seconds(parts); end
+  end
+end
+
+class ActiveSupport::Duration::ISO8601Parser
+  def initialize(string); end
+
+  def mode; end
+  def mode=(_arg0); end
+  def parse!; end
+  def parts; end
+  def scanner; end
+  def sign; end
+  def sign=(_arg0); end
+
+  private
+
+  def finished?; end
+  def number; end
+  def raise_parsing_error(reason = T.unsafe(nil)); end
+  def scan(pattern); end
+  def validate!; end
+end
+
+ActiveSupport::Duration::ISO8601Parser::COMMA = T.let(T.unsafe(nil), String)
+ActiveSupport::Duration::ISO8601Parser::DATE_COMPONENT = T.let(T.unsafe(nil), Regexp)
+ActiveSupport::Duration::ISO8601Parser::DATE_COMPONENTS = T.let(T.unsafe(nil), Array)
+ActiveSupport::Duration::ISO8601Parser::DATE_MARKER = T.let(T.unsafe(nil), Regexp)
+ActiveSupport::Duration::ISO8601Parser::DATE_TO_PART = T.let(T.unsafe(nil), Hash)
+ActiveSupport::Duration::ISO8601Parser::PERIOD = T.let(T.unsafe(nil), String)
+ActiveSupport::Duration::ISO8601Parser::PERIOD_OR_COMMA = T.let(T.unsafe(nil), Regexp)
+class ActiveSupport::Duration::ISO8601Parser::ParsingError < ::ArgumentError; end
+ActiveSupport::Duration::ISO8601Parser::SIGN_MARKER = T.let(T.unsafe(nil), Regexp)
+ActiveSupport::Duration::ISO8601Parser::TIME_COMPONENT = T.let(T.unsafe(nil), Regexp)
+ActiveSupport::Duration::ISO8601Parser::TIME_COMPONENTS = T.let(T.unsafe(nil), Array)
+ActiveSupport::Duration::ISO8601Parser::TIME_MARKER = T.let(T.unsafe(nil), Regexp)
+ActiveSupport::Duration::ISO8601Parser::TIME_TO_PART = T.let(T.unsafe(nil), Hash)
+
+class ActiveSupport::Duration::ISO8601Serializer
+  def initialize(duration, precision: T.unsafe(nil)); end
+
+  def serialize; end
+
+  private
+
+  def normalize; end
+  def week_mixed_with_date?(parts); end
+end
+
+ActiveSupport::Duration::ISO8601Serializer::DATE_COMPONENTS = T.let(T.unsafe(nil), Array)
+ActiveSupport::Duration::PARTS = T.let(T.unsafe(nil), Array)
+ActiveSupport::Duration::PARTS_IN_SECONDS = T.let(T.unsafe(nil), Hash)
+ActiveSupport::Duration::SECONDS_PER_DAY = T.let(T.unsafe(nil), Integer)
+ActiveSupport::Duration::SECONDS_PER_HOUR = T.let(T.unsafe(nil), Integer)
+ActiveSupport::Duration::SECONDS_PER_MINUTE = T.let(T.unsafe(nil), Integer)
+ActiveSupport::Duration::SECONDS_PER_MONTH = T.let(T.unsafe(nil), Integer)
+ActiveSupport::Duration::SECONDS_PER_WEEK = T.let(T.unsafe(nil), Integer)
+ActiveSupport::Duration::SECONDS_PER_YEAR = T.let(T.unsafe(nil), Integer)
+
+class ActiveSupport::Duration::Scalar < ::Numeric
+  def initialize(value); end
+
+  def %(other); end
+  def *(other); end
+  def +(other); end
+  def -(other); end
+  def -@; end
+  def /(other); end
+  def <=>(other); end
+  def coerce(other); end
+  def to_f(*args, &block); end
+  def to_i(*args, &block); end
+  def to_s(*args, &block); end
+  def value; end
+
+  private
+
+  def calculate(op, other); end
+  def raise_type_error(other); end
+end
+
+class ActiveSupport::EnvironmentInquirer < ::ActiveSupport::StringInquirer
+  def initialize(env); end
+
+  def development?; end
+  def production?; end
+  def test?; end
+end
+
+ActiveSupport::EnvironmentInquirer::DEFAULT_ENVIRONMENTS = T.let(T.unsafe(nil), Array)
+
+class ActiveSupport::ExecutionWrapper
+  include ::ActiveSupport::Callbacks
+  extend ::ActiveSupport::Callbacks::ClassMethods
+  extend ::ActiveSupport::DescendantsTracker
+
+  def __callbacks; end
+  def __callbacks?; end
+  def _complete_callbacks; end
+  def _run_callbacks; end
+  def _run_complete_callbacks(&block); end
+  def _run_run_callbacks(&block); end
+  def complete!; end
+  def run!; end
+
+  private
+
+  def hook_state; end
+
+  class << self
+    def __callbacks; end
+    def __callbacks=(value); end
+    def __callbacks?; end
+    def _complete_callbacks; end
+    def _complete_callbacks=(value); end
+    def _run_callbacks; end
+    def _run_callbacks=(value); end
+    def active; end
+    def active=(_arg0); end
+    def active?; end
+    def inherited(other); end
+    def register_hook(hook, outer: T.unsafe(nil)); end
+    def run!; end
+    def to_complete(*args, &block); end
+    def to_run(*args, &block); end
+    def wrap; end
+  end
+end
+
+class ActiveSupport::ExecutionWrapper::CompleteHook < ::Struct
+  def after(target); end
+  def before(target); end
+  def hook; end
+  def hook=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+ActiveSupport::ExecutionWrapper::Null = T.let(T.unsafe(nil), Object)
+
+class ActiveSupport::ExecutionWrapper::RunHook < ::Struct
+  def before(target); end
+  def hook; end
+  def hook=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class ActiveSupport::Executor < ::ActiveSupport::ExecutionWrapper; end
+
+class ActiveSupport::FileUpdateChecker
+  def initialize(files, dirs = T.unsafe(nil), &block); end
+
+  def execute; end
+  def execute_if_updated; end
+  def updated?; end
+
+  private
+
+  def compile_ext(array); end
+  def compile_glob(hash); end
+  def escape(key); end
+  def max_mtime(paths); end
+  def updated_at(paths); end
+  def watched; end
+end
+
+module ActiveSupport::ForkTracker
+  class << self
+    def after_fork(&block); end
+    def check!; end
+    def hook!; end
+    def unregister(callback); end
+  end
+end
+
+module ActiveSupport::ForkTracker::CoreExt
+  def fork(*_arg0); end
+end
+
+module ActiveSupport::ForkTracker::CoreExtPrivate
+  private
+
+  def fork(*_arg0); end
+end
+
+module ActiveSupport::Gzip
+  class << self
+    def compress(source, level = T.unsafe(nil), strategy = T.unsafe(nil)); end
+    def decompress(source); end
+  end
+end
+
+class ActiveSupport::Gzip::Stream < ::StringIO
+  def initialize(*_arg0); end
+
+  def close; end
+end
+
 module ActiveSupport::Inflector
   extend ::ActiveSupport::Inflector
 
@@ -85,6 +1359,12 @@ class ActiveSupport::Inflector::Inflections::Uncountables < ::Array
   def to_regex(string); end
 end
 
+class ActiveSupport::InheritableOptions < ::ActiveSupport::OrderedOptions
+  def initialize(parent = T.unsafe(nil)); end
+
+  def inheritable_copy; end
+end
+
 module ActiveSupport::JSON
   class << self
     def decode(json); end
@@ -134,6 +1414,12 @@ class ActiveSupport::JSON::Encoding::JSONGemEncoder::EscapedString < ::String
   def to_s; end
 end
 
+class ActiveSupport::KeyGenerator
+  def initialize(secret, options = T.unsafe(nil)); end
+
+  def generate_key(salt, key_size = T.unsafe(nil)); end
+end
+
 module ActiveSupport::LazyLoadHooks
   def on_load(name, options = T.unsafe(nil), &block); end
   def run_load_hooks(name, base = T.unsafe(nil)); end
@@ -148,6 +1434,213 @@ module ActiveSupport::LazyLoadHooks
   end
 end
 
+class ActiveSupport::LogSubscriber < ::ActiveSupport::Subscriber
+  def colorize_logging; end
+  def colorize_logging=(val); end
+  def debug(progname = T.unsafe(nil), &block); end
+  def error(progname = T.unsafe(nil), &block); end
+  def fatal(progname = T.unsafe(nil), &block); end
+  def finish(name, id, payload); end
+  def info(progname = T.unsafe(nil), &block); end
+  def logger; end
+  def start(name, id, payload); end
+  def unknown(progname = T.unsafe(nil), &block); end
+  def warn(progname = T.unsafe(nil), &block); end
+
+  private
+
+  def color(text, color, bold = T.unsafe(nil)); end
+
+  class << self
+    def colorize_logging; end
+    def colorize_logging=(val); end
+    def flush_all!; end
+    def log_subscribers; end
+    def logger; end
+    def logger=(_arg0); end
+
+    private
+
+    def fetch_public_methods(subscriber, inherit_all); end
+  end
+end
+
+ActiveSupport::LogSubscriber::BLACK = T.let(T.unsafe(nil), String)
+ActiveSupport::LogSubscriber::BLUE = T.let(T.unsafe(nil), String)
+ActiveSupport::LogSubscriber::BOLD = T.let(T.unsafe(nil), String)
+ActiveSupport::LogSubscriber::CLEAR = T.let(T.unsafe(nil), String)
+ActiveSupport::LogSubscriber::CYAN = T.let(T.unsafe(nil), String)
+ActiveSupport::LogSubscriber::GREEN = T.let(T.unsafe(nil), String)
+ActiveSupport::LogSubscriber::MAGENTA = T.let(T.unsafe(nil), String)
+ActiveSupport::LogSubscriber::RED = T.let(T.unsafe(nil), String)
+ActiveSupport::LogSubscriber::WHITE = T.let(T.unsafe(nil), String)
+ActiveSupport::LogSubscriber::YELLOW = T.let(T.unsafe(nil), String)
+
+class ActiveSupport::Logger < ::Logger
+  include ::ActiveSupport::LoggerSilence
+  include ::ActiveSupport::LoggerThreadSafeLevel
+
+  def initialize(*args, **kwargs); end
+
+  def silencer; end
+  def silencer=(val); end
+
+  class << self
+    def broadcast(logger); end
+    def local_levels; end
+    def local_levels=(val); end
+    def logger_outputs_to?(logger, *sources); end
+    def silencer; end
+    def silencer=(val); end
+  end
+end
+
+class ActiveSupport::Logger::SimpleFormatter < ::Logger::Formatter
+  def call(severity, timestamp, progname, msg); end
+end
+
+module ActiveSupport::LoggerSilence
+  extend ::ActiveSupport::Concern
+  include ::ActiveSupport::LoggerThreadSafeLevel
+
+  def silence(severity = T.unsafe(nil)); end
+end
+
+module ActiveSupport::LoggerThreadSafeLevel
+  extend ::ActiveSupport::Concern
+
+  def add(severity, message = T.unsafe(nil), progname = T.unsafe(nil), &block); end
+  def debug?; end
+  def error?; end
+  def fatal?; end
+  def info?; end
+  def level; end
+  def local_level; end
+  def local_level=(level); end
+  def local_log_id; end
+  def log_at(level); end
+  def unknown?; end
+  def warn?; end
+end
+
+module ActiveSupport::MarshalWithAutoloading
+  def load(source, proc = T.unsafe(nil)); end
+end
+
+class ActiveSupport::MessageEncryptor
+  include ::ActiveSupport::Messages::Rotator
+  include ::ActiveSupport::Messages::Rotator::Encryptor
+
+  def encrypt_and_sign(value, expires_at: T.unsafe(nil), expires_in: T.unsafe(nil), purpose: T.unsafe(nil)); end
+
+  private
+
+  def _decrypt(encrypted_message, purpose); end
+  def _encrypt(value, **metadata_options); end
+  def aead_mode?; end
+  def new_cipher; end
+  def resolve_verifier; end
+  def verifier; end
+
+  class << self
+    def default_cipher; end
+    def key_len(cipher = T.unsafe(nil)); end
+    def use_authenticated_message_encryption; end
+    def use_authenticated_message_encryption=(val); end
+  end
+end
+
+class ActiveSupport::MessageEncryptor::InvalidMessage < ::StandardError; end
+
+module ActiveSupport::MessageEncryptor::NullSerializer
+  class << self
+    def dump(value); end
+    def load(value); end
+  end
+end
+
+module ActiveSupport::MessageEncryptor::NullVerifier
+  class << self
+    def generate(value); end
+    def verify(value); end
+  end
+end
+
+ActiveSupport::MessageEncryptor::OpenSSLCipherError = OpenSSL::Cipher::CipherError
+
+class ActiveSupport::MessageVerifier
+  include ::ActiveSupport::Messages::Rotator
+  include ::ActiveSupport::Messages::Rotator::Verifier
+
+  def generate(value, expires_at: T.unsafe(nil), expires_in: T.unsafe(nil), purpose: T.unsafe(nil)); end
+  def valid_message?(signed_message); end
+  def verify(*args, **options); end
+
+  private
+
+  def decode(data); end
+  def encode(data); end
+  def generate_digest(data); end
+end
+
+class ActiveSupport::MessageVerifier::InvalidSignature < ::StandardError; end
+module ActiveSupport::Messages; end
+
+class ActiveSupport::Messages::Metadata
+  def initialize(message, expires_at = T.unsafe(nil), purpose = T.unsafe(nil)); end
+
+  def as_json(options = T.unsafe(nil)); end
+  def verify(purpose); end
+
+  private
+
+  def fresh?; end
+  def match?(purpose); end
+  def parse_expires_at(expires_at); end
+
+  class << self
+    def verify(message, purpose); end
+    def wrap(message, expires_at: T.unsafe(nil), expires_in: T.unsafe(nil), purpose: T.unsafe(nil)); end
+
+    private
+
+    def decode(message); end
+    def encode(message); end
+    def extract_metadata(message); end
+    def pick_expiry(expires_at, expires_in); end
+  end
+end
+
+module ActiveSupport::Messages::Rotator
+  def initialize(*secrets, on_rotation: T.unsafe(nil), **options); end
+
+  def rotate(*secrets, **options); end
+
+  private
+
+  def run_rotations(on_rotation); end
+end
+
+module ActiveSupport::Messages::Rotator::Encryptor
+  include ::ActiveSupport::Messages::Rotator
+
+  def decrypt_and_verify(*args, on_rotation: T.unsafe(nil), **options); end
+
+  private
+
+  def build_rotation(secret = T.unsafe(nil), sign_secret = T.unsafe(nil), options); end
+end
+
+module ActiveSupport::Messages::Rotator::Verifier
+  include ::ActiveSupport::Messages::Rotator
+
+  def verified(*args, on_rotation: T.unsafe(nil), **options); end
+
+  private
+
+  def build_rotation(secret = T.unsafe(nil), options); end
+end
+
 module ActiveSupport::Multibyte
   class << self
     def proxy_class; end
@@ -204,6 +1697,952 @@ end
 
 ActiveSupport::Multibyte::Unicode::UNICODE_VERSION = T.let(T.unsafe(nil), String)
 
+module ActiveSupport::Notifications
+  class << self
+    def instrument(name, payload = T.unsafe(nil)); end
+    def instrumenter; end
+    def monotonic_subscribe(pattern = T.unsafe(nil), callback = T.unsafe(nil), &block); end
+    def notifier; end
+    def notifier=(_arg0); end
+    def publish(name, *args); end
+    def subscribe(pattern = T.unsafe(nil), callback = T.unsafe(nil), &block); end
+    def subscribed(callback, pattern = T.unsafe(nil), monotonic: T.unsafe(nil), &block); end
+    def unsubscribe(subscriber_or_name); end
+  end
+end
+
+class ActiveSupport::Notifications::Event
+  def initialize(name, start, ending, transaction_id, payload); end
+
+  def <<(event); end
+  def allocations; end
+  def children; end
+  def cpu_time; end
+  def duration; end
+  def end; end
+  def finish!; end
+  def idle_time; end
+  def name; end
+  def parent_of?(event); end
+  def payload; end
+  def payload=(_arg0); end
+  def start!; end
+  def time; end
+  def transaction_id; end
+
+  private
+
+  def now; end
+  def now_allocations; end
+  def now_cpu; end
+end
+
+class ActiveSupport::Notifications::Fanout
+  include ::Mutex_m
+
+  def initialize; end
+
+  def finish(name, id, payload, listeners = T.unsafe(nil)); end
+  def listeners_for(name); end
+  def listening?(name); end
+  def lock; end
+  def locked?; end
+  def publish(name, *args); end
+  def start(name, id, payload); end
+  def subscribe(pattern = T.unsafe(nil), callable = T.unsafe(nil), monotonic: T.unsafe(nil), &block); end
+  def synchronize(&block); end
+  def try_lock; end
+  def unlock; end
+  def unsubscribe(subscriber_or_name); end
+  def wait; end
+end
+
+module ActiveSupport::Notifications::Fanout::Subscribers
+  class << self
+    def new(pattern, listener, monotonic); end
+    def wrap_all(pattern, subscriber); end
+  end
+end
+
+class ActiveSupport::Notifications::Fanout::Subscribers::AllMessages
+  def initialize(delegate); end
+
+  def finish(name, id, payload); end
+  def matches?(_arg0); end
+  def publish(name, *args); end
+  def start(name, id, payload); end
+  def subscribed_to?(name); end
+  def unsubscribe!(*_arg0); end
+end
+
+class ActiveSupport::Notifications::Fanout::Subscribers::EventObject < ::ActiveSupport::Notifications::Fanout::Subscribers::Evented
+  def finish(name, id, payload); end
+  def start(name, id, payload); end
+
+  private
+
+  def build_event(name, id, payload); end
+end
+
+class ActiveSupport::Notifications::Fanout::Subscribers::Evented
+  def initialize(pattern, delegate); end
+
+  def finish(name, id, payload); end
+  def matches?(name); end
+  def pattern; end
+  def publish(name, *args); end
+  def start(name, id, payload); end
+  def subscribed_to?(name); end
+  def unsubscribe!(name); end
+end
+
+class ActiveSupport::Notifications::Fanout::Subscribers::Matcher
+  def initialize(pattern); end
+
+  def ===(name); end
+  def exclusions; end
+  def pattern; end
+  def unsubscribe!(name); end
+
+  class << self
+    def wrap(pattern); end
+  end
+end
+
+class ActiveSupport::Notifications::Fanout::Subscribers::MonotonicTimed < ::ActiveSupport::Notifications::Fanout::Subscribers::Evented
+  def finish(name, id, payload); end
+  def publish(name, *args); end
+  def start(name, id, payload); end
+end
+
+class ActiveSupport::Notifications::Fanout::Subscribers::Timed < ::ActiveSupport::Notifications::Fanout::Subscribers::Evented
+  def finish(name, id, payload); end
+  def publish(name, *args); end
+  def start(name, id, payload); end
+end
+
+class ActiveSupport::Notifications::InstrumentationRegistry
+  extend ::ActiveSupport::PerThreadRegistry
+
+  def initialize; end
+
+  def instrumenter_for(notifier); end
+end
+
+class ActiveSupport::Notifications::Instrumenter
+  def initialize(notifier); end
+
+  def finish(name, payload); end
+  def finish_with_state(listeners_state, name, payload); end
+  def id; end
+  def instrument(name, payload = T.unsafe(nil)); end
+  def start(name, payload); end
+
+  private
+
+  def unique_id; end
+end
+
+module ActiveSupport::NumberHelper
+  extend ::ActiveSupport::Autoload
+  extend ::ActiveSupport::NumberHelper
+
+  def number_to_currency(number, options = T.unsafe(nil)); end
+  def number_to_delimited(number, options = T.unsafe(nil)); end
+  def number_to_human(number, options = T.unsafe(nil)); end
+  def number_to_human_size(number, options = T.unsafe(nil)); end
+  def number_to_percentage(number, options = T.unsafe(nil)); end
+  def number_to_phone(number, options = T.unsafe(nil)); end
+  def number_to_rounded(number, options = T.unsafe(nil)); end
+end
+
+class ActiveSupport::NumberHelper::NumberConverter
+  def initialize(number, options); end
+
+  def execute; end
+  def namespace; end
+  def namespace=(_arg0); end
+  def namespace?; end
+  def number; end
+  def opts; end
+  def validate_float; end
+  def validate_float=(_arg0); end
+  def validate_float?; end
+
+  private
+
+  def default_format_options; end
+  def default_value(key); end
+  def format_options; end
+  def i18n_format_options; end
+  def options; end
+  def translate_in_locale(key, **i18n_options); end
+  def translate_number_value_with_default(key, **i18n_options); end
+  def valid_float?; end
+
+  class << self
+    def convert(number, options); end
+    def namespace; end
+    def namespace=(value); end
+    def namespace?; end
+    def validate_float; end
+    def validate_float=(value); end
+    def validate_float?; end
+  end
+end
+
+ActiveSupport::NumberHelper::NumberConverter::DEFAULTS = T.let(T.unsafe(nil), Hash)
+
+class ActiveSupport::NumberHelper::NumberToCurrencyConverter < ::ActiveSupport::NumberHelper::NumberConverter
+  def convert; end
+
+  private
+
+  def i18n_opts; end
+  def options; end
+
+  class << self
+    def namespace; end
+  end
+end
+
+class ActiveSupport::NumberHelper::NumberToDelimitedConverter < ::ActiveSupport::NumberHelper::NumberConverter
+  def convert; end
+
+  private
+
+  def delimiter_pattern; end
+  def parts; end
+
+  class << self
+    def validate_float; end
+  end
+end
+
+ActiveSupport::NumberHelper::NumberToDelimitedConverter::DEFAULT_DELIMITER_REGEX = T.let(T.unsafe(nil), Regexp)
+
+class ActiveSupport::NumberHelper::NumberToHumanConverter < ::ActiveSupport::NumberHelper::NumberConverter
+  def convert; end
+
+  private
+
+  def calculate_exponent(units); end
+  def determine_unit(units, exponent); end
+  def format; end
+  def unit_exponents(units); end
+
+  class << self
+    def namespace; end
+    def validate_float; end
+  end
+end
+
+ActiveSupport::NumberHelper::NumberToHumanConverter::DECIMAL_UNITS = T.let(T.unsafe(nil), Hash)
+ActiveSupport::NumberHelper::NumberToHumanConverter::INVERTED_DECIMAL_UNITS = T.let(T.unsafe(nil), Hash)
+
+class ActiveSupport::NumberHelper::NumberToHumanSizeConverter < ::ActiveSupport::NumberHelper::NumberConverter
+  def convert; end
+
+  private
+
+  def base; end
+  def conversion_format; end
+  def exponent; end
+  def smaller_than_base?; end
+  def storage_unit_key; end
+  def unit; end
+
+  class << self
+    def namespace; end
+    def validate_float; end
+  end
+end
+
+ActiveSupport::NumberHelper::NumberToHumanSizeConverter::STORAGE_UNITS = T.let(T.unsafe(nil), Array)
+
+class ActiveSupport::NumberHelper::NumberToPercentageConverter < ::ActiveSupport::NumberHelper::NumberConverter
+  def convert; end
+
+  class << self
+    def namespace; end
+  end
+end
+
+class ActiveSupport::NumberHelper::NumberToPhoneConverter < ::ActiveSupport::NumberHelper::NumberConverter
+  def convert; end
+
+  private
+
+  def convert_to_phone_number(number); end
+  def convert_with_area_code(number); end
+  def convert_without_area_code(number); end
+  def country_code(code); end
+  def delimiter; end
+  def phone_ext(ext); end
+  def regexp_pattern(default_pattern); end
+  def start_with_delimiter?(number); end
+end
+
+class ActiveSupport::NumberHelper::NumberToRoundedConverter < ::ActiveSupport::NumberHelper::NumberConverter
+  def convert; end
+
+  private
+
+  def format_number(number); end
+  def strip_insignificant_zeros; end
+
+  class << self
+    def namespace; end
+    def validate_float; end
+  end
+end
+
+class ActiveSupport::NumberHelper::RoundingHelper
+  def initialize(options); end
+
+  def digit_count(number); end
+  def options; end
+  def round(number); end
+
+  private
+
+  def absolute_precision(number); end
+  def convert_to_decimal(number); end
+  def significant; end
+end
+
+class ActiveSupport::OptionMerger
+  def initialize(context, options); end
+
+  private
+
+  def invoke_method(method, arguments, options, &block); end
+  def method_missing(method, *arguments, &block); end
+end
+
+class ActiveSupport::OrderedHash < ::Hash
+  def encode_with(coder); end
+  def extractable_options?; end
+  def nested_under_indifferent_access; end
+  def reject(*args, &block); end
+  def select(*args, &block); end
+  def to_yaml_type; end
+end
+
+class ActiveSupport::OrderedOptions < ::Hash
+  def [](key); end
+  def []=(key, value); end
+  def extractable_options?; end
+  def inspect; end
+  def method_missing(name, *args); end
+
+  protected
+
+  def _get(_arg0); end
+
+  private
+
+  def respond_to_missing?(name, include_private); end
+end
+
+module ActiveSupport::PerThreadRegistry
+  def instance; end
+
+  private
+
+  def method_missing(name, *args, &block); end
+
+  class << self
+    def extended(object); end
+  end
+end
+
+class ActiveSupport::ProxyObject < ::BasicObject
+  def raise(*args); end
+end
+
+class ActiveSupport::Reloader < ::ActiveSupport::ExecutionWrapper
+  def initialize; end
+
+  def _class_unload_callbacks; end
+  def _prepare_callbacks; end
+  def _run_class_unload_callbacks(&block); end
+  def _run_prepare_callbacks(&block); end
+  def check; end
+  def check=(_arg0); end
+  def check?; end
+  def class_unload!(&block); end
+  def complete!; end
+  def executor; end
+  def executor=(_arg0); end
+  def executor?; end
+  def release_unload_lock!; end
+  def require_unload_lock!; end
+  def run!; end
+
+  class << self
+    def __callbacks; end
+    def _class_unload_callbacks; end
+    def _class_unload_callbacks=(value); end
+    def _prepare_callbacks; end
+    def _prepare_callbacks=(value); end
+    def after_class_unload(*args, &block); end
+    def before_class_unload(*args, &block); end
+    def check; end
+    def check!; end
+    def check=(value); end
+    def check?; end
+    def executor; end
+    def executor=(value); end
+    def executor?; end
+    def prepare!; end
+    def reload!; end
+    def reloaded!; end
+    def run!; end
+    def to_prepare(*args, &block); end
+    def wrap; end
+  end
+end
+
+module ActiveSupport::Rescuable
+  extend ::ActiveSupport::Concern
+
+  mixes_in_class_methods ::ActiveSupport::Rescuable::ClassMethods
+
+  def handler_for_rescue(exception); end
+  def rescue_with_handler(exception); end
+end
+
+module ActiveSupport::Rescuable::ClassMethods
+  def handler_for_rescue(exception, object: T.unsafe(nil)); end
+  def rescue_from(*klasses, with: T.unsafe(nil), &block); end
+  def rescue_with_handler(exception, object: T.unsafe(nil), visited_exceptions: T.unsafe(nil)); end
+
+  private
+
+  def constantize_rescue_handler_class(class_or_name); end
+  def find_rescue_handler(exception); end
+end
+
+class ActiveSupport::SafeBuffer < ::String
+  def initialize(str = T.unsafe(nil)); end
+
+  def %(args); end
+  def *(*_arg0); end
+  def +(other); end
+  def <<(value); end
+  def [](*args); end
+  def []=(*args); end
+  def capitalize(*args, &block); end
+  def capitalize!(*args); end
+  def chomp(*args, &block); end
+  def chomp!(*args); end
+  def chop(*args, &block); end
+  def chop!(*args); end
+  def clone_empty; end
+  def concat(value); end
+  def delete(*args, &block); end
+  def delete!(*args); end
+  def delete_prefix(*args, &block); end
+  def delete_prefix!(*args); end
+  def delete_suffix(*args, &block); end
+  def delete_suffix!(*args); end
+  def downcase(*args, &block); end
+  def downcase!(*args); end
+  def encode_with(coder); end
+  def gsub(*args, &block); end
+  def gsub!(*args, &block); end
+  def html_safe?; end
+  def insert(index, value); end
+  def lstrip(*args, &block); end
+  def lstrip!(*args); end
+  def next(*args, &block); end
+  def next!(*args); end
+  def prepend(value); end
+  def replace(value); end
+  def reverse(*args, &block); end
+  def reverse!(*args); end
+  def rstrip(*args, &block); end
+  def rstrip!(*args); end
+  def safe_concat(value); end
+  def scrub(*args, &block); end
+  def scrub!(*args); end
+  def slice(*args, &block); end
+  def slice!(*args); end
+  def squeeze(*args, &block); end
+  def squeeze!(*args); end
+  def strip(*args, &block); end
+  def strip!(*args); end
+  def sub(*args, &block); end
+  def sub!(*args, &block); end
+  def succ(*args, &block); end
+  def succ!(*args); end
+  def swapcase(*args, &block); end
+  def swapcase!(*args); end
+  def to_param; end
+  def to_s; end
+  def tr(*args, &block); end
+  def tr!(*args); end
+  def tr_s(*args, &block); end
+  def tr_s!(*args); end
+  def unicode_normalize(*args, &block); end
+  def unicode_normalize!(*args); end
+  def upcase(*args, &block); end
+  def upcase!(*args); end
+
+  private
+
+  def html_escape_interpolated_argument(arg); end
+  def initialize_copy(other); end
+  def original_concat(*_arg0); end
+  def set_block_back_references(block, match_data); end
+end
+
+class ActiveSupport::SafeBuffer::SafeConcatError < ::StandardError
+  def initialize; end
+end
+
+ActiveSupport::SafeBuffer::UNSAFE_STRING_METHODS = T.let(T.unsafe(nil), Array)
+ActiveSupport::SafeBuffer::UNSAFE_STRING_METHODS_WITH_BACKREF = T.let(T.unsafe(nil), Array)
+
+class ActiveSupport::SecureCompareRotator
+  include ::ActiveSupport::Messages::Rotator
+  include ::ActiveSupport::SecurityUtils
+
+  def secure_compare!(other_value, on_rotation: T.unsafe(nil)); end
+
+  private
+
+  def build_rotation(previous_value, _options); end
+end
+
+class ActiveSupport::SecureCompareRotator::InvalidMatch < ::StandardError; end
+
+module ActiveSupport::SecurityUtils
+  private
+
+  def fixed_length_secure_compare(a, b); end
+  def secure_compare(a, b); end
+
+  class << self
+    def fixed_length_secure_compare(a, b); end
+    def secure_compare(a, b); end
+  end
+end
+
+class ActiveSupport::StringInquirer < ::String
+  private
+
+  def method_missing(method_name, *arguments); end
+  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
+end
+
+class ActiveSupport::Subscriber
+  def initialize; end
+
+  def finish(name, id, payload); end
+  def patterns; end
+  def start(name, id, payload); end
+
+  private
+
+  def event_stack; end
+
+  class << self
+    def attach_to(namespace, subscriber = T.unsafe(nil), notifier = T.unsafe(nil), inherit_all: T.unsafe(nil)); end
+    def detach_from(namespace, notifier = T.unsafe(nil)); end
+    def method_added(event); end
+    def subscribers; end
+
+    private
+
+    def add_event_subscriber(event); end
+    def fetch_public_methods(subscriber, inherit_all); end
+    def find_attached_subscriber; end
+    def invalid_event?(event); end
+    def namespace; end
+    def notifier; end
+    def pattern_subscribed?(pattern); end
+    def prepare_pattern(event); end
+    def remove_event_subscriber(event); end
+    def subscriber; end
+  end
+end
+
+class ActiveSupport::SubscriberQueueRegistry
+  extend ::ActiveSupport::PerThreadRegistry
+
+  def initialize; end
+
+  def get_queue(queue_key); end
+end
+
+module ActiveSupport::TaggedLogging
+  def clear_tags!(*args, &block); end
+  def flush; end
+  def pop_tags(*args, &block); end
+  def push_tags(*args, &block); end
+  def tagged(*tags); end
+
+  class << self
+    def new(logger); end
+  end
+end
+
+module ActiveSupport::TaggedLogging::Formatter
+  def call(severity, timestamp, progname, msg); end
+  def clear_tags!; end
+  def current_tags; end
+  def pop_tags(size = T.unsafe(nil)); end
+  def push_tags(*tags); end
+  def tagged(*tags); end
+  def tags_text; end
+end
+
+module ActiveSupport::TaggedLogging::LocalTagStorage
+  def current_tags; end
+  def current_tags=(_arg0); end
+
+  class << self
+    def extended(base); end
+  end
+end
+
+class ActiveSupport::TestCase < ::Minitest::Test
+  include ::ActiveSupport::Testing::SetupAndTeardown
+  include ::ActiveSupport::Testing::TaggedLogging
+  include ::ActiveSupport::Callbacks
+  include ::ActiveSupport::Testing::Assertions
+  include ::ActiveSupport::Testing::Deprecation
+  include ::ActiveSupport::Testing::TimeHelpers
+  include ::ActiveSupport::Testing::FileFixtures
+  extend ::ActiveSupport::Callbacks::ClassMethods
+  extend ::ActiveSupport::DescendantsTracker
+  extend ::ActiveSupport::Testing::SetupAndTeardown::ClassMethods
+  extend ::ActiveSupport::Testing::Declarative
+
+  def __callbacks; end
+  def __callbacks?; end
+  def _run_setup_callbacks(&block); end
+  def _run_teardown_callbacks(&block); end
+  def _setup_callbacks; end
+  def _teardown_callbacks; end
+  def assert_no_match(matcher, obj, msg = T.unsafe(nil)); end
+  def assert_not_empty(obj, msg = T.unsafe(nil)); end
+  def assert_not_equal(exp, act, msg = T.unsafe(nil)); end
+  def assert_not_in_delta(exp, act, delta = T.unsafe(nil), msg = T.unsafe(nil)); end
+  def assert_not_in_epsilon(a, b, epsilon = T.unsafe(nil), msg = T.unsafe(nil)); end
+  def assert_not_includes(collection, obj, msg = T.unsafe(nil)); end
+  def assert_not_instance_of(cls, obj, msg = T.unsafe(nil)); end
+  def assert_not_kind_of(cls, obj, msg = T.unsafe(nil)); end
+  def assert_not_nil(obj, msg = T.unsafe(nil)); end
+  def assert_not_operator(o1, op, o2 = T.unsafe(nil), msg = T.unsafe(nil)); end
+  def assert_not_predicate(o1, op, msg = T.unsafe(nil)); end
+  def assert_not_respond_to(obj, meth, msg = T.unsafe(nil)); end
+  def assert_not_same(exp, act, msg = T.unsafe(nil)); end
+  def assert_raise(*exp); end
+  def file_fixture_path; end
+  def file_fixture_path?; end
+  def method_name; end
+
+  class << self
+    def __callbacks; end
+    def __callbacks=(value); end
+    def __callbacks?; end
+    def _setup_callbacks; end
+    def _setup_callbacks=(value); end
+    def _teardown_callbacks; end
+    def _teardown_callbacks=(value); end
+    def file_fixture_path; end
+    def file_fixture_path=(value); end
+    def file_fixture_path?; end
+    def parallelize(workers: T.unsafe(nil), with: T.unsafe(nil)); end
+    def parallelize_setup(&block); end
+    def parallelize_teardown(&block); end
+    def test_order; end
+    def test_order=(new_order); end
+  end
+end
+
+ActiveSupport::TestCase::Assertion = Minitest::Assertion
+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
+  def assert_difference(expression, *args, &block); end
+  def assert_no_changes(expression, message = T.unsafe(nil), &block); end
+  def assert_no_difference(expression, message = T.unsafe(nil), &block); end
+  def assert_not(object, message = T.unsafe(nil)); end
+  def assert_nothing_raised; end
+end
+
+ActiveSupport::Testing::Assertions::UNTRACKED = T.let(T.unsafe(nil), Object)
+
+module ActiveSupport::Testing::ConstantLookup
+  extend ::ActiveSupport::Concern
+
+  mixes_in_class_methods ::ActiveSupport::Testing::ConstantLookup::ClassMethods
+end
+
+module ActiveSupport::Testing::ConstantLookup::ClassMethods
+  def determine_constant_from_test_name(test_name); end
+end
+
+module ActiveSupport::Testing::Declarative
+  def test(name, &block); end
+end
+
+module ActiveSupport::Testing::Deprecation
+  def assert_deprecated(match = T.unsafe(nil), deprecator = T.unsafe(nil), &block); end
+  def assert_not_deprecated(deprecator = T.unsafe(nil), &block); end
+  def collect_deprecations(deprecator = T.unsafe(nil)); end
+end
+
+module ActiveSupport::Testing::FileFixtures
+  extend ::ActiveSupport::Concern
+
+  def file_fixture(fixture_name); end
+end
+
+module ActiveSupport::Testing::Isolation
+  include ::ActiveSupport::Testing::Isolation::Forking
+
+  def run; end
+
+  class << self
+    def forking_env?; end
+    def included(klass); end
+  end
+end
+
+module ActiveSupport::Testing::Isolation::Forking
+  def run_in_isolation(&blk); end
+end
+
+module ActiveSupport::Testing::Isolation::Subprocess
+  def run_in_isolation(&blk); end
+end
+
+ActiveSupport::Testing::Isolation::Subprocess::ORIG_ARGV = T.let(T.unsafe(nil), Array)
+
+class ActiveSupport::Testing::Parallelization
+  def initialize(worker_count); end
+
+  def <<(work); end
+  def after_fork_hooks; end
+  def run_cleanup_hooks; end
+  def shutdown; end
+  def start; end
+
+  class << self
+    def after_fork_hook(&blk); end
+    def after_fork_hooks; end
+    def run_cleanup_hook(&blk); end
+    def run_cleanup_hooks; end
+  end
+end
+
+class ActiveSupport::Testing::Parallelization::Server
+  include ::DRb::DRbUndumped
+
+  def initialize; end
+
+  def <<(o); end
+  def active_workers?; end
+  def pop; end
+  def record(reporter, result); end
+  def shutdown; end
+  def start_worker(worker_id); end
+  def stop_worker(worker_id); end
+end
+
+class ActiveSupport::Testing::Parallelization::Worker
+  def initialize(number, url); end
+
+  def after_fork; end
+  def perform_job(job); end
+  def run_cleanup; end
+  def safe_record(reporter, result); end
+  def start; end
+  def work_from_queue; end
+
+  private
+
+  def add_setup_exception(result); end
+  def set_process_title(status); end
+end
+
+module ActiveSupport::Testing::SetupAndTeardown
+  def after_teardown; end
+  def before_setup; end
+
+  class << self
+    def prepended(klass); end
+  end
+end
+
+module ActiveSupport::Testing::SetupAndTeardown::ClassMethods
+  def setup(*args, &block); end
+  def teardown(*args, &block); end
+end
+
+class ActiveSupport::Testing::SimpleStubs
+  def initialize; end
+
+  def stub_object(object, method_name, &block); end
+  def stubbed?; end
+  def stubbing(object, method_name); end
+  def unstub_all!; end
+
+  private
+
+  def unstub_object(stub); end
+end
+
+class ActiveSupport::Testing::SimpleStubs::Stub < ::Struct
+  def method_name; end
+  def method_name=(_); end
+  def object; end
+  def object=(_); end
+  def original_method; end
+  def original_method=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+module ActiveSupport::Testing::TaggedLogging
+  def before_setup; end
+  def tagged_logger=(_arg0); end
+
+  private
+
+  def tagged_logger; end
+end
+
+module ActiveSupport::Testing::TimeHelpers
+  def after_teardown; end
+  def freeze_time(&block); end
+  def travel(duration, &block); end
+  def travel_back; end
+  def travel_to(date_or_time); end
+  def unfreeze_time; end
+
+  private
+
+  def simple_stubs; end
+end
+
+class ActiveSupport::TimeWithZone
+  include ::DateAndTime::Compatibility
+  include ::Comparable
+
+  def initialize(utc_time, time_zone, local_time = T.unsafe(nil), period = T.unsafe(nil)); end
+
+  def +(other); end
+  def -(other); end
+  def <=>(other); end
+  def acts_like_time?; end
+  def advance(options); end
+  def after?(_arg0); end
+  def ago(other); end
+  def as_json(options = T.unsafe(nil)); end
+  def before?(_arg0); end
+  def between?(min, max); end
+  def blank?; end
+  def change(options); end
+  def comparable_time; end
+  def day; end
+  def dst?; end
+  def encode_with(coder); end
+  def eql?(other); end
+  def formatted_offset(colon = T.unsafe(nil), alternate_utc_string = T.unsafe(nil)); end
+  def freeze; end
+  def future?; end
+  def getgm; end
+  def getlocal(utc_offset = T.unsafe(nil)); end
+  def getutc; end
+  def gmt?; end
+  def gmt_offset; end
+  def gmtime; end
+  def gmtoff; end
+  def hash; end
+  def hour; end
+  def httpdate; end
+  def in(other); end
+  def in_time_zone(new_zone = T.unsafe(nil)); end
+  def init_with(coder); end
+  def inspect; end
+  def is_a?(klass); end
+  def isdst; end
+  def iso8601(fraction_digits = T.unsafe(nil)); end
+  def kind_of?(klass); end
+  def localtime(utc_offset = T.unsafe(nil)); end
+  def marshal_dump; end
+  def marshal_load(variables); end
+  def mday; end
+  def method_missing(sym, *args, &block); end
+  def min; end
+  def mon; end
+  def month; end
+  def next_day?; end
+  def nsec; end
+  def past?; end
+  def period; end
+  def prev_day?; end
+  def respond_to?(sym, include_priv = T.unsafe(nil)); end
+  def rfc2822; end
+  def rfc3339(fraction_digits = T.unsafe(nil)); end
+  def rfc822; end
+  def sec; end
+  def since(other); end
+  def strftime(format); end
+  def time; end
+  def time_zone; end
+  def to_a; end
+  def to_date; end
+  def to_datetime; end
+  def to_f; end
+  def to_formatted_s(format = T.unsafe(nil)); end
+  def to_i; end
+  def to_r; end
+  def to_s(format = T.unsafe(nil)); end
+  def to_time; end
+  def today?; end
+  def tomorrow?; end
+  def tv_sec; end
+  def usec; end
+  def utc; end
+  def utc?; end
+  def utc_offset; end
+  def wday; end
+  def xmlschema(fraction_digits = T.unsafe(nil)); end
+  def yday; end
+  def year; end
+  def yesterday?; end
+  def zone; end
+
+  private
+
+  def duration_of_variable_length?(obj); end
+  def get_period_and_ensure_valid_local_time(period); end
+  def incorporate_utc_offset(time, offset); end
+  def respond_to_missing?(sym, include_priv); end
+  def transfer_time_values_to_utc_constructor(time); end
+  def wrap_with_time_zone(time); end
+
+  class << self
+    def name; end
+  end
+end
+
+ActiveSupport::TimeWithZone::PRECISIONS = T.let(T.unsafe(nil), Hash)
+ActiveSupport::TimeWithZone::SECONDS_PER_DAY = T.let(T.unsafe(nil), Integer)
+
 class ActiveSupport::TimeZone
   include ::Comparable
 
@@ -266,12 +2705,91 @@ module ActiveSupport::ToJsonWithActiveSupportEncoder
   def to_json(options = T.unsafe(nil)); end
 end
 
+module ActiveSupport::Tryable
+  def try(method_name = T.unsafe(nil), *args, &b); end
+  def try!(method_name = T.unsafe(nil), *args, &b); end
+end
+
+module ActiveSupport::VERSION; end
+ActiveSupport::VERSION::MAJOR = T.let(T.unsafe(nil), Integer)
+ActiveSupport::VERSION::MINOR = T.let(T.unsafe(nil), Integer)
+ActiveSupport::VERSION::PRE = T.let(T.unsafe(nil), String)
+ActiveSupport::VERSION::STRING = T.let(T.unsafe(nil), String)
+ActiveSupport::VERSION::TINY = T.let(T.unsafe(nil), Integer)
+
+module ActiveSupport::XmlMini
+  extend ::ActiveSupport::XmlMini
+
+  def backend; end
+  def backend=(name); end
+  def depth; end
+  def depth=(_arg0); end
+  def parse(*args, &block); end
+  def rename_key(key, options = T.unsafe(nil)); end
+  def to_tag(key, value, options); end
+  def with_backend(name); end
+
+  private
+
+  def _dasherize(key); end
+  def _parse_binary(bin, entity); end
+  def _parse_file(file, entity); end
+  def cast_backend_name_to_module(name); end
+  def current_thread_backend; end
+  def current_thread_backend=(name); end
+end
+
+ActiveSupport::XmlMini::DEFAULT_ENCODINGS = T.let(T.unsafe(nil), Hash)
+ActiveSupport::XmlMini::FORMATTING = T.let(T.unsafe(nil), Hash)
+
+module ActiveSupport::XmlMini::FileLike
+  def content_type; end
+  def content_type=(_arg0); end
+  def original_filename; end
+  def original_filename=(_arg0); end
+end
+
+ActiveSupport::XmlMini::PARSING = T.let(T.unsafe(nil), Hash)
+ActiveSupport::XmlMini::TYPE_NAMES = T.let(T.unsafe(nil), Hash)
+
+module ActiveSupport::XmlMini_REXML
+  extend ::ActiveSupport::XmlMini_REXML
+
+  def parse(data); end
+
+  private
+
+  def collapse(element, depth); end
+  def empty_content?(element); end
+  def get_attributes(element); end
+  def merge!(hash, key, value); end
+  def merge_element!(hash, element, depth); end
+  def merge_texts!(hash, element); end
+  def require_rexml; end
+end
+
+ActiveSupport::XmlMini_REXML::CONTENT_KEY = T.let(T.unsafe(nil), String)
+
 class Array
   include ::Enumerable
   include ::JSON::Ext::Generator::GeneratorMethods::Array
   include ::Plist::Emit
+  include ::MessagePack::CoreExt
 
   def as_json(options = T.unsafe(nil)); end
+  def compact_blank!; end
+  def extract_options!; end
+  def sum(init = T.unsafe(nil), &block); end
+  def to_formatted_s(format = T.unsafe(nil)); end
+  def to_param; end
+  def to_query(key); end
+  def to_s(format = T.unsafe(nil)); end
+  def to_sentence(options = T.unsafe(nil)); end
+  def to_xml(options = T.unsafe(nil)); end
+
+  class << self
+    def wrap(object); end
+  end
 end
 
 class BigDecimal < ::Numeric
@@ -283,22 +2801,145 @@ end
 BigDecimal::EXCEPTION_NaN = T.let(T.unsafe(nil), Integer)
 BigDecimal::VERSION = T.let(T.unsafe(nil), String)
 
+class Class < ::Module
+  def class_attribute(*attrs, instance_accessor: T.unsafe(nil), instance_reader: T.unsafe(nil), instance_writer: T.unsafe(nil), instance_predicate: T.unsafe(nil), default: T.unsafe(nil)); end
+end
+
 class Date
   include ::Comparable
   include ::DateAndTime::Zones
+  include ::DateAndTime::Calculations
 
+  def +(other); end
+  def -(other); end
+  def <=>(other); end
+  def acts_like_date?; end
+  def advance(options); end
+  def ago(seconds); end
   def as_json(options = T.unsafe(nil)); end
+  def at_beginning_of_day; end
+  def at_end_of_day; end
+  def at_midday; end
+  def at_middle_of_day; end
+  def at_midnight; end
+  def at_noon; end
+  def beginning_of_day; end
+  def change(options); end
+  def compare_with_coercion(other); end
+  def end_of_day; end
+  def in(seconds); end
   def inspect; end
+  def midday; end
+  def middle_of_day; end
+  def midnight; end
+  def minus_with_duration(other); end
+  def noon; end
+  def plus_with_duration(other); end
   def readable_inspect; end
+  def since(seconds); end
   def to_formatted_s(format = T.unsafe(nil)); end
   def to_s(format = T.unsafe(nil)); end
   def to_time(form = T.unsafe(nil)); end
   def xmlschema; end
+
+  class << self
+    def beginning_of_week; end
+    def beginning_of_week=(week_start); end
+    def beginning_of_week_default; end
+    def beginning_of_week_default=(_arg0); end
+    def current; end
+    def find_beginning_of_week!(week_start); end
+    def tomorrow; end
+    def yesterday; end
+  end
 end
 
 Date::DATE_FORMATS = T.let(T.unsafe(nil), Hash)
 module DateAndTime; end
 
+module DateAndTime::Calculations
+  def after?(date_or_time); end
+  def all_day; end
+  def all_month; end
+  def all_quarter; end
+  def all_week(start_day = T.unsafe(nil)); end
+  def all_year; end
+  def at_beginning_of_month; end
+  def at_beginning_of_quarter; end
+  def at_beginning_of_week(start_day = T.unsafe(nil)); end
+  def at_beginning_of_year; end
+  def at_end_of_month; end
+  def at_end_of_quarter; end
+  def at_end_of_week(start_day = T.unsafe(nil)); end
+  def at_end_of_year; end
+  def before?(date_or_time); end
+  def beginning_of_month; end
+  def beginning_of_quarter; end
+  def beginning_of_week(start_day = T.unsafe(nil)); end
+  def beginning_of_year; end
+  def days_ago(days); end
+  def days_since(days); end
+  def days_to_week_start(start_day = T.unsafe(nil)); end
+  def end_of_month; end
+  def end_of_quarter; end
+  def end_of_week(start_day = T.unsafe(nil)); end
+  def end_of_year; end
+  def future?; end
+  def last_month; end
+  def last_quarter; end
+  def last_week(start_day = T.unsafe(nil), same_time: T.unsafe(nil)); end
+  def last_weekday; end
+  def last_year; end
+  def monday; end
+  def months_ago(months); end
+  def months_since(months); end
+  def next_day?; end
+  def next_occurring(day_of_week); end
+  def next_quarter; end
+  def next_week(given_day_in_next_week = T.unsafe(nil), same_time: T.unsafe(nil)); end
+  def next_weekday; end
+  def on_weekday?; end
+  def on_weekend?; end
+  def past?; end
+  def prev_day?; end
+  def prev_occurring(day_of_week); end
+  def prev_quarter; end
+  def prev_week(start_day = T.unsafe(nil), same_time: T.unsafe(nil)); end
+  def prev_weekday; end
+  def sunday; end
+  def today?; end
+  def tomorrow; end
+  def tomorrow?; end
+  def weeks_ago(weeks); end
+  def weeks_since(weeks); end
+  def years_ago(years); end
+  def years_since(years); end
+  def yesterday; end
+  def yesterday?; end
+
+  private
+
+  def copy_time_to(other); end
+  def days_span(day); end
+  def first_hour(date_or_time); end
+  def last_hour(date_or_time); end
+end
+
+DateAndTime::Calculations::DAYS_INTO_WEEK = T.let(T.unsafe(nil), Hash)
+DateAndTime::Calculations::WEEKEND_DAYS = T.let(T.unsafe(nil), Array)
+
+module DateAndTime::Compatibility
+  def preserve_timezone; end
+  def utc_to_local_returns_utc_offset_times; end
+
+  class << self
+    def preserve_timezone; end
+    def preserve_timezone=(val); end
+    def utc_to_local_returns_utc_offset_times; end
+    def utc_to_local_returns_utc_offset_times=(val); end
+  end
+end
+
 module DateAndTime::Zones
   def in_time_zone(zone = T.unsafe(nil)); end
 
@@ -367,23 +3008,64 @@ class DateTime < ::Date
   end
 end
 
-module Enumerable
-  def as_json(options = T.unsafe(nil)); end
+module ERB::Util
+  private
+
+  def h(s); end
+  def html_escape(s); end
+  def html_escape_once(s); end
+  def json_escape(s); end
+  def unwrapped_html_escape(s); end
+
+  class << self
+    def h(s); end
+    def html_escape(s); end
+    def html_escape_once(s); end
+    def json_escape(s); end
+    def unwrapped_html_escape(s); end
+  end
 end
 
+ERB::Util::HTML_ESCAPE = T.let(T.unsafe(nil), Hash)
+ERB::Util::HTML_ESCAPE_ONCE_REGEXP = T.let(T.unsafe(nil), Regexp)
+ERB::Util::JSON_ESCAPE = T.let(T.unsafe(nil), Hash)
+ERB::Util::JSON_ESCAPE_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+module Enumerable
+  def as_json(options = T.unsafe(nil)); end
+  def compact_blank; end
+  def exclude?(object); end
+  def excluding(*elements); end
+  def including(*elements); end
+  def index_by; end
+  def index_with(default = T.unsafe(nil)); end
+  def many?; end
+  def pick(*keys); end
+  def pluck(*keys); end
+  def sum(identity = T.unsafe(nil), &block); end
+  def without(*elements); end
+end
+
+Enumerable::INDEX_WITH_DEFAULT = T.let(T.unsafe(nil), Object)
+
 class Exception
+  include ::ActiveSupport::Dependencies::Blamable
+
   def as_json(options = T.unsafe(nil)); end
 end
 
 class FalseClass
   include ::JSON::Ext::Generator::GeneratorMethods::FalseClass
+  include ::MessagePack::CoreExt
 
   def as_json(options = T.unsafe(nil)); end
   def blank?; end
+  def to_param; end
 end
 
 class Float < ::Numeric
   include ::JSON::Ext::Generator::GeneratorMethods::Float
+  include ::MessagePack::CoreExt
 
   def as_json(options = T.unsafe(nil)); end
 end
@@ -392,14 +3074,38 @@ class Hash
   include ::Enumerable
   include ::JSON::Ext::Generator::GeneratorMethods::Hash
   include ::Plist::Emit
+  include ::MessagePack::CoreExt
 
   def as_json(options = T.unsafe(nil)); end
+  def assert_valid_keys(*valid_keys); end
+  def compact_blank; end
+  def compact_blank!; end
   def deep_merge(other_hash, &block); end
   def deep_merge!(other_hash, &block); end
+  def deep_stringify_keys; end
+  def deep_stringify_keys!; end
+  def deep_symbolize_keys; end
+  def deep_symbolize_keys!; end
+  def deep_transform_keys(&block); end
+  def deep_transform_keys!(&block); end
   def except(*keys); end
   def except!(*keys); end
   def extract!(*keys); end
+  def extractable_options?; end
   def slice!(*keys); end
+  def stringify_keys; end
+  def stringify_keys!; end
+  def symbolize_keys; end
+  def symbolize_keys!; end
+  def to_options; end
+  def to_options!; end
+  def to_param(namespace = T.unsafe(nil)); end
+  def to_query(namespace = T.unsafe(nil)); end
+
+  private
+
+  def _deep_transform_keys_in_object(object, &block); end
+  def _deep_transform_keys_in_object!(object, &block); end
 end
 
 class IO
@@ -434,18 +3140,50 @@ class IPAddr
   def as_json(options = T.unsafe(nil)); end
 end
 
+module Kernel
+  extend ::Forwardable
+
+  private
+
+  def enable_warnings; end
+  def silence_warnings; end
+  def suppress(*exception_classes); end
+  def with_warnings(flag); end
+
+  class << self
+    def enable_warnings; end
+    def silence_warnings; end
+    def suppress(*exception_classes); end
+    def with_warnings(flag); end
+  end
+end
+
+class LoadError < ::ScriptError
+  def is_missing?(location); end
+end
+
 class Module
+  include ::ActiveSupport::Dependencies::ModuleConstMissing
+
+  def alias_attribute(new_name, old_name); end
+  def anonymous?; end
   def cattr_accessor(*syms, instance_reader: T.unsafe(nil), instance_writer: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), &blk); end
   def cattr_reader(*syms, instance_reader: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), location: T.unsafe(nil)); end
   def cattr_writer(*syms, instance_writer: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), location: T.unsafe(nil)); end
   def delegate(*methods, to: T.unsafe(nil), prefix: T.unsafe(nil), allow_nil: T.unsafe(nil), private: T.unsafe(nil)); end
   def delegate_missing_to(target, allow_nil: T.unsafe(nil)); end
+  def deprecate(*method_names); end
   def mattr_accessor(*syms, instance_reader: T.unsafe(nil), instance_writer: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), &blk); end
   def mattr_reader(*syms, instance_reader: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), location: T.unsafe(nil)); end
   def mattr_writer(*syms, instance_writer: T.unsafe(nil), instance_accessor: T.unsafe(nil), default: T.unsafe(nil), location: T.unsafe(nil)); end
   def method_visibility(method); end
+  def module_parent; end
+  def module_parent_name; end
+  def module_parents; end
   def redefine_method(method, &block); end
   def redefine_singleton_method(method, &block); end
+  def remove_possible_method(method); end
+  def remove_possible_singleton_method(method); end
   def silence_redefinition_of_method(method); end
 end
 
@@ -456,13 +3194,26 @@ Module::RUBY_RESERVED_KEYWORDS = T.let(T.unsafe(nil), Array)
 
 class NameError < ::StandardError
   include ::DidYouMean::Correctable
+
+  def missing_name; end
+  def missing_name?(name); end
+
+  private
+
+  def real_mod_name(mod); end
 end
 
+NameError::UNBOUND_METHOD_MODULE_NAME = T.let(T.unsafe(nil), UnboundMethod)
+
 class NilClass
   include ::JSON::Ext::Generator::GeneratorMethods::NilClass
+  include ::MessagePack::CoreExt
 
   def as_json(options = T.unsafe(nil)); end
   def blank?; end
+  def to_param; end
+  def try(_method_name = T.unsafe(nil), *_arg1); end
+  def try!(_method_name = T.unsafe(nil), *_arg1); end
 end
 
 class Numeric
@@ -470,20 +3221,63 @@ class Numeric
 
   def as_json(options = T.unsafe(nil)); end
   def blank?; end
+  def byte; end
+  def bytes; end
+  def day; end
+  def days; end
+  def exabyte; end
+  def exabytes; end
+  def fortnight; end
+  def fortnights; end
+  def gigabyte; end
+  def gigabytes; end
+  def hour; end
+  def hours; end
+  def html_safe?; end
+  def in_milliseconds; end
+  def kilobyte; end
+  def kilobytes; end
+  def megabyte; end
+  def megabytes; end
+  def minute; end
+  def minutes; end
+  def petabyte; end
+  def petabytes; end
+  def second; end
+  def seconds; end
+  def terabyte; end
+  def terabytes; end
+  def week; end
+  def weeks; end
 end
 
+Numeric::EXABYTE = T.let(T.unsafe(nil), Integer)
+Numeric::GIGABYTE = T.let(T.unsafe(nil), Integer)
+Numeric::KILOBYTE = T.let(T.unsafe(nil), Integer)
+Numeric::MEGABYTE = T.let(T.unsafe(nil), Integer)
+Numeric::PETABYTE = T.let(T.unsafe(nil), Integer)
+Numeric::TERABYTE = T.let(T.unsafe(nil), Integer)
+
 class Object < ::BasicObject
+  include ::ActiveSupport::ForkTracker::CoreExt
+  include ::ActiveSupport::ForkTracker::CoreExtPrivate
   include ::ActiveSupport::ToJsonWithActiveSupportEncoder
   include ::Kernel
   include ::JSON::Ext::Generator::GeneratorMethods::Object
   include ::PP::ObjectMixin
+  include ::ActiveSupport::Tryable
+  include ::ActiveSupport::Dependencies::Loadable
 
+  def acts_like?(duck); end
   def as_json(options = T.unsafe(nil)); end
   def blank?; end
+  def html_safe?; end
   def instance_values; end
   def instance_variable_names; end
   def presence; end
   def present?; end
+  def to_param; end
+  def to_query(key); end
 end
 
 class Pathname
@@ -498,6 +3292,7 @@ class Range
   include ::Enumerable
 
   def as_json(options = T.unsafe(nil)); end
+  def sum(identity = T.unsafe(nil)); end
 end
 
 class Regexp
@@ -542,6 +3337,7 @@ class String
   include ::Comparable
   include ::JSON::Ext::Generator::GeneratorMethods::String
   include ::Colorize::InstanceMethods
+  include ::MessagePack::CoreExt
   extend ::JSON::Ext::Generator::GeneratorMethods::String::Extend
   extend ::Colorize::ClassMethods
 
@@ -559,18 +3355,29 @@ class String
   def first(limit = T.unsafe(nil)); end
   def foreign_key(separate_class_name_and_id_with_underscore = T.unsafe(nil)); end
   def from(position); end
+  def html_safe; end
   def humanize(capitalize: T.unsafe(nil), keep_id_suffix: T.unsafe(nil)); end
   def is_utf8?; end
   def last(limit = T.unsafe(nil)); end
   def mb_chars; end
   def parameterize(separator: T.unsafe(nil), preserve_case: T.unsafe(nil), locale: T.unsafe(nil)); end
   def pluralize(count = T.unsafe(nil), locale = T.unsafe(nil)); end
+  def remove(*patterns); end
+  def remove!(*patterns); end
   def safe_constantize; end
   def singularize(locale = T.unsafe(nil)); end
+  def squish; end
+  def squish!; end
   def tableize; end
   def titlecase(keep_id_suffix: T.unsafe(nil)); end
   def titleize(keep_id_suffix: T.unsafe(nil)); end
   def to(position); end
+  def to_date; end
+  def to_datetime; end
+  def to_time(form = T.unsafe(nil)); end
+  def truncate(truncate_at, options = T.unsafe(nil)); end
+  def truncate_bytes(truncate_at, omission: T.unsafe(nil)); end
+  def truncate_words(words_count, options = T.unsafe(nil)); end
 
   sig { returns(String) }
   def underscore; end
@@ -594,6 +3401,7 @@ Struct::Tms = Process::Tms
 
 class Symbol
   include ::Comparable
+  include ::MessagePack::CoreExt
 
   def as_json(options = T.unsafe(nil)); end
   def end_with?(*suffixes); end
@@ -604,55 +3412,95 @@ end
 
 class Time
   include ::Comparable
+  include ::DateAndTime::Zones
+  include ::DateAndTime::Calculations
 
+  def +(other); end
+  def -(other); end
+  def <=>(other); end
+  def acts_like_time?; end
+  def advance(options); end
+  def ago(seconds); end
   def as_json(options = T.unsafe(nil)); end
+  def at_beginning_of_day; end
+  def at_beginning_of_hour; end
+  def at_beginning_of_minute; end
+  def at_end_of_day; end
+  def at_end_of_hour; end
+  def at_end_of_minute; end
+  def at_midday; end
+  def at_middle_of_day; end
+  def at_midnight; end
+  def at_noon; end
+  def beginning_of_day; end
+  def beginning_of_hour; end
+  def beginning_of_minute; end
   def blank?; end
+  def ceil(precision = T.unsafe(nil)); end
+  def change(options); end
+  def compare_with_coercion(other); end
+  def end_of_day; end
+  def end_of_hour; end
+  def end_of_minute; end
+  def eql?(other); end
+  def eql_with_coercion(other); end
+  def floor(precision = T.unsafe(nil)); end
   def formatted_offset(colon = T.unsafe(nil), alternate_utc_string = T.unsafe(nil)); end
+  def in(seconds); end
+  def midday; end
+  def middle_of_day; end
+  def midnight; end
+  def minus_with_coercion(other); end
+  def minus_with_duration(other); end
+  def minus_without_coercion(other); end
+  def next_day(days = T.unsafe(nil)); end
+  def next_month(months = T.unsafe(nil)); end
+  def next_year(years = T.unsafe(nil)); end
+  def noon; end
+  def plus_with_duration(other); end
+  def prev_day(days = T.unsafe(nil)); end
+  def prev_month(months = T.unsafe(nil)); end
+  def prev_year(years = T.unsafe(nil)); end
+  def sec_fraction; end
+  def seconds_since_midnight; end
+  def seconds_until_end_of_day; end
+  def since(seconds); end
   def to_formatted_s(format = T.unsafe(nil)); end
   def to_s(format = T.unsafe(nil)); end
+
+  class << self
+    def ===(other); end
+    def at(*args); end
+    def at_with_coercion(*args); end
+    def current; end
+    def days_in_month(month, year = T.unsafe(nil)); end
+    def days_in_year(year = T.unsafe(nil)); end
+    def find_zone(time_zone); end
+    def find_zone!(time_zone); end
+    def rfc3339(str); end
+    def use_zone(time_zone); end
+    def zone; end
+    def zone=(time_zone); end
+    def zone_default; end
+    def zone_default=(_arg0); end
+  end
 end
 
+Time::COMMON_YEAR_DAYS_IN_MONTH = T.let(T.unsafe(nil), Array)
 Time::DATE_FORMATS = T.let(T.unsafe(nil), Hash)
 
 class TrueClass
   include ::JSON::Ext::Generator::GeneratorMethods::TrueClass
+  include ::MessagePack::CoreExt
 
   def as_json(options = T.unsafe(nil)); end
   def blank?; end
+  def to_param; end
 end
 
-module URI
-  include ::URI::RFC2396_REGEXP
-  extend ::URI::Escape
-end
-
-class URI::File < ::URI::Generic
-  def check_password(user); end
-  def check_user(user); end
-  def check_userinfo(user); end
-  def set_host(v); end
-  def set_password(v); end
-  def set_port(v); end
-  def set_user(v); end
-  def set_userinfo(v); end
-
-  class << self
-    def build(args); end
-  end
-end
-
-URI::File::COMPONENT = T.let(T.unsafe(nil), Array)
-
 class URI::Generic
   include ::URI::RFC2396_REGEXP
   include ::URI
 
   def as_json(options = T.unsafe(nil)); end
 end
-
-URI::Parser = URI::RFC2396_Parser
-URI::REGEXP = URI::RFC2396_REGEXP
-
-class URI::RFC2396_Parser
-  include ::URI::RFC2396_REGEXP
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/addressable@2.8.0.rbi b/Library/Homebrew/sorbet/rbi/gems/addressable@2.8.0.rbi
index 0856e79e4d..71cf5d7118 100644
--- a/Library/Homebrew/sorbet/rbi/gems/addressable@2.8.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/addressable@2.8.0.rbi
@@ -73,6 +73,72 @@ Addressable::IDNA::UNICODE_TABLE = T.let(T.unsafe(nil), String)
 Addressable::IDNA::UTF8_REGEX = T.let(T.unsafe(nil), Regexp)
 Addressable::IDNA::UTF8_REGEX_MULTIBYTE = T.let(T.unsafe(nil), Regexp)
 
+class Addressable::Template
+  def initialize(pattern); end
+
+  def ==(template); end
+  def eql?(template); end
+  def expand(mapping, processor = T.unsafe(nil), normalize_values = T.unsafe(nil)); end
+  def extract(uri, processor = T.unsafe(nil)); end
+  def freeze; end
+  def inspect; end
+  def keys; end
+  def match(uri, processor = T.unsafe(nil)); end
+  def named_captures; end
+  def names; end
+  def partial_expand(mapping, processor = T.unsafe(nil), normalize_values = T.unsafe(nil)); end
+  def pattern; end
+  def source; end
+  def to_regexp; end
+  def variable_defaults; end
+  def variables; end
+
+  private
+
+  def join_values(operator, return_value); end
+  def normalize_keys(mapping); end
+  def normalize_value(value); end
+  def ordered_variable_defaults; end
+  def parse_new_template_pattern(pattern, processor = T.unsafe(nil)); end
+  def parse_template_pattern(pattern, processor = T.unsafe(nil)); end
+  def transform_capture(mapping, capture, processor = T.unsafe(nil), normalize_values = T.unsafe(nil)); end
+  def transform_partial_capture(mapping, capture, processor = T.unsafe(nil), normalize_values = T.unsafe(nil)); end
+end
+
+Addressable::Template::EXPRESSION = T.let(T.unsafe(nil), Regexp)
+class Addressable::Template::InvalidTemplateOperatorError < ::StandardError; end
+class Addressable::Template::InvalidTemplateValueError < ::StandardError; end
+Addressable::Template::JOINERS = T.let(T.unsafe(nil), Hash)
+Addressable::Template::LEADERS = T.let(T.unsafe(nil), Hash)
+
+class Addressable::Template::MatchData
+  def initialize(uri, template, mapping); end
+
+  def [](key, len = T.unsafe(nil)); end
+  def captures; end
+  def inspect; end
+  def keys; end
+  def mapping; end
+  def names; end
+  def post_match; end
+  def pre_match; end
+  def string; end
+  def template; end
+  def to_a; end
+  def to_s; end
+  def uri; end
+  def values; end
+  def values_at(*indexes); end
+  def variables; end
+end
+
+Addressable::Template::RESERVED = T.let(T.unsafe(nil), String)
+class Addressable::Template::TemplateOperatorAbortedError < ::StandardError; end
+Addressable::Template::UNRESERVED = T.let(T.unsafe(nil), String)
+Addressable::Template::VARIABLE_LIST = T.let(T.unsafe(nil), Regexp)
+Addressable::Template::VARNAME = T.let(T.unsafe(nil), Regexp)
+Addressable::Template::VARSPEC = T.let(T.unsafe(nil), Regexp)
+
 class Addressable::URI
   def initialize(options = T.unsafe(nil)); end
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/ast@2.4.2.rbi b/Library/Homebrew/sorbet/rbi/gems/ast@2.4.2.rbi
index a2027d19c8..05bb18902d 100644
--- a/Library/Homebrew/sorbet/rbi/gems/ast@2.4.2.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/ast@2.4.2.rbi
@@ -1,11 +1,10 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `ast` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-module AST
-end
+module AST; end
 
 class AST::Node
   def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
@@ -41,7 +40,7 @@ class AST::Node
 end
 
 class AST::Processor
-  include(::AST::Processor::Mixin)
+  include ::AST::Processor::Mixin
 end
 
 module AST::Processor::Mixin
diff --git a/Library/Homebrew/sorbet/rbi/gems/bootsnap@1.8.1.rbi b/Library/Homebrew/sorbet/rbi/gems/bootsnap@1.8.1.rbi
index be565398bd..331cab5eef 100644
--- a/Library/Homebrew/sorbet/rbi/gems/bootsnap@1.8.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/bootsnap@1.8.1.rbi
@@ -4,5 +4,214 @@
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module Bootsnap
+  extend ::Bootsnap
+
+  def bundler?; end
+
+  class << self
+    def _instrument(event, path); end
+    def default_setup; end
+    def instrumentation=(callback); end
+    def iseq_cache_supported?; end
+    def log!; end
+    def logger; end
+    def logger=(logger); end
+    def setup(cache_dir:, development_mode: T.unsafe(nil), load_path_cache: T.unsafe(nil), autoload_paths_cache: T.unsafe(nil), disable_trace: T.unsafe(nil), compile_cache_iseq: T.unsafe(nil), compile_cache_yaml: T.unsafe(nil)); end
+  end
+end
+
+module Bootsnap::CompileCache
+  class << self
+    def permission_error(path); end
+    def setup(cache_dir:, iseq:, yaml:); end
+    def supported?; end
+  end
+end
+
+class Bootsnap::CompileCache::Error < ::StandardError; end
+class Bootsnap::CompileCache::PermissionError < ::Bootsnap::CompileCache::Error; end
+
+module Bootsnap::ExplicitRequire
+  class << self
+    def from_archdir(feature); end
+    def from_rubylibdir(feature); end
+    def from_self(feature); end
+    def with_gems(*gems); end
+  end
+end
+
+Bootsnap::ExplicitRequire::ARCHDIR = T.let(T.unsafe(nil), String)
+Bootsnap::ExplicitRequire::DLEXT = T.let(T.unsafe(nil), String)
+Bootsnap::ExplicitRequire::RUBYLIBDIR = T.let(T.unsafe(nil), String)
+class Bootsnap::InvalidConfiguration < ::StandardError; end
+
+module Bootsnap::LoadPathCache
+  class << self
+    def load_path_cache; end
+    def loaded_features_index; end
+    def realpath_cache; end
+    def setup(cache_path:, development_mode:); end
+    def supported?; end
+  end
+end
+
+Bootsnap::LoadPathCache::CACHED_EXTENSIONS = T.let(T.unsafe(nil), Array)
+
+class Bootsnap::LoadPathCache::Cache
+  def initialize(store, path_obj, development_mode: T.unsafe(nil)); end
+
+  def absolute_path?(path); end
+  def find(feature); end
+  def load_dir(dir); end
+  def push_paths(sender, *paths); end
+  def reinitialize(path_obj = T.unsafe(nil)); end
+  def unshift_paths(sender, *paths); end
+
+  private
+
+  def dir_changed?; end
+  def expand_path(feature); end
+  def maybe_append_extension(f); end
+  def now; end
+  def push_paths_locked(*paths); end
+  def search_index(f); end
+  def stale?; end
+  def try_ext(f); end
+  def try_index(f); end
+  def unshift_paths_locked(*paths); end
+end
+
+Bootsnap::LoadPathCache::Cache::AGE_THRESHOLD = T.let(T.unsafe(nil), Integer)
+Bootsnap::LoadPathCache::Cache::BUILTIN_FEATURES = T.let(T.unsafe(nil), Hash)
+
+module Bootsnap::LoadPathCache::ChangeObserver
+  class << self
+    def register(observer, arr); end
+  end
+end
+
+module Bootsnap::LoadPathCache::ChangeObserver::ArrayMixin
+  def <<(entry); end
+  def []=(*args, &block); end
+  def append(*entries); end
+  def clear(*args, &block); end
+  def collect!(*args, &block); end
+  def compact!(*args, &block); end
+  def concat(entries); end
+  def delete(*args, &block); end
+  def delete_at(*args, &block); end
+  def delete_if(*args, &block); end
+  def fill(*args, &block); end
+  def flatten!(*args, &block); end
+  def insert(*args, &block); end
+  def keep_if(*args, &block); end
+  def map!(*args, &block); end
+  def pop(*args, &block); end
+  def prepend(*entries); end
+  def push(*entries); end
+  def reject!(*args, &block); end
+  def replace(*args, &block); end
+  def reverse!(*args, &block); end
+  def rotate!(*args, &block); end
+  def select!(*args, &block); end
+  def shift(*args, &block); end
+  def shuffle!(*args, &block); end
+  def slice!(*args, &block); end
+  def sort!(*args, &block); end
+  def sort_by!(*args, &block); end
+  def uniq!(*args); end
+  def unshift(*entries); end
+end
+
+Bootsnap::LoadPathCache::DLEXT = T.let(T.unsafe(nil), String)
+Bootsnap::LoadPathCache::DL_EXTENSIONS = T.let(T.unsafe(nil), Array)
+Bootsnap::LoadPathCache::DOT_RB = T.let(T.unsafe(nil), String)
+Bootsnap::LoadPathCache::DOT_SO = T.let(T.unsafe(nil), String)
+Bootsnap::LoadPathCache::ERROR_TAG_IVAR = T.let(T.unsafe(nil), Symbol)
+class Bootsnap::LoadPathCache::FallbackScan < ::StandardError; end
+
+class Bootsnap::LoadPathCache::LoadedFeaturesIndex
+  def initialize; end
+
+  def key?(feature); end
+  def purge(feature); end
+  def purge_multi(features); end
+  def register(short, long = T.unsafe(nil)); end
+
+  private
+
+  def extension_elidable?(f); end
+  def strip_extension_if_elidable(f); end
+end
+
+Bootsnap::LoadPathCache::LoadedFeaturesIndex::STRIP_EXTENSION = T.let(T.unsafe(nil), Regexp)
+
+class Bootsnap::LoadPathCache::Path
+  def initialize(path); end
+
+  def entries_and_dirs(store); end
+  def expanded_path; end
+  def non_directory?; end
+  def path; end
+  def relative?; end
+  def stable?; end
+  def volatile?; end
+
+  private
+
+  def latest_mtime(path, dirs); end
+  def scan!; end
+  def stability; end
+end
+
+Bootsnap::LoadPathCache::Path::RUBY_LIBDIR = T.let(T.unsafe(nil), String)
+Bootsnap::LoadPathCache::Path::RUBY_SITEDIR = T.let(T.unsafe(nil), String)
+Bootsnap::LoadPathCache::Path::STABLE = T.let(T.unsafe(nil), Symbol)
+Bootsnap::LoadPathCache::Path::VOLATILE = T.let(T.unsafe(nil), Symbol)
+
+module Bootsnap::LoadPathCache::PathScanner
+  class << self
+    def call(path); end
+    def os_path(path); end
+    def walk(absolute_dir_path, relative_dir_path, &block); end
+  end
+end
+
+Bootsnap::LoadPathCache::PathScanner::ALTERNATIVE_NATIVE_EXTENSIONS_PATTERN = T.let(T.unsafe(nil), Regexp)
+Bootsnap::LoadPathCache::PathScanner::BUNDLE_PATH = T.let(T.unsafe(nil), String)
+Bootsnap::LoadPathCache::PathScanner::NORMALIZE_NATIVE_EXTENSIONS = T.let(T.unsafe(nil), TrueClass)
+Bootsnap::LoadPathCache::PathScanner::REQUIRABLE_EXTENSIONS = T.let(T.unsafe(nil), Array)
+
+class Bootsnap::LoadPathCache::RealpathCache
+  def initialize; end
+
+  def call(*key); end
+
+  private
+
+  def find_file(name); end
+  def realpath(caller_location, path); end
+end
+
+class Bootsnap::LoadPathCache::ReturnFalse < ::StandardError; end
+Bootsnap::LoadPathCache::SLASH = T.let(T.unsafe(nil), String)
+
+class Bootsnap::LoadPathCache::Store
+  def initialize(store_path); end
+
+  def fetch(key); end
+  def get(key); end
+  def set(key, value); end
+  def transaction; end
+
+  private
+
+  def commit_transaction; end
+  def dump_data; end
+  def load_data; end
+end
+
+class Bootsnap::LoadPathCache::Store::NestedTransactionError < ::StandardError; end
+class Bootsnap::LoadPathCache::Store::SetOutsideTransactionNotAllowed < ::StandardError; end
+Bootsnap::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/byebug@11.1.3.rbi b/Library/Homebrew/sorbet/rbi/gems/byebug@11.1.3.rbi
index 76f1693fdc..d729b91410 100644
--- a/Library/Homebrew/sorbet/rbi/gems/byebug@11.1.3.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/byebug@11.1.3.rbi
@@ -1,6 +1,6 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `byebug` gem.
-# Please instead update this file by running `tapioca generate --exclude json`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
@@ -12,6 +12,8 @@ module Byebug
 end
 
 module Kernel
+  extend ::Forwardable
+
   def byebug; end
   def debugger; end
   def remote_byebug(host = T.unsafe(nil), port = T.unsafe(nil)); end
diff --git a/Library/Homebrew/sorbet/rbi/gems/coderay@1.1.3.rbi b/Library/Homebrew/sorbet/rbi/gems/coderay@1.1.3.rbi
index e4f321bd91..453dd04791 100644
--- a/Library/Homebrew/sorbet/rbi/gems/coderay@1.1.3.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/coderay@1.1.3.rbi
@@ -1,7 +1,1005 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `coderay` gem.
-# Please instead update this file by running `tapioca generate --exclude json`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
+module CodeRay
+  class << self
+    def coderay_path(*path); end
+    def encode(code, lang, format, options = T.unsafe(nil)); end
+    def encode_file(filename, format, options = T.unsafe(nil)); end
+    def encode_tokens(tokens, format, options = T.unsafe(nil)); end
+    def encoder(format, options = T.unsafe(nil)); end
+    def get_scanner_options(options); end
+    def highlight(code, lang, options = T.unsafe(nil), format = T.unsafe(nil)); end
+    def highlight_file(filename, options = T.unsafe(nil), format = T.unsafe(nil)); end
+    def scan(code, lang, options = T.unsafe(nil), &block); end
+    def scan_file(filename, lang = T.unsafe(nil), options = T.unsafe(nil), &block); end
+    def scanner(lang, options = T.unsafe(nil), &block); end
+  end
+end
 
+CodeRay::CODERAY_PATH = T.let(T.unsafe(nil), String)
+
+class CodeRay::Duo
+  def initialize(lang = T.unsafe(nil), format = T.unsafe(nil), options = T.unsafe(nil)); end
+
+  def call(code, options = T.unsafe(nil)); end
+  def encode(code, options = T.unsafe(nil)); end
+  def encoder; end
+  def format; end
+  def format=(_arg0); end
+  def highlight(code, options = T.unsafe(nil)); end
+  def lang; end
+  def lang=(_arg0); end
+  def options; end
+  def options=(_arg0); end
+  def scanner; end
+
+  class << self
+    def [](*_arg0); end
+  end
+end
+
+module CodeRay::Encoders
+  extend ::CodeRay::PluginHost
+end
+
+class CodeRay::Encoders::CommentFilter < ::CodeRay::Encoders::TokenKindFilter; end
+CodeRay::Encoders::CommentFilter::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+
+class CodeRay::Encoders::Count < ::CodeRay::Encoders::Encoder
+  def begin_group(kind); end
+  def begin_line(kind); end
+  def end_group(kind); end
+  def end_line(kind); end
+  def text_token(text, kind); end
+
+  protected
+
+  def finish(options); end
+  def setup(options); end
+end
+
+class CodeRay::Encoders::Debug < ::CodeRay::Encoders::Encoder
+  def begin_group(kind); end
+  def begin_line(kind); end
+  def end_group(kind); end
+  def end_line(kind); end
+  def text_token(text, kind); end
+end
+
+CodeRay::Encoders::Debug::FILE_EXTENSION = T.let(T.unsafe(nil), String)
+
+class CodeRay::Encoders::DebugLint < ::CodeRay::Encoders::Debug
+  def begin_group(kind); end
+  def begin_line(kind); end
+  def end_group(kind); end
+  def end_line(kind); end
+  def text_token(text, kind); end
+
+  protected
+
+  def finish(options); end
+  def setup(options); end
+end
+
+class CodeRay::Encoders::Div < ::CodeRay::Encoders::HTML; end
+CodeRay::Encoders::Div::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+CodeRay::Encoders::Div::FILE_EXTENSION = T.let(T.unsafe(nil), String)
+
+class CodeRay::Encoders::Encoder
+  extend ::CodeRay::Plugin
+
+  def initialize(options = T.unsafe(nil)); end
+
+  def <<(token); end
+  def begin_group(kind); end
+  def begin_line(kind); end
+  def encode(code, lang, options = T.unsafe(nil)); end
+  def encode_tokens(tokens, options = T.unsafe(nil)); end
+  def end_group(kind); end
+  def end_line(kind); end
+  def file_extension; end
+  def highlight(code, lang, options = T.unsafe(nil)); end
+  def options; end
+  def options=(_arg0); end
+  def scanner; end
+  def scanner=(_arg0); end
+  def text_token(text, kind); end
+  def token(content, kind); end
+  def tokens(tokens, options = T.unsafe(nil)); end
+
+  protected
+
+  def compile(tokens, options = T.unsafe(nil)); end
+  def finish(options); end
+  def get_output(options); end
+  def output(data); end
+  def setup(options); end
+
+  class << self
+    def const_missing(sym); end
+    def file_extension; end
+  end
+end
+
+CodeRay::Encoders::Encoder::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+CodeRay::Encoders::Encoder::PLUGIN_HOST = CodeRay::Encoders
+
+class CodeRay::Encoders::Filter < ::CodeRay::Encoders::Encoder
+  def begin_group(kind); end
+  def begin_line(kind); end
+  def end_group(kind); end
+  def end_line(kind); end
+  def text_token(text, kind); end
+
+  protected
+
+  def finish(options); end
+  def setup(options); end
+end
+
+class CodeRay::Encoders::HTML < ::CodeRay::Encoders::Encoder
+  def begin_group(kind); end
+  def begin_line(kind); end
+  def css; end
+  def end_group(kind); end
+  def end_line(kind); end
+  def text_token(text, kind); end
+
+  protected
+
+  def break_lines(text, style); end
+  def check_group_nesting(name, kind); end
+  def check_options!(options); end
+  def close_span; end
+  def css_class_for_kinds(kinds); end
+  def finish(options); end
+  def make_span_for_kinds(method, hint); end
+  def setup(options); end
+  def style_for_kinds(kinds); end
+
+  class << self
+    def make_html_escape_hash; end
+    def token_path_to_hint(hint, kinds); end
+  end
+end
+
+class CodeRay::Encoders::HTML::CSS
+  def initialize(style = T.unsafe(nil)); end
+
+  def get_style_for_css_classes(css_classes); end
+  def stylesheet; end
+
+  private
+
+  def parse(stylesheet); end
+
+  class << self
+    def load_stylesheet(style = T.unsafe(nil)); end
+  end
+end
+
+CodeRay::Encoders::HTML::CSS::CSS_CLASS_PATTERN = T.let(T.unsafe(nil), Regexp)
+CodeRay::Encoders::HTML::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+CodeRay::Encoders::HTML::FILE_EXTENSION = T.let(T.unsafe(nil), String)
+CodeRay::Encoders::HTML::HTML_ESCAPE = T.let(T.unsafe(nil), Hash)
+CodeRay::Encoders::HTML::HTML_ESCAPE_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+module CodeRay::Encoders::HTML::Numbering
+  class << self
+    def number!(output, mode = T.unsafe(nil), options = T.unsafe(nil)); end
+  end
+end
+
+module CodeRay::Encoders::HTML::Output
+  def apply_title!(title); end
+  def css; end
+  def css=(_arg0); end
+  def stylesheet(in_tag = T.unsafe(nil)); end
+  def wrap!(element, *args); end
+  def wrap_in!(template); end
+  def wrapped_in; end
+  def wrapped_in=(_arg0); end
+  def wrapped_in?(element); end
+
+  class << self
+    def extended(o); end
+    def make_stylesheet(css, in_tag = T.unsafe(nil)); end
+    def page_template_for_css(css); end
+  end
+end
+
+CodeRay::Encoders::HTML::Output::DIV = T.let(T.unsafe(nil), CodeRay::Encoders::HTML::Output::Template)
+CodeRay::Encoders::HTML::Output::PAGE = T.let(T.unsafe(nil), CodeRay::Encoders::HTML::Output::Template)
+CodeRay::Encoders::HTML::Output::SPAN = T.let(T.unsafe(nil), CodeRay::Encoders::HTML::Output::Template)
+CodeRay::Encoders::HTML::Output::TABLE = T.let(T.unsafe(nil), CodeRay::Encoders::HTML::Output::Template)
+
+class CodeRay::Encoders::HTML::Output::Template < ::String
+  def apply(target, replacement); end
+
+  class << self
+    def wrap!(str, template, target); end
+  end
+end
+
+CodeRay::Encoders::HTML::TOKEN_KIND_TO_INFO = T.let(T.unsafe(nil), Hash)
+CodeRay::Encoders::HTML::TRANSPARENT_TOKEN_KINDS = T.let(T.unsafe(nil), Set)
+
+class CodeRay::Encoders::JSON < ::CodeRay::Encoders::Encoder
+  def begin_group(kind); end
+  def begin_line(kind); end
+  def end_group(kind); end
+  def end_line(kind); end
+  def text_token(text, kind); end
+
+  protected
+
+  def append(data); end
+  def finish(options); end
+  def setup(options); end
+end
+
+CodeRay::Encoders::JSON::FILE_EXTENSION = T.let(T.unsafe(nil), String)
+
+class CodeRay::Encoders::LinesOfCode < ::CodeRay::Encoders::TokenKindFilter
+  protected
+
+  def finish(options); end
+  def setup(options); end
+end
+
+CodeRay::Encoders::LinesOfCode::NON_EMPTY_LINE = T.let(T.unsafe(nil), Regexp)
+
+class CodeRay::Encoders::Lint < ::CodeRay::Encoders::Debug
+  def begin_group(kind); end
+  def begin_line(kind); end
+  def end_group(kind); end
+  def end_line(kind); end
+  def text_token(text, kind); end
+
+  protected
+
+  def finish(options); end
+  def setup(options); end
+end
+
+class CodeRay::Encoders::Lint::EmptyToken < ::CodeRay::Encoders::Lint::InvalidTokenStream; end
+class CodeRay::Encoders::Lint::IncorrectTokenGroupNesting < ::CodeRay::Encoders::Lint::InvalidTokenStream; end
+class CodeRay::Encoders::Lint::InvalidTokenStream < ::StandardError; end
+class CodeRay::Encoders::Lint::UnknownTokenKind < ::CodeRay::Encoders::Lint::InvalidTokenStream; end
+
+class CodeRay::Encoders::Null < ::CodeRay::Encoders::Encoder
+  def text_token(text, kind); end
+end
+
+class CodeRay::Encoders::Page < ::CodeRay::Encoders::HTML; end
+CodeRay::Encoders::Page::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+CodeRay::Encoders::Page::FILE_EXTENSION = T.let(T.unsafe(nil), String)
+class CodeRay::Encoders::Span < ::CodeRay::Encoders::HTML; end
+CodeRay::Encoders::Span::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+CodeRay::Encoders::Span::FILE_EXTENSION = T.let(T.unsafe(nil), String)
+
+class CodeRay::Encoders::Statistic < ::CodeRay::Encoders::Encoder
+  def begin_group(kind); end
+  def begin_line(kind); end
+  def block_token(action, kind); end
+  def end_group(kind); end
+  def end_line(kind); end
+  def real_token_count; end
+  def text_token(text, kind); end
+  def type_stats; end
+
+  protected
+
+  def finish(options); end
+  def setup(options); end
+end
+
+CodeRay::Encoders::Statistic::STATS = T.let(T.unsafe(nil), String)
+CodeRay::Encoders::Statistic::TOKEN_TYPES_ROW = T.let(T.unsafe(nil), String)
+
+class CodeRay::Encoders::Statistic::TypeStats < ::Struct
+  def count; end
+  def count=(_); end
+  def size; end
+  def size=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class CodeRay::Encoders::Terminal < ::CodeRay::Encoders::Encoder
+  def begin_group(kind); end
+  def begin_line(kind); end
+  def end_group(kind); end
+  def end_line(kind); end
+  def text_token(text, kind); end
+
+  protected
+
+  def setup(options); end
+
+  private
+
+  def open_token(kind); end
+end
+
+CodeRay::Encoders::Terminal::TOKEN_COLORS = T.let(T.unsafe(nil), Hash)
+
+class CodeRay::Encoders::Text < ::CodeRay::Encoders::Encoder
+  def text_token(text, kind); end
+
+  protected
+
+  def setup(options); end
+end
+
+CodeRay::Encoders::Text::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+CodeRay::Encoders::Text::FILE_EXTENSION = T.let(T.unsafe(nil), String)
+
+class CodeRay::Encoders::TokenKindFilter < ::CodeRay::Encoders::Filter
+  def begin_group(kind); end
+  def begin_line(kind); end
+  def end_group(kind); end
+  def end_line(kind); end
+  def text_token(text, kind); end
+
+  protected
+
+  def include_group?(kind); end
+  def include_text_token?(text, kind); end
+  def setup(options); end
+end
+
+CodeRay::Encoders::TokenKindFilter::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+
+class CodeRay::Encoders::XML < ::CodeRay::Encoders::Encoder
+  def begin_group(kind); end
+  def end_group(kind); end
+  def text_token(text, kind); end
+
+  protected
+
+  def finish(options); end
+  def setup(options); end
+end
+
+CodeRay::Encoders::XML::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+CodeRay::Encoders::XML::FILE_EXTENSION = T.let(T.unsafe(nil), String)
+
+class CodeRay::Encoders::YAML < ::CodeRay::Encoders::Encoder
+  def begin_group(kind); end
+  def begin_line(kind); end
+  def end_group(kind); end
+  def end_line(kind); end
+  def text_token(text, kind); end
+
+  protected
+
+  def finish(options); end
+  def setup(options); end
+end
+
+CodeRay::Encoders::YAML::FILE_EXTENSION = T.let(T.unsafe(nil), String)
+
+module CodeRay::FileType
+  class << self
+    def [](filename, read_shebang = T.unsafe(nil)); end
+    def fetch(filename, default = T.unsafe(nil), read_shebang = T.unsafe(nil)); end
+
+    protected
+
+    def type_from_shebang(filename); end
+  end
+end
+
+CodeRay::FileType::TypeFromExt = T.let(T.unsafe(nil), Hash)
+CodeRay::FileType::TypeFromName = T.let(T.unsafe(nil), Hash)
+CodeRay::FileType::TypeFromShebang = T.let(T.unsafe(nil), Regexp)
+class CodeRay::FileType::UnknownFileType < ::Exception; end
+
+module CodeRay::Plugin
+  def aliases; end
+  def plugin_host(host = T.unsafe(nil)); end
+  def plugin_id; end
+  def register_for(id); end
+  def title(title = T.unsafe(nil)); end
+end
+
+module CodeRay::PluginHost
+  def [](id, *args, &blk); end
+  def all_plugins; end
+  def const_missing(const); end
+  def default(id = T.unsafe(nil)); end
+  def list; end
+  def load(id, *args, &blk); end
+  def load_all; end
+  def load_plugin_map; end
+  def map(hash); end
+  def plugin_hash; end
+  def plugin_path(*args); end
+  def register(plugin, id); end
+
+  protected
+
+  def make_plugin_hash; end
+  def path_to(plugin_id); end
+  def validate_id(id); end
+
+  class << self
+    def extended(mod); end
+  end
+end
+
+class CodeRay::PluginHost::HostNotFound < ::LoadError; end
+CodeRay::PluginHost::PLUGIN_HOSTS = T.let(T.unsafe(nil), Array)
+CodeRay::PluginHost::PLUGIN_HOSTS_BY_ID = T.let(T.unsafe(nil), Hash)
+class CodeRay::PluginHost::PluginNotFound < ::LoadError; end
+
+module CodeRay::Scanners
+  extend ::CodeRay::PluginHost
+end
+
+class CodeRay::Scanners::C < ::CodeRay::Scanners::Scanner
+  protected
+
+  def scan_tokens(encoder, options); end
+end
+
+CodeRay::Scanners::C::DIRECTIVES = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::C::ESCAPE = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::C::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList)
+CodeRay::Scanners::C::KEYWORDS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::C::PREDEFINED_CONSTANTS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::C::PREDEFINED_TYPES = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::C::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::CPlusPlus = CodeRay::Scanners::Text
+
+class CodeRay::Scanners::CSS < ::CodeRay::Scanners::Scanner
+  protected
+
+  def scan_tokens(encoder, options); end
+  def setup; end
+end
+
+CodeRay::Scanners::CSS::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array)
+module CodeRay::Scanners::CSS::RE; end
+CodeRay::Scanners::CSS::RE::AtKeyword = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::CSS::RE::AttributeSelector = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::CSS::RE::Class = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::CSS::RE::Dimension = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::CSS::RE::Escape = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::CSS::RE::Function = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::CSS::RE::Hex = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::CSS::RE::HexColor = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::CSS::RE::Id = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::CSS::RE::Ident = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::CSS::RE::NMChar = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::CSS::RE::NMStart = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::CSS::RE::Name = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::CSS::RE::Num = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::CSS::RE::Percentage = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::CSS::RE::PseudoClass = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::CSS::RE::String = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::CSS::RE::String1 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::CSS::RE::String2 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::CSS::RE::Unicode = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::CSS::RE::Unit = T.let(T.unsafe(nil), Regexp)
+
+class CodeRay::Scanners::Clojure < ::CodeRay::Scanners::Scanner
+  protected
+
+  def scan_tokens(encoder, options); end
+end
+
+CodeRay::Scanners::Clojure::BASIC_IDENTIFIER = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::COMPLEX10 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::COMPLEX16 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::COMPLEX2 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::COMPLEX8 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::CORE_FORMS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Clojure::DECIMAL = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::DIGIT = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::DIGIT10 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::DIGIT16 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::DIGIT2 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::DIGIT8 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::EXACTNESS = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::EXP = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::EXP_MARK = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::IDENTIFIER = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList)
+CodeRay::Scanners::Clojure::IMAG10 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::IMAG16 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::IMAG2 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::IMAG8 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::KEYWORD_NEXT_TOKEN_KIND = T.let(T.unsafe(nil), CodeRay::WordList)
+CodeRay::Scanners::Clojure::NUM = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::NUM10 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::NUM16 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::NUM2 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::NUM8 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::PREDEFINED_CONSTANTS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Clojure::PREFIX10 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::PREFIX16 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::PREFIX2 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::PREFIX8 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::RADIX10 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::RADIX16 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::RADIX2 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::RADIX8 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::REAL10 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::REAL16 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::REAL2 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::REAL8 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::SIGN = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::SPECIAL_FORMS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Clojure::SUFFIX = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::SYMBOL = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::UINT10 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::UINT16 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::UINT2 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::UINT8 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::UREAL10 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::UREAL16 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::UREAL2 = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Clojure::UREAL8 = T.let(T.unsafe(nil), Regexp)
+
+class CodeRay::Scanners::Debug < ::CodeRay::Scanners::Scanner
+  protected
+
+  def scan_tokens(encoder, options); end
+  def setup; end
+end
+
+class CodeRay::Scanners::Delphi < ::CodeRay::Scanners::Scanner
+  protected
+
+  def scan_tokens(encoder, options); end
+end
+
+CodeRay::Scanners::Delphi::DIRECTIVES = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Delphi::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList::CaseIgnoring)
+CodeRay::Scanners::Delphi::KEYWORDS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Delphi::NAME_FOLLOWS = T.let(T.unsafe(nil), CodeRay::WordList::CaseIgnoring)
+
+class CodeRay::Scanners::Diff < ::CodeRay::Scanners::Scanner
+  protected
+
+  def scan_tokens(encoder, options); end
+
+  private
+
+  def diff(a, b); end
+end
+
+CodeRay::Scanners::Diff::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+
+class CodeRay::Scanners::ERB < ::CodeRay::Scanners::Scanner
+  protected
+
+  def reset_instance; end
+  def scan_tokens(encoder, options); end
+  def setup; end
+end
+
+CodeRay::Scanners::ERB::ERB_RUBY_BLOCK = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::ERB::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::ERB::START_OF_ERB = T.let(T.unsafe(nil), Regexp)
+
+class CodeRay::Scanners::Go < ::CodeRay::Scanners::Scanner
+  protected
+
+  def scan_tokens(encoder, options); end
+end
+
+CodeRay::Scanners::Go::ESCAPE = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Go::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList)
+CodeRay::Scanners::Go::KEYWORDS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Go::PREDEFINED_CONSTANTS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Go::PREDEFINED_FUNCTIONS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Go::PREDEFINED_TYPES = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Go::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp)
+
+class CodeRay::Scanners::Groovy < ::CodeRay::Scanners::Java
+  protected
+
+  def scan_tokens(encoder, options); end
+  def setup; end
+end
+
+CodeRay::Scanners::Groovy::ESCAPE = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Groovy::GROOVY_KEYWORDS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Groovy::GROOVY_MAGIC_VARIABLES = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Groovy::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList)
+CodeRay::Scanners::Groovy::KEYWORDS_EXPECTING_VALUE = T.let(T.unsafe(nil), CodeRay::WordList)
+CodeRay::Scanners::Groovy::REGEXP_ESCAPE = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Groovy::STRING_CONTENT_PATTERN = T.let(T.unsafe(nil), Hash)
+CodeRay::Scanners::Groovy::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp)
+
+class CodeRay::Scanners::HAML < ::CodeRay::Scanners::Scanner
+  protected
+
+  def scan_tokens(encoder, options); end
+  def setup; end
+end
+
+CodeRay::Scanners::HAML::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array)
+
+class CodeRay::Scanners::HTML < ::CodeRay::Scanners::Scanner
+  def reset; end
+
+  protected
+
+  def scan_css(encoder, code, state = T.unsafe(nil)); end
+  def scan_java_script(encoder, code); end
+  def scan_tokens(encoder, options); end
+  def setup; end
+end
+
+CodeRay::Scanners::HTML::ATTR_NAME = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::HTML::ENTITY = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::HTML::EVENT_ATTRIBUTES = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::HTML::HEX = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::HTML::IN_ATTRIBUTE = T.let(T.unsafe(nil), CodeRay::WordList::CaseIgnoring)
+CodeRay::Scanners::HTML::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::HTML::PLAIN_STRING_CONTENT = T.let(T.unsafe(nil), Hash)
+CodeRay::Scanners::HTML::TAG_END = T.let(T.unsafe(nil), Regexp)
+
+class CodeRay::Scanners::JSON < ::CodeRay::Scanners::Scanner
+  protected
+
+  def scan_tokens(encoder, options); end
+  def setup; end
+end
+
+CodeRay::Scanners::JSON::ESCAPE = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::JSON::KEY = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::JSON::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::JSON::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp)
+
+class CodeRay::Scanners::Java < ::CodeRay::Scanners::Scanner
+  protected
+
+  def scan_tokens(encoder, options); end
+end
+
+module CodeRay::Scanners::Java::BuiltinTypes; end
+CodeRay::Scanners::Java::BuiltinTypes::List = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Java::CONSTANTS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Java::DIRECTIVES = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Java::ESCAPE = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Java::IDENT = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Java::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList)
+CodeRay::Scanners::Java::KEYWORDS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Java::MAGIC_VARIABLES = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Java::RESERVED = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Java::STRING_CONTENT_PATTERN = T.let(T.unsafe(nil), Hash)
+CodeRay::Scanners::Java::TYPES = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Java::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp)
+
+class CodeRay::Scanners::JavaScript < ::CodeRay::Scanners::Scanner
+  protected
+
+  def reset_instance; end
+  def scan_tokens(encoder, options); end
+  def setup; end
+  def xml_scanner; end
+end
+
+CodeRay::Scanners::JavaScript::ESCAPE = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::JavaScript::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList)
+CodeRay::Scanners::JavaScript::KEYWORDS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::JavaScript::KEYWORDS_EXPECTING_VALUE = T.let(T.unsafe(nil), CodeRay::WordList)
+CodeRay::Scanners::JavaScript::KEY_CHECK_PATTERN = T.let(T.unsafe(nil), Hash)
+CodeRay::Scanners::JavaScript::MAGIC_VARIABLES = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::JavaScript::PREDEFINED_CONSTANTS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::JavaScript::REGEXP_ESCAPE = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::JavaScript::RESERVED_WORDS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::JavaScript::STRING_CONTENT_PATTERN = T.let(T.unsafe(nil), Hash)
+CodeRay::Scanners::JavaScript::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp)
+
+class CodeRay::Scanners::Lua < ::CodeRay::Scanners::Scanner
+  protected
+
+  def scan_tokens(encoder, options); end
+  def setup; end
+end
+
+CodeRay::Scanners::Lua::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList)
+CodeRay::Scanners::Lua::KEYWORDS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Lua::PREDEFINED_CONSTANTS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Lua::PREDEFINED_EXPRESSIONS = T.let(T.unsafe(nil), Array)
+
+class CodeRay::Scanners::PHP < ::CodeRay::Scanners::Scanner
+  protected
+
+  def reset_instance; end
+  def scan_tokens(encoder, options); end
+  def setup; end
+end
+
+CodeRay::Scanners::PHP::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array)
+module CodeRay::Scanners::PHP::RE; end
+CodeRay::Scanners::PHP::RE::HTML_INDICATOR = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::PHP::RE::IDENTIFIER = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::PHP::RE::OPERATOR = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::PHP::RE::PHP_END = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::PHP::RE::PHP_START = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::PHP::RE::VARIABLE = T.let(T.unsafe(nil), Regexp)
+module CodeRay::Scanners::PHP::Words; end
+CodeRay::Scanners::PHP::Words::BUILTIN_FUNCTIONS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::PHP::Words::CLASSES = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::PHP::Words::CONSTANTS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::PHP::Words::EXCEPTIONS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::PHP::Words::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList::CaseIgnoring)
+CodeRay::Scanners::PHP::Words::KEYWORDS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::PHP::Words::LANGUAGE_CONSTRUCTS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::PHP::Words::PREDEFINED = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::PHP::Words::TYPES = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::PHP::Words::VARIABLE_KIND = T.let(T.unsafe(nil), CodeRay::WordList)
+
+class CodeRay::Scanners::Python < ::CodeRay::Scanners::Scanner
+  protected
+
+  def scan_tokens(encoder, options); end
+end
+
+CodeRay::Scanners::Python::DEF_NEW_STATE = T.let(T.unsafe(nil), CodeRay::WordList)
+CodeRay::Scanners::Python::DESCRIPTOR = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Python::DOCSTRING_COMING = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Python::ESCAPE = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Python::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList)
+CodeRay::Scanners::Python::KEYWORDS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Python::NAME = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Python::OLD_KEYWORDS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Python::OPERATOR = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Python::PREDEFINED_EXCEPTIONS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Python::PREDEFINED_METHODS_AND_TYPES = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Python::PREDEFINED_VARIABLES_AND_CONSTANTS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Python::STRING_CONTENT_REGEXP = T.let(T.unsafe(nil), Hash)
+CodeRay::Scanners::Python::STRING_DELIMITER_REGEXP = T.let(T.unsafe(nil), Hash)
+CodeRay::Scanners::Python::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp)
+
+class CodeRay::Scanners::Raydebug < ::CodeRay::Scanners::Scanner
+  protected
+
+  def scan_tokens(encoder, options); end
+  def setup; end
+end
+
+class CodeRay::Scanners::Ruby < ::CodeRay::Scanners::Scanner
+  def interpreted_string_state; end
+
+  protected
+
+  def scan_tokens(encoder, options); end
+  def setup; end
+end
+
+module CodeRay::Scanners::Ruby::Patterns; end
+CodeRay::Scanners::Ruby::Patterns::BINARY = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::CHARACTER = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::CLASS_VARIABLE = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::CONTROL_META_ESCAPE = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::DATA = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::DECIMAL = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::ESCAPE = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::EXPONENT = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::FANCY_STRING_INTERPRETED = T.let(T.unsafe(nil), Hash)
+CodeRay::Scanners::Ruby::Patterns::FANCY_STRING_KIND = T.let(T.unsafe(nil), Hash)
+CodeRay::Scanners::Ruby::Patterns::FANCY_STRING_START = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::FLOAT_OR_INT = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::FLOAT_SUFFIX = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::GLOBAL_VARIABLE = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::HEREDOC_OPEN = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::HEXADECIMAL = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::IDENT = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList)
+CodeRay::Scanners::Ruby::Patterns::INSTANCE_VARIABLE = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::KEYWORDS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Ruby::Patterns::KEYWORDS_EXPECTING_VALUE = T.let(T.unsafe(nil), CodeRay::WordList)
+CodeRay::Scanners::Ruby::Patterns::KEYWORD_NEW_STATE = T.let(T.unsafe(nil), CodeRay::WordList)
+CodeRay::Scanners::Ruby::Patterns::METHOD_AFTER_DOT = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::METHOD_NAME = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::METHOD_NAME_EX = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::METHOD_NAME_OPERATOR = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::METHOD_NAME_OR_SYMBOL = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::METHOD_SUFFIX = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::NUMERIC = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::OBJECT_VARIABLE = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::OCTAL = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::PREDEFINED_CONSTANTS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Ruby::Patterns::PREFIX_VARIABLE = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::QUOTE_TO_TYPE = T.let(T.unsafe(nil), Hash)
+CodeRay::Scanners::Ruby::Patterns::REGEXP_MODIFIERS = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::RUBYDOC = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::RUBYDOC_OR_DATA = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::SIMPLE_ESCAPE = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::SYMBOL = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::VALUE_FOLLOWS = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::Ruby::Patterns::VARIABLE = T.let(T.unsafe(nil), Regexp)
+
+class CodeRay::Scanners::Ruby::StringState < ::Struct
+  def initialize(kind, interpreted, delim, heredoc = T.unsafe(nil)); end
+
+  def heredoc_pattern(delim, interpreted, indented); end
+
+  class << self
+    def simple_key_pattern(delim); end
+  end
+end
+
+CodeRay::Scanners::Ruby::StringState::CLOSING_PAREN = T.let(T.unsafe(nil), Hash)
+CodeRay::Scanners::Ruby::StringState::STRING_PATTERN = T.let(T.unsafe(nil), Hash)
+
+class CodeRay::Scanners::SQL < ::CodeRay::Scanners::Scanner
+  def scan_tokens(encoder, options); end
+end
+
+CodeRay::Scanners::SQL::COMMANDS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::SQL::DIRECTIVES = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::SQL::ESCAPE = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::SQL::IDENT_KIND = T.let(T.unsafe(nil), CodeRay::WordList::CaseIgnoring)
+CodeRay::Scanners::SQL::KEYWORDS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::SQL::OBJECTS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::SQL::PREDEFINED_CONSTANTS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::SQL::PREDEFINED_FUNCTIONS = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::SQL::PREDEFINED_TYPES = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::SQL::STRING_CONTENT_PATTERN = T.let(T.unsafe(nil), Hash)
+CodeRay::Scanners::SQL::STRING_PREFIXES = T.let(T.unsafe(nil), Regexp)
+CodeRay::Scanners::SQL::UNICODE_ESCAPE = T.let(T.unsafe(nil), Regexp)
+
+class CodeRay::Scanners::Sass < ::CodeRay::Scanners::CSS
+  protected
+
+  def scan_tokens(encoder, options); end
+  def setup; end
+end
+
+class CodeRay::Scanners::Scanner < ::StringScanner
+  include ::Enumerable
+  extend ::CodeRay::Plugin
+
+  def initialize(code = T.unsafe(nil), options = T.unsafe(nil)); end
+
+  def binary_string; end
+  def column(pos = T.unsafe(nil)); end
+  def each(&block); end
+  def file_extension; end
+  def lang; end
+  def line(pos = T.unsafe(nil)); end
+  def reset; end
+  def state; end
+  def state=(_arg0); end
+  def string=(code); end
+  def tokenize(source = T.unsafe(nil), options = T.unsafe(nil)); end
+  def tokens; end
+
+  protected
+
+  def raise_inspect(message, tokens, state = T.unsafe(nil), ambit = T.unsafe(nil), backtrace = T.unsafe(nil)); end
+  def raise_inspect_arguments(message, tokens, state, ambit); end
+  def reset_instance; end
+  def scan_rest; end
+  def scan_tokens(tokens, options); end
+  def scanner_state_info(state); end
+  def set_string_from_source(source); end
+  def set_tokens_from_options(options); end
+  def setup; end
+  def tokens_last(tokens, n); end
+  def tokens_size(tokens); end
+
+  class << self
+    def encoding(name = T.unsafe(nil)); end
+    def file_extension(extension = T.unsafe(nil)); end
+    def lang; end
+    def normalize(code); end
+
+    protected
+
+    def encode_with_encoding(code, target_encoding); end
+    def guess_encoding(s); end
+    def to_unix(code); end
+  end
+end
+
+CodeRay::Scanners::Scanner::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+CodeRay::Scanners::Scanner::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array)
+CodeRay::Scanners::Scanner::PLUGIN_HOST = CodeRay::Scanners
+CodeRay::Scanners::Scanner::SCANNER_STATE_INFO = T.let(T.unsafe(nil), String)
+CodeRay::Scanners::Scanner::SCAN_ERROR_MESSAGE = T.let(T.unsafe(nil), String)
+class CodeRay::Scanners::Scanner::ScanError < ::StandardError; end
+
+class CodeRay::Scanners::Taskpaper < ::CodeRay::Scanners::Scanner
+  protected
+
+  def scan_tokens(encoder, options); end
+end
+
+class CodeRay::Scanners::Text < ::CodeRay::Scanners::Scanner
+  protected
+
+  def scan_tokens(encoder, options); end
+end
+
+CodeRay::Scanners::Text::KINDS_NOT_LOC = T.let(T.unsafe(nil), Array)
+class CodeRay::Scanners::XML < ::CodeRay::Scanners::HTML; end
+
+class CodeRay::Scanners::YAML < ::CodeRay::Scanners::Scanner
+  protected
+
+  def scan_tokens(encoder, options); end
+end
+
+CodeRay::Scanners::YAML::KINDS_NOT_LOC = T.let(T.unsafe(nil), Symbol)
+
+module CodeRay::Styles
+  extend ::CodeRay::PluginHost
+end
+
+class CodeRay::Styles::Alpha < ::CodeRay::Styles::Style; end
+CodeRay::Styles::Alpha::CSS_MAIN_STYLES = T.let(T.unsafe(nil), String)
+CodeRay::Styles::Alpha::TOKEN_COLORS = T.let(T.unsafe(nil), String)
+
+class CodeRay::Styles::Style
+  extend ::CodeRay::Plugin
+end
+
+CodeRay::Styles::Style::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+CodeRay::Styles::Style::PLUGIN_HOST = CodeRay::Styles
+CodeRay::TokenKinds = T.let(T.unsafe(nil), Hash)
+
+class CodeRay::Tokens < ::Array
+  def begin_group(kind); end
+  def begin_line(kind); end
+  def count; end
+  def encode(encoder, options = T.unsafe(nil)); end
+  def end_group(kind); end
+  def end_line(kind); end
+  def method_missing(meth, options = T.unsafe(nil)); end
+  def scanner; end
+  def scanner=(_arg0); end
+  def split_into_parts(*sizes); end
+  def text_token(*_arg0); end
+  def to_s; end
+  def tokens(*_arg0); end
+end
+
+class CodeRay::TokensProxy
+  def initialize(input, lang, options = T.unsafe(nil), block = T.unsafe(nil)); end
+
+  def block; end
+  def block=(_arg0); end
+  def each(*args, &blk); end
+  def encode(encoder, options = T.unsafe(nil)); end
+  def input; end
+  def input=(_arg0); end
+  def lang; end
+  def lang=(_arg0); end
+  def method_missing(method, *args, &blk); end
+  def options; end
+  def options=(_arg0); end
+  def scanner; end
+  def tokens; end
+end
+
+CodeRay::VERSION = T.let(T.unsafe(nil), String)
+
+class CodeRay::WordList < ::Hash
+  def initialize(default = T.unsafe(nil)); end
+
+  def add(words, value = T.unsafe(nil)); end
+end
+
+class CodeRay::WordList::CaseIgnoring < ::CodeRay::WordList
+  def [](key); end
+  def []=(key, value); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/colorize@0.8.1.rbi b/Library/Homebrew/sorbet/rbi/gems/colorize@0.8.1.rbi
index 9e8bcde109..ef5c2b709f 100644
--- a/Library/Homebrew/sorbet/rbi/gems/colorize@0.8.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/colorize@0.8.1.rbi
@@ -1,11 +1,10 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `colorize` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-module Colorize
-end
+module Colorize; end
 
 module Colorize::ClassMethods
   def color_codes; end
diff --git a/Library/Homebrew/sorbet/rbi/gems/commander@4.6.0.rbi b/Library/Homebrew/sorbet/rbi/gems/commander@4.6.0.rbi
index be9c1ae486..dcd7b25677 100644
--- a/Library/Homebrew/sorbet/rbi/gems/commander@4.6.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/commander@4.6.0.rbi
@@ -4,5 +4,263 @@
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module Blank
+  class << self
+    def included(base); end
+  end
+end
+
+module Commander
+  private
+
+  def configure(*configuration_opts, &configuration_block); end
+
+  class << self
+    def configure(*configuration_opts, &configuration_block); end
+  end
+end
+
+class Commander::Command
+  def initialize(name); end
+
+  def action(*args, &block); end
+  def call(args = T.unsafe(nil)); end
+  def description; end
+  def description=(_arg0); end
+  def example(description, command); end
+  def examples; end
+  def examples=(_arg0); end
+  def global_options; end
+  def inspect; end
+  def name; end
+  def name=(_arg0); end
+  def option(*args, &block); end
+  def option_proc(switches); end
+  def options; end
+  def options=(_arg0); end
+  def parse_options_and_call_procs(*args); end
+  def proxy_option_struct; end
+  def proxy_options; end
+  def proxy_options=(_arg0); end
+  def run(*args); end
+  def summary; end
+  def summary=(_arg0); end
+  def syntax; end
+  def syntax=(_arg0); end
+  def when_called(*args, &block); end
+end
+
+class Commander::Command::Options
+  include ::Blank
+
+  def initialize; end
+
+  def __hash__; end
+  def default(defaults = T.unsafe(nil)); end
+  def inspect; end
+  def method_missing(meth, *args); end
+end
+
+module Commander::Delegates
+  def add_command(*args, &block); end
+  def alias_command(*args, &block); end
+  def always_trace!(*args, &block); end
+  def command(*args, &block); end
+  def default_command(*args, &block); end
+  def defined_commands(*args, &block); end
+  def global_option(*args, &block); end
+  def never_trace!(*args, &block); end
+  def program(*args, &block); end
+  def run!(*args, &block); end
+end
+
+module Commander::HelpFormatter
+  private
+
+  def indent(amount, text); end
+
+  class << self
+    def indent(amount, text); end
+  end
+end
+
+class Commander::HelpFormatter::Base
+  def initialize(runner); end
+
+  def render; end
+  def render_command(command); end
+end
+
+class Commander::HelpFormatter::Context
+  def initialize(target); end
+
+  def decorate_binding(_bind); end
+  def get_binding; end
+end
+
+class Commander::HelpFormatter::ProgramContext < ::Commander::HelpFormatter::Context
+  def decorate_binding(bind); end
+  def max_aliases_length(bind); end
+  def max_command_length(bind); end
+  def max_key_length(hash, default = T.unsafe(nil)); end
+end
+
+class Commander::HelpFormatter::Terminal < ::Commander::HelpFormatter::Base
+  def render; end
+  def render_command(command); end
+  def template(name); end
+end
+
+class Commander::HelpFormatter::TerminalCompact < ::Commander::HelpFormatter::Terminal
+  def template(name); end
+end
+
+module Commander::Methods
+  include ::Commander::UI
+  include ::Commander::UI::AskForClass
+  include ::Commander::Delegates
+end
+
+module Commander::Platform
+  class << self
+    def jruby?; end
+  end
+end
+
+class Commander::Runner
+  def initialize(args = T.unsafe(nil)); end
+
+  def active_command; end
+  def add_command(command); end
+  def alias?(name); end
+  def alias_command(alias_name, name, *args); end
+  def always_trace!; end
+  def args_without_command_name; end
+  def command(name, &block); end
+  def command_exists?(name); end
+  def command_name_from_args; end
+  def commands; end
+  def create_default_commands; end
+  def default_command(name); end
+  def expand_optionally_negative_switches(switches); end
+  def global_option(*args, &block); end
+  def global_option_proc(switches, &block); end
+  def help_formatter; end
+  def help_formatter_alias_defaults; end
+  def help_formatter_aliases; end
+  def never_trace!; end
+  def options; end
+  def parse_global_options; end
+  def program(key, *args, &block); end
+  def program_defaults; end
+  def remove_global_options(options, args); end
+  def require_program(*keys); end
+  def require_valid_command(command = T.unsafe(nil)); end
+  def run!; end
+  def run_active_command; end
+  def say(*args); end
+  def valid_command_names_from(*args); end
+  def version; end
+
+  private
+
+  def longest_valid_command_name_from(args); end
+
+  class << self
+    def instance; end
+    def separate_switches_from_description(*args); end
+    def switch_to_sym(switch); end
+  end
+end
+
+class Commander::Runner::CommandError < ::StandardError; end
+class Commander::Runner::InvalidCommandError < ::Commander::Runner::CommandError; end
+
+module Commander::UI
+  private
+
+  def applescript(script); end
+  def ask_editor(input = T.unsafe(nil), preferred_editor = T.unsafe(nil)); end
+  def available_editor(preferred = T.unsafe(nil)); end
+  def choose(message = T.unsafe(nil), *choices, &block); end
+  def color(*args); end
+  def converse(prompt, responses = T.unsafe(nil)); end
+  def enable_paging; end
+  def io(input = T.unsafe(nil), output = T.unsafe(nil), &block); end
+  def log(action, *args); end
+  def password(message = T.unsafe(nil), mask = T.unsafe(nil)); end
+  def progress(arr, options = T.unsafe(nil)); end
+  def replace_tokens(str, hash); end
+  def say_error(*args); end
+  def say_ok(*args); end
+  def say_warning(*args); end
+  def speak(message, voice = T.unsafe(nil), rate = T.unsafe(nil)); end
+
+  class << self
+    def applescript(script); end
+    def ask_editor(input = T.unsafe(nil), preferred_editor = T.unsafe(nil)); end
+    def available_editor(preferred = T.unsafe(nil)); end
+    def choose(message = T.unsafe(nil), *choices, &block); end
+    def color(*args); end
+    def converse(prompt, responses = T.unsafe(nil)); end
+    def enable_paging; end
+    def io(input = T.unsafe(nil), output = T.unsafe(nil), &block); end
+    def log(action, *args); end
+    def password(message = T.unsafe(nil), mask = T.unsafe(nil)); end
+    def progress(arr, options = T.unsafe(nil)); end
+    def replace_tokens(str, hash); end
+    def say_error(*args); end
+    def say_ok(*args); end
+    def say_warning(*args); end
+    def speak(message, voice = T.unsafe(nil), rate = T.unsafe(nil)); end
+  end
+end
+
+module Commander::UI::AskForClass
+  def ask_for_array(prompt); end
+  def ask_for_file(prompt); end
+  def ask_for_float(prompt); end
+  def ask_for_integer(prompt); end
+  def ask_for_pathname(prompt); end
+  def ask_for_regexp(prompt); end
+  def ask_for_string(prompt); end
+  def ask_for_symbol(prompt); end
+  def method_missing(method_name, *arguments, &block); end
+
+  private
+
+  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
+end
+
+Commander::UI::AskForClass::DEPRECATED_CONSTANTS = T.let(T.unsafe(nil), Array)
+
+class Commander::UI::ProgressBar
+  def initialize(total, options = T.unsafe(nil)); end
+
+  def completed?; end
+  def erase_line; end
+  def finished?; end
+  def generate_tokens; end
+  def increment(tokens = T.unsafe(nil)); end
+  def percent_complete; end
+  def progress_bar; end
+  def show; end
+  def steps_remaining; end
+  def time_elapsed; end
+  def time_remaining; end
+end
+
+Commander::VERSION = T.let(T.unsafe(nil), String)
+
+class Object < ::BasicObject
+  include ::ActiveSupport::ForkTracker::CoreExt
+  include ::ActiveSupport::ForkTracker::CoreExtPrivate
+  include ::ActiveSupport::ToJsonWithActiveSupportEncoder
+  include ::Kernel
+  include ::JSON::Ext::Generator::GeneratorMethods::Object
+  include ::PP::ObjectMixin
+  include ::ActiveSupport::Tryable
+  include ::ActiveSupport::Dependencies::Loadable
+
+  def get_binding; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/connection_pool@2.2.5.rbi b/Library/Homebrew/sorbet/rbi/gems/connection_pool@2.2.5.rbi
index 38ff14aa21..8c9eca8967 100644
--- a/Library/Homebrew/sorbet/rbi/gems/connection_pool@2.2.5.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/connection_pool@2.2.5.rbi
@@ -22,12 +22,8 @@ class ConnectionPool
 end
 
 ConnectionPool::DEFAULTS = T.let(T.unsafe(nil), Hash)
-
-class ConnectionPool::Error < ::RuntimeError
-end
-
-class ConnectionPool::PoolShuttingDownError < ::ConnectionPool::Error
-end
+class ConnectionPool::Error < ::RuntimeError; end
+class ConnectionPool::PoolShuttingDownError < ::ConnectionPool::Error; end
 
 class ConnectionPool::TimedStack
   def initialize(size = T.unsafe(nil), &block); end
@@ -50,9 +46,7 @@ class ConnectionPool::TimedStack
   def try_create(options = T.unsafe(nil)); end
 end
 
-class ConnectionPool::TimeoutError < ::Timeout::Error
-end
-
+class ConnectionPool::TimeoutError < ::Timeout::Error; end
 ConnectionPool::VERSION = T.let(T.unsafe(nil), String)
 
 class ConnectionPool::Wrapper < ::BasicObject
diff --git a/Library/Homebrew/sorbet/rbi/gems/diff-lcs@1.4.4.rbi b/Library/Homebrew/sorbet/rbi/gems/diff-lcs@1.4.4.rbi
index a20cddbe1d..c91fde957d 100644
--- a/Library/Homebrew/sorbet/rbi/gems/diff-lcs@1.4.4.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/diff-lcs@1.4.4.rbi
@@ -1,7 +1,143 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `diff-lcs` gem.
-# Please instead update this file by running `tapioca generate --exclude json`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
+module Diff; end
 
+module Diff::LCS
+  def diff(other, callbacks = T.unsafe(nil), &block); end
+  def lcs(other, &block); end
+  def patch(patchset); end
+  def patch!(patchset); end
+  def patch_me(patchset); end
+  def sdiff(other, callbacks = T.unsafe(nil), &block); end
+  def traverse_balanced(other, callbacks = T.unsafe(nil), &block); end
+  def traverse_sequences(other, callbacks = T.unsafe(nil), &block); end
+  def unpatch(patchset); end
+  def unpatch!(patchset); end
+  def unpatch_me(patchset); end
+
+  class << self
+    def LCS(seq1, seq2, &block); end
+    def callbacks_for(callbacks); end
+    def diff(seq1, seq2, callbacks = T.unsafe(nil), &block); end
+    def lcs(seq1, seq2, &block); end
+    def patch(src, patchset, direction = T.unsafe(nil)); end
+    def patch!(src, patchset); end
+    def sdiff(seq1, seq2, callbacks = T.unsafe(nil), &block); end
+    def traverse_balanced(seq1, seq2, callbacks = T.unsafe(nil)); end
+    def traverse_sequences(seq1, seq2, callbacks = T.unsafe(nil)); end
+    def unpatch!(src, patchset); end
+
+    private
+
+    def diff_traversal(method, seq1, seq2, callbacks, &block); end
+  end
+end
+
+Diff::LCS::BalancedCallbacks = Diff::LCS::DefaultCallbacks
+
+class Diff::LCS::Change
+  include ::Comparable
+
+  def initialize(*args); end
+
+  def <=>(other); end
+  def ==(other); end
+  def action; end
+  def adding?; end
+  def changed?; end
+  def deleting?; end
+  def element; end
+  def finished_a?; end
+  def finished_b?; end
+  def inspect(*_args); end
+  def position; end
+  def to_a; end
+  def to_ary; end
+  def unchanged?; end
+
+  class << self
+    def from_a(arr); end
+    def valid_action?(action); end
+  end
+end
+
+Diff::LCS::Change::IntClass = Integer
+Diff::LCS::Change::VALID_ACTIONS = T.let(T.unsafe(nil), Array)
+
+class Diff::LCS::ContextChange < ::Diff::LCS::Change
+  def initialize(*args); end
+
+  def <=>(other); end
+  def ==(other); end
+  def new_element; end
+  def new_position; end
+  def old_element; end
+  def old_position; end
+  def to_a; end
+  def to_ary; end
+
+  class << self
+    def from_a(arr); end
+    def simplify(event); end
+  end
+end
+
+class Diff::LCS::ContextDiffCallbacks < ::Diff::LCS::DiffCallbacks
+  def change(event); end
+  def discard_a(event); end
+  def discard_b(event); end
+end
+
+class Diff::LCS::DefaultCallbacks
+  class << self
+    def change(event); end
+    def discard_a(event); end
+    def discard_b(event); end
+    def match(event); end
+  end
+end
+
+class Diff::LCS::DiffCallbacks
+  def initialize; end
+
+  def diffs; end
+  def discard_a(event); end
+  def discard_b(event); end
+  def finish; end
+  def match(_event); end
+
+  private
+
+  def finish_hunk; end
+end
+
+module Diff::LCS::Internals
+  class << self
+    def analyze_patchset(patchset, depth = T.unsafe(nil)); end
+    def intuit_diff_direction(src, patchset, limit = T.unsafe(nil)); end
+    def lcs(a, b); end
+
+    private
+
+    def inverse_vector(a, vector); end
+    def position_hash(enum, interval); end
+    def replace_next_larger(enum, value, last_index = T.unsafe(nil)); end
+  end
+end
+
+class Diff::LCS::SDiffCallbacks
+  def initialize; end
+
+  def change(event); end
+  def diffs; end
+  def discard_a(event); end
+  def discard_b(event); end
+  def match(event); end
+end
+
+Diff::LCS::SequenceCallbacks = Diff::LCS::DefaultCallbacks
+Diff::LCS::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/docile@1.4.0.rbi b/Library/Homebrew/sorbet/rbi/gems/docile@1.4.0.rbi
index f1412c4902..1f8415fe28 100644
--- a/Library/Homebrew/sorbet/rbi/gems/docile@1.4.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/docile@1.4.0.rbi
@@ -4,5 +4,51 @@
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module Docile
+  extend ::Docile::Execution
+
+  private
+
+  def dsl_eval(dsl, *args, &block); end
+  def dsl_eval_immutable(dsl, *args, &block); end
+  def dsl_eval_with_block_return(dsl, *args, &block); end
+
+  class << self
+    def dsl_eval(dsl, *args, &block); end
+    def dsl_eval_immutable(dsl, *args, &block); end
+    def dsl_eval_with_block_return(dsl, *args, &block); end
+  end
+end
+
+module Docile::BacktraceFilter
+  def backtrace; end
+  def backtrace_locations; end
+end
+
+Docile::BacktraceFilter::FILTER_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+class Docile::ChainingFallbackContextProxy < ::Docile::FallbackContextProxy
+  def method_missing(method, *args, &block); end
+end
+
+module Docile::Execution
+  private
+
+  def exec_in_proxy_context(dsl, proxy_type, *args, &block); end
+
+  class << self
+    def exec_in_proxy_context(dsl, proxy_type, *args, &block); end
+  end
+end
+
+class Docile::FallbackContextProxy
+  def initialize(receiver, fallback); end
+
+  def instance_variables; end
+  def method_missing(method, *args, &block); end
+end
+
+Docile::FallbackContextProxy::NON_FALLBACK_METHODS = T.let(T.unsafe(nil), Set)
+Docile::FallbackContextProxy::NON_PROXIED_INSTANCE_VARIABLES = T.let(T.unsafe(nil), Set)
+Docile::FallbackContextProxy::NON_PROXIED_METHODS = T.let(T.unsafe(nil), Set)
+Docile::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/domain_name@0.5.20190701.rbi b/Library/Homebrew/sorbet/rbi/gems/domain_name@0.5.20190701.rbi
index 37d499cd1b..74537b6724 100644
--- a/Library/Homebrew/sorbet/rbi/gems/domain_name@0.5.20190701.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/domain_name@0.5.20190701.rbi
@@ -1,6 +1,6 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `domain_name` gem.
-# Please instead update this file by running `tapioca generate --exclude json`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
@@ -38,9 +38,7 @@ class DomainName
 end
 
 DomainName::DOT = T.let(T.unsafe(nil), String)
-
 DomainName::ETLD_DATA = T.let(T.unsafe(nil), Hash)
-
 DomainName::ETLD_DATA_DATE = T.let(T.unsafe(nil), String)
 
 module DomainName::Punycode
@@ -52,42 +50,22 @@ module DomainName::Punycode
   end
 end
 
-class DomainName::Punycode::ArgumentError < ::ArgumentError
-end
-
+class DomainName::Punycode::ArgumentError < ::ArgumentError; end
 DomainName::Punycode::BASE = T.let(T.unsafe(nil), Integer)
-
-class DomainName::Punycode::BufferOverflowError < ::DomainName::Punycode::ArgumentError
-end
-
+class DomainName::Punycode::BufferOverflowError < ::DomainName::Punycode::ArgumentError; end
 DomainName::Punycode::CUTOFF = T.let(T.unsafe(nil), Integer)
-
 DomainName::Punycode::DAMP = T.let(T.unsafe(nil), Integer)
-
 DomainName::Punycode::DECODE_DIGIT = T.let(T.unsafe(nil), Hash)
-
 DomainName::Punycode::DELIMITER = T.let(T.unsafe(nil), String)
-
 DomainName::Punycode::DOT = T.let(T.unsafe(nil), String)
-
 DomainName::Punycode::ENCODE_DIGIT = T.let(T.unsafe(nil), Proc)
-
 DomainName::Punycode::INITIAL_BIAS = T.let(T.unsafe(nil), Integer)
-
 DomainName::Punycode::INITIAL_N = T.let(T.unsafe(nil), Integer)
-
 DomainName::Punycode::LOBASE = T.let(T.unsafe(nil), Integer)
-
 DomainName::Punycode::MAXINT = T.let(T.unsafe(nil), Integer)
-
 DomainName::Punycode::PREFIX = T.let(T.unsafe(nil), String)
-
 DomainName::Punycode::RE_NONBASIC = T.let(T.unsafe(nil), Regexp)
-
 DomainName::Punycode::SKEW = T.let(T.unsafe(nil), Integer)
-
 DomainName::Punycode::TMAX = T.let(T.unsafe(nil), Integer)
-
 DomainName::Punycode::TMIN = T.let(T.unsafe(nil), Integer)
-
 DomainName::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/ecma-re-validator@0.3.0.rbi b/Library/Homebrew/sorbet/rbi/gems/ecma-re-validator@0.3.0.rbi
index f8d792df4c..5580de04da 100644
--- a/Library/Homebrew/sorbet/rbi/gems/ecma-re-validator@0.3.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/ecma-re-validator@0.3.0.rbi
@@ -4,5 +4,12 @@
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module EcmaReValidator
+  class << self
+    def valid?(input); end
+  end
+end
+
+EcmaReValidator::INVALID_REGEXP = T.let(T.unsafe(nil), Array)
+EcmaReValidator::INVALID_TOKENS = T.let(T.unsafe(nil), Array)
+EcmaReValidator::UNICODE_CHARACTERS = T.let(T.unsafe(nil), Array)
diff --git a/Library/Homebrew/sorbet/rbi/gems/elftools@1.1.3.rbi b/Library/Homebrew/sorbet/rbi/gems/elftools@1.1.3.rbi
index 45a0baab0e..2237a85802 100644
--- a/Library/Homebrew/sorbet/rbi/gems/elftools@1.1.3.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/elftools@1.1.3.rbi
@@ -1,191 +1,106 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `elftools` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-module ELFTools
-end
+module ELFTools; end
 
 module ELFTools::Constants
-  include(::ELFTools::Constants::DF)
-  include(::ELFTools::Constants::DT)
-  include(::ELFTools::Constants::EM)
-  include(::ELFTools::Constants::ET)
-  include(::ELFTools::Constants::PF)
-  include(::ELFTools::Constants::PT)
-  include(::ELFTools::Constants::SHN)
-  include(::ELFTools::Constants::SHT)
-  include(::ELFTools::Constants::STB)
-  include(::ELFTools::Constants::STT)
-end
-
-module ELFTools::Constants::DF
+  include ::ELFTools::Constants::DF
+  include ::ELFTools::Constants::DT
+  include ::ELFTools::Constants::EM
+  include ::ELFTools::Constants::ET
+  include ::ELFTools::Constants::PF
+  include ::ELFTools::Constants::PT
+  include ::ELFTools::Constants::SHN
+  include ::ELFTools::Constants::SHT
+  include ::ELFTools::Constants::STB
+  include ::ELFTools::Constants::STT
 end
 
+module ELFTools::Constants::DF; end
 ELFTools::Constants::DF::DF_1_CONFALT = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_DIRECT = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_DISPRELDNE = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_DISPRELPND = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_EDITED = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_ENDFILTEE = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_GLOBAL = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_GLOBAUDIT = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_GROUP = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_IGNMULDEF = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_INITFIRST = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_INTERPOSE = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_LOADFLTR = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_NODEFLIB = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_NODELETE = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_NODIRECT = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_NODUMP = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_NOHDR = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_NOKSYMS = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_NOOPEN = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_NORELOC = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_NOW = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_ORIGIN = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_SINGLETON = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_SYMINTPOSE = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_1_TRANS = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_BIND_NOW = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_ORIGIN = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_STATIC_TLS = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_SYMBOLIC = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DF::DF_TEXTREL = T.let(T.unsafe(nil), Integer)
-
-module ELFTools::Constants::DT
-end
-
+module ELFTools::Constants::DT; end
 ELFTools::Constants::DT::DT_ADDRRNGHI = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_ADDRRNGLO = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_BIND_NOW = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_DEBUG = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_ENCODING = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_FINI = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_FINI_ARRAY = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_FINI_ARRAYSZ = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_FLAGS = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_FLAGS_1 = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_GNU_HASH = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_HASH = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_HIOS = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_HIPROC = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_INIT = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_INIT_ARRAY = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_INIT_ARRAYSZ = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_JMPREL = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_LOOS = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_LOPROC = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_NEEDED = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_NULL = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_PLTGOT = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_PLTREL = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_PLTRELSZ = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_REL = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_RELA = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_RELACOUNT = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_RELAENT = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_RELASZ = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_RELCOUNT = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_RELENT = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_RELSZ = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_RPATH = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_RUNPATH = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_SONAME = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_STRSZ = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_STRTAB = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_SYMBOLIC = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_SYMENT = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_SYMTAB = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_TEXTREL = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_VALRNGHI = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_VALRNGLO = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_VERDEF = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_VERDEFNUM = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_VERNEED = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_VERNEEDNUM = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::DT::DT_VERSYM = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::ELFMAG = T.let(T.unsafe(nil), String)
 
 module ELFTools::Constants::EM
@@ -195,85 +110,45 @@ module ELFTools::Constants::EM
 end
 
 ELFTools::Constants::EM::EM_386 = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_486 = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_68K = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_860 = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_88K = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_AARCH64 = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_ALPHA = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_ALTERA_NIOS2 = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_ARM = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_AVR32 = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_BLACKFIN = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_BPF = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_CRIS = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_CYGNUS_M32R = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_CYGNUS_MN10300 = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_FRV = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_H8_300 = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_IA_64 = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_M32 = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_M32R = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_MICROBLAZE = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_MIPS = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_MIPS_RS3_LE = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_MIPS_RS4_BE = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_MN10300 = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_NONE = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_OPENRISC = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_PARISC = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_PPC = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_PPC64 = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_S390 = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_S390_OLD = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_SH = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_SPARC = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_SPARC32PLUS = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_SPARCV9 = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_SPU = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_TILEGX = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_TILEPRO = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_TI_C6000 = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::EM::EM_X86_64 = T.let(T.unsafe(nil), Integer)
 
 module ELFTools::Constants::ET
@@ -283,151 +158,75 @@ module ELFTools::Constants::ET
 end
 
 ELFTools::Constants::ET::ET_CORE = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::ET::ET_DYN = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::ET::ET_EXEC = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::ET::ET_NONE = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::ET::ET_REL = T.let(T.unsafe(nil), Integer)
-
-module ELFTools::Constants::PF
-end
-
+module ELFTools::Constants::PF; end
 ELFTools::Constants::PF::PF_R = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::PF::PF_W = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::PF::PF_X = T.let(T.unsafe(nil), Integer)
-
-module ELFTools::Constants::PT
-end
-
+module ELFTools::Constants::PT; end
 ELFTools::Constants::PT::PT_DYNAMIC = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::PT::PT_GNU_EH_FRAME = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::PT::PT_GNU_RELRO = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::PT::PT_GNU_STACK = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::PT::PT_HIOS = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::PT::PT_HIPROC = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::PT::PT_INTERP = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::PT::PT_LOAD = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::PT::PT_LOOS = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::PT::PT_LOPROC = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::PT::PT_NOTE = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::PT::PT_NULL = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::PT::PT_PHDR = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::PT::PT_SHLIB = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::PT::PT_TLS = T.let(T.unsafe(nil), Integer)
-
-module ELFTools::Constants::SHN
-end
-
+module ELFTools::Constants::SHN; end
 ELFTools::Constants::SHN::SHN_LORESERVE = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::SHN::SHN_UNDEF = T.let(T.unsafe(nil), Integer)
-
-module ELFTools::Constants::SHT
-end
-
+module ELFTools::Constants::SHT; end
 ELFTools::Constants::SHT::SHT_DYNAMIC = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::SHT::SHT_DYNSYM = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::SHT::SHT_HASH = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::SHT::SHT_HIPROC = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::SHT::SHT_HIUSER = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::SHT::SHT_LOPROC = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::SHT::SHT_LOUSER = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::SHT::SHT_NOBITS = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::SHT::SHT_NOTE = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::SHT::SHT_NULL = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::SHT::SHT_PROGBITS = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::SHT::SHT_REL = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::SHT::SHT_RELA = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::SHT::SHT_SHLIB = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::SHT::SHT_STRTAB = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::SHT::SHT_SYMTAB = T.let(T.unsafe(nil), Integer)
-
-module ELFTools::Constants::STB
-end
-
+module ELFTools::Constants::STB; end
 ELFTools::Constants::STB::STB_GLOBAL = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::STB::STB_GNU_UNIQUE = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::STB::STB_HIOS = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::STB::STB_HIPROC = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::STB::STB_LOCAL = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::STB::STB_LOOS = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::STB::STB_LOPROC = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::STB::STB_NUM = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::STB::STB_WEAK = T.let(T.unsafe(nil), Integer)
-
-module ELFTools::Constants::STT
-end
-
+module ELFTools::Constants::STT; end
 ELFTools::Constants::STT::STT_ARM_TFUNC = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::STT::STT_COMMON = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::STT::STT_FILE = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::STT::STT_FUNC = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::STT::STT_GNU_IFUNC = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::STT::STT_HIOS = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::STT::STT_HIPROC = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::STT::STT_LOOS = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::STT::STT_LOPROC = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::STT::STT_NOTYPE = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::STT::STT_NUM = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::STT::STT_OBJECT = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::STT::STT_SECTION = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::STT::STT_SPARC_REGISTER = T.let(T.unsafe(nil), Integer)
-
 ELFTools::Constants::STT::STT_TLS = T.let(T.unsafe(nil), Integer)
 
 module ELFTools::Dynamic
@@ -454,15 +253,9 @@ class ELFTools::Dynamic::Tag
 end
 
 ELFTools::Dynamic::Tag::TYPE_WITH_NAME = T.let(T.unsafe(nil), Array)
-
-class ELFTools::ELFClassError < ::ELFTools::ELFError
-end
-
-class ELFTools::ELFDataError < ::ELFTools::ELFError
-end
-
-class ELFTools::ELFError < ::StandardError
-end
+class ELFTools::ELFClassError < ::ELFTools::ELFError; end
+class ELFTools::ELFDataError < ::ELFTools::ELFError; end
+class ELFTools::ELFError < ::StandardError; end
 
 class ELFTools::ELFFile
   def initialize(stream); end
@@ -499,8 +292,7 @@ class ELFTools::ELFFile
   def loaded_headers; end
 end
 
-class ELFTools::ELFMagicError < ::ELFTools::ELFError
-end
+class ELFTools::ELFMagicError < ::ELFTools::ELFError; end
 
 class ELFTools::LazyArray
   def initialize(size, &block); end
@@ -546,17 +338,16 @@ class ELFTools::Relocation
   def mask_bit; end
 end
 
-module ELFTools::Sections
-end
+module ELFTools::Sections; end
 
 class ELFTools::Sections::DynamicSection < ::ELFTools::Sections::Section
-  include(::ELFTools::Dynamic)
+  include ::ELFTools::Dynamic
 
   def tag_start; end
 end
 
 class ELFTools::Sections::NoteSection < ::ELFTools::Sections::Section
-  include(::ELFTools::Note)
+  include ::ELFTools::Note
 
   def note_start; end
   def note_total_size; end
@@ -620,11 +411,10 @@ class ELFTools::Sections::Symbol
   def stream; end
 end
 
-module ELFTools::Segments
-end
+module ELFTools::Segments; end
 
 class ELFTools::Segments::DynamicSegment < ::ELFTools::Segments::Segment
-  include(::ELFTools::Dynamic)
+  include ::ELFTools::Dynamic
 
   def tag_start; end
 end
@@ -647,7 +437,7 @@ class ELFTools::Segments::LoadSegment < ::ELFTools::Segments::Segment
 end
 
 class ELFTools::Segments::NoteSegment < ::ELFTools::Segments::Segment
-  include(::ELFTools::Note)
+  include ::ELFTools::Note
 
   def note_start; end
   def note_total_size; end
@@ -669,8 +459,7 @@ class ELFTools::Segments::Segment
   end
 end
 
-module ELFTools::Structs
-end
+module ELFTools::Structs; end
 
 class ELFTools::Structs::ELF32_Phdr < ::ELFTools::Structs::ELFStruct
   class << self
@@ -702,9 +491,9 @@ end
 
 class ELFTools::Structs::ELFStruct < ::BinData::Record
   def elf_class; end
-  def elf_class=(_); end
+  def elf_class=(_arg0); end
   def offset; end
-  def offset=(_); end
+  def offset=(_arg0); end
   def patches; end
 
   class << self
@@ -764,7 +553,7 @@ end
 ELFTools::Structs::ELF_sym = T.let(T.unsafe(nil), Hash)
 
 module ELFTools::Util
-  extend(::ELFTools::Util::ClassMethods)
+  extend ::ELFTools::Util::ClassMethods
 end
 
 module ELFTools::Util::ClassMethods
@@ -773,3 +562,5 @@ module ELFTools::Util::ClassMethods
   def select_by_type(enum, type); end
   def to_constant(mod, val); end
 end
+
+ELFTools::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/hana@1.3.7.rbi b/Library/Homebrew/sorbet/rbi/gems/hana@1.3.7.rbi
index 3db1f77715..724d9950da 100644
--- a/Library/Homebrew/sorbet/rbi/gems/hana@1.3.7.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/hana@1.3.7.rbi
@@ -4,5 +4,63 @@
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module Hana; end
+
+class Hana::Patch
+  def initialize(is); end
+
+  def apply(doc); end
+
+  private
+
+  def add(ins, doc); end
+  def add_op(dest, key, obj); end
+  def check_index(obj, key); end
+  def copy(ins, doc); end
+  def get_path(ins); end
+  def move(ins, doc); end
+  def remove(ins, doc); end
+  def replace(ins, doc); end
+  def rm_op(obj, key); end
+  def test(ins, doc); end
+end
+
+class Hana::Patch::Exception < ::StandardError; end
+Hana::Patch::FROM = T.let(T.unsafe(nil), String)
+
+class Hana::Patch::FailedTestException < ::Hana::Patch::Exception
+  def initialize(path, value); end
+
+  def path; end
+  def path=(_arg0); end
+  def value; end
+  def value=(_arg0); end
+end
+
+class Hana::Patch::IndexError < ::Hana::Patch::Exception; end
+class Hana::Patch::InvalidObjectOperationException < ::Hana::Patch::Exception; end
+class Hana::Patch::InvalidPath < ::Hana::Patch::Exception; end
+class Hana::Patch::MissingTargetException < ::Hana::Patch::Exception; end
+class Hana::Patch::ObjectOperationOnArrayException < ::Hana::Patch::Exception; end
+class Hana::Patch::OutOfBoundsException < ::Hana::Patch::Exception; end
+Hana::Patch::VALID = T.let(T.unsafe(nil), Hash)
+Hana::Patch::VALUE = T.let(T.unsafe(nil), String)
+
+class Hana::Pointer
+  include ::Enumerable
+
+  def initialize(path); end
+
+  def each(&block); end
+  def eval(object); end
+
+  class << self
+    def eval(list, object); end
+    def parse(path); end
+  end
+end
+
+Hana::Pointer::ESC = T.let(T.unsafe(nil), Hash)
+class Hana::Pointer::Exception < ::StandardError; end
+class Hana::Pointer::FormatError < ::Hana::Pointer::Exception; end
+Hana::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/highline@2.0.3.rbi b/Library/Homebrew/sorbet/rbi/gems/highline@2.0.3.rbi
index c36660a836..d2c18030ff 100644
--- a/Library/Homebrew/sorbet/rbi/gems/highline@2.0.3.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/highline@2.0.3.rbi
@@ -1,7 +1,851 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `highline` gem.
-# Please instead update this file by running `tapioca generate --exclude json`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
+class HighLine
+  include ::HighLine::BuiltinStyles
+  include ::HighLine::CustomErrors
+  extend ::HighLine::BuiltinStyles::ClassMethods
+  extend ::SingleForwardable
 
+  def initialize(input = T.unsafe(nil), output = T.unsafe(nil), wrap_at = T.unsafe(nil), page_at = T.unsafe(nil), indent_size = T.unsafe(nil), indent_level = T.unsafe(nil)); end
+
+  def agree(yes_or_no_question, character = T.unsafe(nil)); end
+  def ask(template_or_question, answer_type = T.unsafe(nil), &details); end
+  def choose(*items, &details); end
+  def color(string, *colors); end
+  def color_code(*colors); end
+  def get_response_character_mode(question); end
+  def get_response_getc_mode(question); end
+  def get_response_line_mode(question); end
+  def indent(increase = T.unsafe(nil), statement = T.unsafe(nil), multiline = T.unsafe(nil)); end
+  def indent_level; end
+  def indent_level=(_arg0); end
+  def indent_size; end
+  def indent_size=(_arg0); end
+  def indentation; end
+  def input; end
+  def key; end
+  def key=(_arg0); end
+  def list(items, mode = T.unsafe(nil), option = T.unsafe(nil)); end
+  def multi_indent; end
+  def multi_indent=(_arg0); end
+  def new_scope; end
+  def newline; end
+  def output; end
+  def output_cols; end
+  def output_rows; end
+  def page_at; end
+  def page_at=(setting); end
+  def puts(*args); end
+  def render_statement(statement); end
+  def reset_use_color; end
+  def say(statement); end
+  def shell_style_lambda(menu); end
+  def terminal; end
+  def track_eof; end
+  def track_eof=(_arg0); end
+  def track_eof?; end
+  def uncolor(string); end
+  def use_color; end
+  def use_color=(_arg0); end
+  def use_color?; end
+  def wrap_at; end
+  def wrap_at=(setting); end
+
+  private
+
+  def actual_length(text); end
+  def confirm(question); end
+  def default_use_color; end
+  def erase_current_line; end
+  def get_line(question); end
+  def get_line_raw_no_echo_mode(question); end
+  def ignore_arrow_key; end
+  def last_answer(answers); end
+  def line_overflow_for_question?(line, question); end
+  def output_erase_char; end
+  def say_last_char_or_echo_char(line, question); end
+  def say_new_line_or_overwrite(question); end
+  def unique_answers(list); end
+
+  class << self
+    def String(s); end
+    def Style(*args); end
+    def agree(*args, &block); end
+    def ask(*args, &block); end
+    def choose(*args, &block); end
+    def color(*args, &block); end
+    def color_code(*args, &block); end
+    def color_scheme; end
+    def color_scheme=(_arg0); end
+    def colorize_strings; end
+    def default_instance; end
+    def default_instance=(_arg0); end
+    def find_or_create_style(arg); end
+    def find_or_create_style_list(*args); end
+    def reset; end
+    def reset_color_scheme; end
+    def reset_use_color(*args, &block); end
+    def say(*args, &block); end
+    def supports_rgb_color?; end
+    def track_eof=(*args, &block); end
+    def track_eof?(*args, &block); end
+    def uncolor(*args, &block); end
+    def use_color=(*args, &block); end
+    def use_color?(*args, &block); end
+    def using_color_scheme?; end
+  end
+end
+
+module HighLine::BuiltinStyles
+  mixes_in_class_methods ::HighLine::BuiltinStyles::ClassMethods
+
+  class << self
+    def included(base); end
+  end
+end
+
+HighLine::BuiltinStyles::BASIC_COLORS = T.let(T.unsafe(nil), Array)
+HighLine::BuiltinStyles::BLACK = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::BLACK_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::BLINK = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::BLINK_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::BLUE = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::BLUE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::BOLD = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::BOLD_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::BRIGHT_BLACK = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::BRIGHT_BLACK_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::BRIGHT_BLUE = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::BRIGHT_BLUE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::BRIGHT_CYAN = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::BRIGHT_CYAN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::BRIGHT_GRAY = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::BRIGHT_GRAY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::BRIGHT_GREEN = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::BRIGHT_GREEN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::BRIGHT_GREY = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::BRIGHT_GREY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::BRIGHT_MAGENTA = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::BRIGHT_MAGENTA_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::BRIGHT_NONE = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::BRIGHT_NONE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::BRIGHT_RED = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::BRIGHT_RED_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::BRIGHT_WHITE = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::BRIGHT_WHITE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::BRIGHT_YELLOW = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::BRIGHT_YELLOW_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::CLEAR = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::CLEAR_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::COLORS = T.let(T.unsafe(nil), Array)
+HighLine::BuiltinStyles::COLOR_LIST = T.let(T.unsafe(nil), Hash)
+HighLine::BuiltinStyles::CONCEALED = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::CONCEALED_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::CYAN = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::CYAN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+
+module HighLine::BuiltinStyles::ClassMethods
+  def const_missing(name); end
+end
+
+HighLine::BuiltinStyles::ClassMethods::RGB_COLOR_PATTERN = T.let(T.unsafe(nil), Regexp)
+HighLine::BuiltinStyles::DARK = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::DARK_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ERASE_CHAR = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ERASE_CHAR_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ERASE_LINE = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ERASE_LINE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::GRAY = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::GRAY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::GREEN = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::GREEN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::GREY = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::GREY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::LIGHT_BLACK = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::LIGHT_BLACK_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::LIGHT_BLUE = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::LIGHT_BLUE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::LIGHT_CYAN = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::LIGHT_CYAN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::LIGHT_GRAY = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::LIGHT_GRAY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::LIGHT_GREEN = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::LIGHT_GREEN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::LIGHT_GREY = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::LIGHT_GREY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::LIGHT_MAGENTA = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::LIGHT_MAGENTA_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::LIGHT_NONE = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::LIGHT_NONE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::LIGHT_RED = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::LIGHT_RED_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::LIGHT_WHITE = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::LIGHT_WHITE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::LIGHT_YELLOW = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::LIGHT_YELLOW_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::MAGENTA = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::MAGENTA_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::NONE = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::NONE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_BLACK = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_BLACK_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_BLUE = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_BLUE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_BRIGHT_BLACK = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_BRIGHT_BLACK_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_BRIGHT_BLUE = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_BRIGHT_BLUE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_BRIGHT_CYAN = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_BRIGHT_CYAN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_BRIGHT_GRAY = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_BRIGHT_GRAY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_BRIGHT_GREEN = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_BRIGHT_GREEN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_BRIGHT_GREY = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_BRIGHT_GREY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_BRIGHT_MAGENTA = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_BRIGHT_MAGENTA_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_BRIGHT_NONE = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_BRIGHT_NONE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_BRIGHT_RED = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_BRIGHT_RED_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_BRIGHT_WHITE = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_BRIGHT_WHITE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_BRIGHT_YELLOW = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_BRIGHT_YELLOW_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_CYAN = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_CYAN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_GRAY = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_GRAY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_GREEN = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_GREEN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_GREY = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_GREY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_LIGHT_BLACK = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_LIGHT_BLACK_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_LIGHT_BLUE = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_LIGHT_BLUE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_LIGHT_CYAN = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_LIGHT_CYAN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_LIGHT_GRAY = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_LIGHT_GRAY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_LIGHT_GREEN = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_LIGHT_GREEN_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_LIGHT_GREY = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_LIGHT_GREY_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_LIGHT_MAGENTA = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_LIGHT_MAGENTA_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_LIGHT_NONE = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_LIGHT_NONE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_LIGHT_RED = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_LIGHT_RED_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_LIGHT_WHITE = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_LIGHT_WHITE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_LIGHT_YELLOW = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_LIGHT_YELLOW_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_MAGENTA = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_MAGENTA_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_NONE = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_NONE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_RED = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_RED_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_WHITE = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_WHITE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::ON_YELLOW = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::ON_YELLOW_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::RED = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::RED_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::RESET = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::RESET_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::REVERSE = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::REVERSE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::STYLES = T.let(T.unsafe(nil), Array)
+HighLine::BuiltinStyles::STYLE_LIST = T.let(T.unsafe(nil), Hash)
+HighLine::BuiltinStyles::UNDERLINE = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::UNDERLINE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::UNDERSCORE = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::UNDERSCORE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::WHITE = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::WHITE_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+HighLine::BuiltinStyles::YELLOW = T.let(T.unsafe(nil), String)
+HighLine::BuiltinStyles::YELLOW_STYLE = T.let(T.unsafe(nil), HighLine::Style)
+
+class HighLine::ColorScheme
+  def initialize(h = T.unsafe(nil)); end
+
+  def [](color_tag); end
+  def []=(color_tag, constants); end
+  def definition(color_tag); end
+  def include?(color_tag); end
+  def keys; end
+  def load_from_hash(h); end
+  def to_hash; end
+
+  private
+
+  def to_constant(v); end
+  def to_symbol(t); end
+end
+
+module HighLine::CustomErrors; end
+
+class HighLine::CustomErrors::ExplainableError < ::StandardError
+  def explanation_key; end
+end
+
+class HighLine::CustomErrors::NoAutoCompleteMatch < ::HighLine::CustomErrors::ExplainableError
+  def explanation_key; end
+end
+
+class HighLine::CustomErrors::NoConfirmationQuestionError < ::HighLine::CustomErrors::ExplainableError
+  def explanation_key; end
+end
+
+class HighLine::CustomErrors::NotInRangeQuestionError < ::HighLine::CustomErrors::ExplainableError
+  def explanation_key; end
+end
+
+class HighLine::CustomErrors::NotValidQuestionError < ::HighLine::CustomErrors::ExplainableError
+  def explanation_key; end
+end
+
+class HighLine::CustomErrors::QuestionError < ::HighLine::CustomErrors::ExplainableError
+  def explanation_key; end
+end
+
+class HighLine::List
+  def initialize(items, options = T.unsafe(nil)); end
+
+  def col_down; end
+  def col_down_mode; end
+  def cols; end
+  def cols=(cols); end
+  def items; end
+  def list; end
+  def row_join_str_size; end
+  def row_join_string; end
+  def row_join_string=(_arg0); end
+  def slice_by_cols; end
+  def slice_by_rows; end
+  def to_a; end
+  def to_s; end
+  def transpose; end
+  def transpose_mode; end
+
+  private
+
+  def build; end
+  def items_sliced_by_cols; end
+  def items_sliced_by_rows; end
+  def row_count; end
+  def stringfy(row); end
+end
+
+class HighLine::ListRenderer
+  def initialize(items, mode = T.unsafe(nil), option = T.unsafe(nil), highline); end
+
+  def highline; end
+  def items; end
+  def mode; end
+  def option; end
+  def render; end
+
+  private
+
+  def actual_length(text); end
+  def actual_lengths_for(line); end
+  def col_count; end
+  def col_count_calculate; end
+  def get_col_widths(lines); end
+  def get_row_widths(lines); end
+  def get_segment_widths(lines); end
+  def inside_line_size_limit?(widths); end
+  def items_max_length; end
+  def line_size_limit; end
+  def list_columns_across_mode; end
+  def list_columns_down_mode; end
+  def list_default_mode; end
+  def list_inline_mode; end
+  def list_uneven_columns_down_mode; end
+  def list_uneven_columns_mode(list = T.unsafe(nil)); end
+  def max_length(items); end
+  def pad_char; end
+  def pad_uneven_rows(list, widths); end
+  def render_list_items(items); end
+  def right_pad_field(field, width); end
+  def right_pad_row(row, widths); end
+  def right_padded_items; end
+  def row_count; end
+  def row_join_str_size; end
+  def row_join_string; end
+  def row_join_string=(_arg0); end
+  def row_to_s(row); end
+  def stringfy_list(list); end
+  def transpose(lines); end
+end
+
+class HighLine::Menu < ::HighLine::Question
+  def initialize; end
+
+  def add_item(item); end
+  def all_items; end
+  def build_item(*args); end
+  def choice(name, help = T.unsafe(nil), text = T.unsafe(nil), &action); end
+  def choices(*names, &action); end
+  def decorate_index(index); end
+  def decorate_item(text, ix); end
+  def find_item_from_selection(items, selection); end
+  def flow; end
+  def flow=(_arg0); end
+  def gather_selected(highline_context, selections, details = T.unsafe(nil)); end
+  def get_item_by_letter(items, selection); end
+  def get_item_by_number(items, selection); end
+  def header; end
+  def header=(_arg0); end
+  def help(topic, help); end
+  def hidden(name, help = T.unsafe(nil), &action); end
+  def index; end
+  def index=(style); end
+  def index_color; end
+  def index_color=(_arg0); end
+  def index_suffix; end
+  def index_suffix=(_arg0); end
+  def init_help; end
+  def layout; end
+  def layout=(new_layout); end
+  def list_option; end
+  def list_option=(_arg0); end
+  def map_items_by_index; end
+  def map_items_by_name; end
+  def mark_for_decoration(text, ix); end
+  def nil_on_handled; end
+  def nil_on_handled=(_arg0); end
+  def options; end
+  def parse_list; end
+  def prompt; end
+  def prompt=(_arg0); end
+  def select(highline_context, selection, details = T.unsafe(nil)); end
+  def select_by; end
+  def select_by=(_arg0); end
+  def shell; end
+  def shell=(_arg0); end
+  def show_default_if_any; end
+  def to_ary; end
+  def to_s; end
+  def update_responses; end
+  def value_for_array_selections(items, selections, details); end
+  def value_for_hash_selections(items, selections, details); end
+  def value_for_selected_item(item, details); end
+
+  class << self
+    def index_color; end
+    def index_color=(_arg0); end
+  end
+end
+
+class HighLine::Menu::Item
+  def initialize(name, attributes); end
+
+  def action; end
+  def help; end
+  def item_help; end
+  def name; end
+  def text; end
+end
+
+class HighLine::Paginator
+  def initialize(highline); end
+
+  def continue_paging?; end
+  def highline; end
+  def page_print(text); end
+end
+
+class HighLine::Question
+  include ::HighLine::CustomErrors
+
+  def initialize(template, answer_type); end
+
+  def above; end
+  def above=(_arg0); end
+  def answer; end
+  def answer=(_arg0); end
+  def answer_or_default(answer_string); end
+  def answer_type; end
+  def answer_type=(_arg0); end
+  def ask_on_error_msg; end
+  def below; end
+  def below=(_arg0); end
+  def build_responses(message_source = T.unsafe(nil)); end
+  def build_responses_new_hash(message_source); end
+  def case; end
+  def case=(_arg0); end
+  def change_case(answer_string); end
+  def character; end
+  def character=(_arg0); end
+  def check_range; end
+  def choices_complete(answer_string); end
+  def completion; end
+  def completion=(_arg0); end
+  def confirm; end
+  def confirm=(_arg0); end
+  def confirm_question(highline); end
+  def convert; end
+  def default; end
+  def default=(_arg0); end
+  def default_responses_hash; end
+  def directory; end
+  def directory=(_arg0); end
+  def echo; end
+  def echo=(_arg0); end
+  def expected_range; end
+  def final_response(error); end
+  def final_responses; end
+  def first_answer; end
+  def first_answer=(_arg0); end
+  def first_answer?; end
+  def format_answer(answer_string); end
+  def gather; end
+  def gather=(_arg0); end
+  def get_echo_for_response(response); end
+  def get_response(highline); end
+  def get_response_or_default(highline); end
+  def glob; end
+  def glob=(_arg0); end
+  def in; end
+  def in=(_arg0); end
+  def in_range?; end
+  def limit; end
+  def limit=(_arg0); end
+  def overwrite; end
+  def overwrite=(_arg0); end
+  def readline; end
+  def readline=(_arg0); end
+  def remove_whitespace(answer_string); end
+  def responses; end
+  def selection; end
+  def show_question(highline); end
+  def template; end
+  def template=(_arg0); end
+  def to_s; end
+  def valid_answer?; end
+  def validate; end
+  def validate=(_arg0); end
+  def verify_match; end
+  def verify_match=(_arg0); end
+  def whitespace; end
+  def whitespace=(_arg0); end
+
+  private
+
+  def append_default; end
+  def choice_error_str(message_source); end
+
+  class << self
+    def build(template_or_question, answer_type = T.unsafe(nil), &details); end
+  end
+end
+
+class HighLine::Question::AnswerConverter
+  extend ::Forwardable
+
+  def initialize(question); end
+
+  def answer(*args, &block); end
+  def answer=(*args, &block); end
+  def answer_type(*args, &block); end
+  def check_range(*args, &block); end
+  def choices_complete(*args, &block); end
+  def convert; end
+  def directory(*args, &block); end
+  def to_array; end
+  def to_file; end
+  def to_float; end
+  def to_integer; end
+  def to_pathname; end
+  def to_proc; end
+  def to_regexp; end
+  def to_string; end
+  def to_symbol; end
+
+  private
+
+  def convert_by_answer_type; end
+end
+
+class HighLine::QuestionAsker
+  include ::HighLine::CustomErrors
+
+  def initialize(question, highline); end
+
+  def ask_once; end
+  def gather_answers; end
+  def gather_hash; end
+  def gather_integer; end
+  def gather_regexp; end
+  def question; end
+
+  private
+
+  def answer_matches_regex(answer); end
+  def explain_error(explanation_key); end
+  def gather_answers_based_on_type; end
+  def gather_with_array; end
+end
+
+class HighLine::SampleColorScheme < ::HighLine::ColorScheme
+  def initialize(_h = T.unsafe(nil)); end
+end
+
+HighLine::SampleColorScheme::SAMPLE_SCHEME = T.let(T.unsafe(nil), Hash)
+
+class HighLine::Statement
+  def initialize(source, highline); end
+
+  def highline; end
+  def source; end
+  def statement; end
+  def template_string; end
+  def to_s; end
+
+  private
+
+  def format_statement; end
+  def render_template; end
+  def stringfy(template_string); end
+  def template; end
+
+  class << self
+    def const_missing(constant); end
+  end
+end
+
+class HighLine::String < ::String
+  include ::HighLine::StringExtensions
+
+  def black; end
+  def blink; end
+  def blue; end
+  def bold; end
+  def bright_black; end
+  def bright_blue; end
+  def bright_cyan; end
+  def bright_gray; end
+  def bright_green; end
+  def bright_grey; end
+  def bright_magenta; end
+  def bright_none; end
+  def bright_red; end
+  def bright_white; end
+  def bright_yellow; end
+  def clear; end
+  def color(*args); end
+  def concealed; end
+  def cyan; end
+  def dark; end
+  def foreground(*args); end
+  def gray; end
+  def green; end
+  def grey; end
+  def light_black; end
+  def light_blue; end
+  def light_cyan; end
+  def light_gray; end
+  def light_green; end
+  def light_grey; end
+  def light_magenta; end
+  def light_none; end
+  def light_red; end
+  def light_white; end
+  def light_yellow; end
+  def magenta; end
+  def method_missing(method, *_args); end
+  def none; end
+  def on(arg); end
+  def on_black; end
+  def on_blue; end
+  def on_bright_black; end
+  def on_bright_blue; end
+  def on_bright_cyan; end
+  def on_bright_gray; end
+  def on_bright_green; end
+  def on_bright_grey; end
+  def on_bright_magenta; end
+  def on_bright_none; end
+  def on_bright_red; end
+  def on_bright_white; end
+  def on_bright_yellow; end
+  def on_cyan; end
+  def on_gray; end
+  def on_green; end
+  def on_grey; end
+  def on_light_black; end
+  def on_light_blue; end
+  def on_light_cyan; end
+  def on_light_gray; end
+  def on_light_green; end
+  def on_light_grey; end
+  def on_light_magenta; end
+  def on_light_none; end
+  def on_light_red; end
+  def on_light_white; end
+  def on_light_yellow; end
+  def on_magenta; end
+  def on_none; end
+  def on_red; end
+  def on_rgb(*colors); end
+  def on_white; end
+  def on_yellow; end
+  def red; end
+  def reset; end
+  def reverse; end
+  def rgb(*colors); end
+  def uncolor; end
+  def underline; end
+  def underscore; end
+  def white; end
+  def yellow; end
+
+  private
+
+  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
+  def setup_color_code(*colors); end
+end
+
+module HighLine::StringExtensions
+  class << self
+    def define_builtin_style_methods(base); end
+    def define_style_support_methods(base); end
+    def included(base); end
+  end
+end
+
+HighLine::StringExtensions::STYLE_METHOD_NAME_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+class HighLine::Style
+  def initialize(defn = T.unsafe(nil)); end
+
+  def blue; end
+  def bright; end
+  def builtin; end
+  def builtin=(_arg0); end
+  def code; end
+  def color(string); end
+  def dup; end
+  def green; end
+  def light; end
+  def list; end
+  def name; end
+  def on; end
+  def red; end
+  def rgb; end
+  def rgb=(_arg0); end
+  def to_hash; end
+  def variant(new_name, options = T.unsafe(nil)); end
+
+  private
+
+  def create_bright_variant(variant_name); end
+  def find_style(name); end
+
+  class << self
+    def ansi_rgb_to_hex(ansi_number); end
+    def clear_index; end
+    def code_index; end
+    def index(style); end
+    def list; end
+    def rgb(*colors); end
+    def rgb_hex(*colors); end
+    def rgb_number(*parts); end
+    def rgb_parts(hex); end
+    def uncolor(string); end
+  end
+end
+
+class HighLine::TemplateRenderer
+  extend ::Forwardable
+
+  def initialize(template, source, highline); end
+
+  def answer(*args, &block); end
+  def answer_type(*args, &block); end
+  def color(*args, &block); end
+  def header(*args, &block); end
+  def highline; end
+  def key(*args, &block); end
+  def list(*args, &block); end
+  def menu; end
+  def method_missing(method, *args); end
+  def prompt(*args, &block); end
+  def render; end
+  def source; end
+  def template; end
+
+  class << self
+    def const_missing(name); end
+  end
+end
+
+class HighLine::Terminal
+  def initialize(input, output); end
+
+  def character_mode; end
+  def get_character; end
+  def get_line(question, highline); end
+  def get_line_default(highline); end
+  def get_line_with_readline(question, highline); end
+  def initialize_system_extensions; end
+  def input; end
+  def jruby?; end
+  def output; end
+  def raw_no_echo_mode; end
+  def raw_no_echo_mode_exec; end
+  def readline_read(question); end
+  def restore_mode; end
+  def rubinius?; end
+  def terminal_size; end
+  def windows?; end
+
+  private
+
+  def restore_stty; end
+  def run_preserving_stty; end
+  def save_stty; end
+
+  class << self
+    def get_terminal(input, output); end
+  end
+end
+
+class HighLine::Terminal::IOConsole < ::HighLine::Terminal
+  def get_character; end
+  def raw_no_echo_mode; end
+  def restore_mode; end
+  def terminal_size; end
+end
+
+HighLine::VERSION = T.let(T.unsafe(nil), String)
+
+module HighLine::Wrapper
+  class << self
+    def actual_length(string_with_escapes); end
+    def wrap(text, wrap_at); end
+  end
+end
+
+class Object < ::BasicObject
+  include ::ActiveSupport::ForkTracker::CoreExt
+  include ::ActiveSupport::ForkTracker::CoreExtPrivate
+  include ::ActiveSupport::ToJsonWithActiveSupportEncoder
+  include ::Kernel
+  include ::JSON::Ext::Generator::GeneratorMethods::Object
+  include ::PP::ObjectMixin
+  include ::ActiveSupport::Tryable
+  include ::ActiveSupport::Dependencies::Loadable
+
+  def or_ask(*args, &details); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/hpricot@0.8.6.rbi b/Library/Homebrew/sorbet/rbi/gems/hpricot@0.8.6.rbi
index 362cb7e593..09c40f8079 100644
--- a/Library/Homebrew/sorbet/rbi/gems/hpricot@0.8.6.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/hpricot@0.8.6.rbi
@@ -1,7 +1,647 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `hpricot` gem.
-# Please instead update this file by running `tapioca generate --exclude json`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
+module Hpricot
+  class << self
+    def XML(input = T.unsafe(nil), opts = T.unsafe(nil), &blk); end
+    def buffer_size; end
+    def buffer_size=(_arg0); end
+    def build(ele = T.unsafe(nil), assigns = T.unsafe(nil), &blk); end
+    def css(_arg0, _arg1, _arg2); end
+    def make(input = T.unsafe(nil), opts = T.unsafe(nil), &blk); end
+    def parse(input = T.unsafe(nil), opts = T.unsafe(nil), &blk); end
+    def scan(*_arg0); end
+    def uxs(str); end
+  end
+end
 
+Hpricot::AttrCore = T.let(T.unsafe(nil), Array)
+Hpricot::AttrEvents = T.let(T.unsafe(nil), Array)
+Hpricot::AttrFocus = T.let(T.unsafe(nil), Array)
+Hpricot::AttrHAlign = T.let(T.unsafe(nil), Array)
+Hpricot::AttrI18n = T.let(T.unsafe(nil), Array)
+Hpricot::AttrVAlign = T.let(T.unsafe(nil), Array)
+
+class Hpricot::Attributes
+  def initialize(e); end
+
+  def [](k); end
+  def []=(k, v); end
+  def element; end
+  def element=(_arg0); end
+  def inspect; end
+  def to_hash; end
+  def to_s; end
+end
+
+Hpricot::Attrs = T.let(T.unsafe(nil), Array)
+
+class Hpricot::BlankSlate
+  class << self
+    def hide(name); end
+  end
+end
+
+class Hpricot::BogusETag
+  include ::Hpricot
+  include ::Hpricot::Node
+  include ::Hpricot::Leaf
+  include ::Hpricot::Traverse
+  include ::Hpricot::Leaf::Trav
+  include ::Hpricot::BogusETag::Trav
+
+  def initialize(name); end
+
+  def clear_raw; end
+  def output(out, opts = T.unsafe(nil)); end
+  def pretty_print(q); end
+  def raw_string; end
+end
+
+module Hpricot::BogusETag::Trav
+  include ::Hpricot::Traverse
+  include ::Hpricot::Leaf::Trav
+end
+
+module Hpricot::Builder
+  def <<(string); end
+  def a(*args, &block); end
+  def abbr(*args, &block); end
+  def acronym(*args, &block); end
+  def add_child(ele); end
+  def address(*args, &block); end
+  def applet(*args, &block); end
+  def area(*args, &block); end
+  def b(*args, &block); end
+  def base(*args, &block); end
+  def basefont(*args, &block); end
+  def bdo(*args, &block); end
+  def big(*args, &block); end
+  def blockquote(*args, &block); end
+  def body(*args, &block); end
+  def br(*args, &block); end
+  def build(*a, &b); end
+  def button(*args, &block); end
+  def caption(*args, &block); end
+  def center(*args, &block); end
+  def cite(*args, &block); end
+  def code(*args, &block); end
+  def col(*args, &block); end
+  def colgroup(*args, &block); end
+  def concat(string); end
+  def dd(*args, &block); end
+  def del(*args, &block); end
+  def dfn(*args, &block); end
+  def dir(*args, &block); end
+  def div(*args, &block); end
+  def dl(*args, &block); end
+  def doctype(target, pub, sys); end
+  def dt(*args, &block); end
+  def em(*args, &block); end
+  def fieldset(*args, &block); end
+  def font(*args, &block); end
+  def form(*args, &block); end
+  def h1(*args, &block); end
+  def h2(*args, &block); end
+  def h3(*args, &block); end
+  def h4(*args, &block); end
+  def h5(*args, &block); end
+  def h6(*args, &block); end
+  def head(*args, &block); end
+  def hr(*args, &block); end
+  def html(*args, &block); end
+  def html_tag(sym, *args, &block); end
+  def i(*args, &block); end
+  def iframe(*args, &block); end
+  def img(*args, &block); end
+  def input(*args, &block); end
+  def ins(*args, &block); end
+  def isindex(*args, &block); end
+  def kbd(*args, &block); end
+  def label(*args, &block); end
+  def legend(*args, &block); end
+  def li(*args, &block); end
+  def link(*args, &block); end
+  def map(*args, &block); end
+  def menu(*args, &block); end
+  def meta(*args, &block); end
+  def noframes(*args, &block); end
+  def noscript(*args, &block); end
+  def object(*args, &block); end
+  def ol(*args, &block); end
+  def optgroup(*args, &block); end
+  def option(*args, &block); end
+  def p(*args, &block); end
+  def param(*args, &block); end
+  def pre(*args, &block); end
+  def q(*args, &block); end
+  def s(*args, &block); end
+  def samp(*args, &block); end
+  def script(*args, &block); end
+  def select(*args, &block); end
+  def small(*args, &block); end
+  def span(*args, &block); end
+  def strike(*args, &block); end
+  def strong(*args, &block); end
+  def style(*args, &block); end
+  def sub(*args, &block); end
+  def sup(*args, &block); end
+  def table(*args, &block); end
+  def tag!(tag, *args, &block); end
+  def tbody(*args, &block); end
+  def td(*args, &block); end
+  def text(string); end
+  def text!(string); end
+  def textarea(*args, &block); end
+  def tfoot(*args, &block); end
+  def th(*args, &block); end
+  def thead(*args, &block); end
+  def title(*args, &block); end
+  def tr(*args, &block); end
+  def tt(*args, &block); end
+  def u(*args, &block); end
+  def ul(*args, &block); end
+  def var(*args, &block); end
+  def xhtml_strict(attrs = T.unsafe(nil), &block); end
+  def xhtml_transitional(attrs = T.unsafe(nil), &block); end
+
+  private
+
+  def xhtml_html(attrs = T.unsafe(nil), &block); end
+
+  class << self
+    def set(option, value); end
+  end
+end
+
+class Hpricot::CData
+  include ::Hpricot
+  include ::Hpricot::Node
+  include ::Hpricot::Leaf
+  include ::Hpricot::Traverse
+  include ::Hpricot::Leaf::Trav
+  include ::Hpricot::CData::Trav
+
+  def initialize(content); end
+
+  def content; end
+  def content=(_arg0); end
+  def inner_text; end
+  def output(out, opts = T.unsafe(nil)); end
+  def raw_string; end
+  def to_plain_text; end
+  def to_s; end
+end
+
+module Hpricot::CData::Trav
+  include ::Hpricot::Traverse
+  include ::Hpricot::Leaf::Trav
+end
+
+class Hpricot::Comment
+  include ::Hpricot
+  include ::Hpricot::Node
+  include ::Hpricot::Leaf
+  include ::Hpricot::Traverse
+  include ::Hpricot::Leaf::Trav
+  include ::Hpricot::Comment::Trav
+
+  def content; end
+  def content=(_arg0); end
+  def output(out, opts = T.unsafe(nil)); end
+  def pathname; end
+  def raw_string; end
+end
+
+module Hpricot::Comment::Trav
+  include ::Hpricot::Traverse
+  include ::Hpricot::Leaf::Trav
+end
+
+module Hpricot::Container
+  include ::Hpricot
+  include ::Hpricot::Node
+end
+
+module Hpricot::Container::Trav
+  include ::Hpricot::Traverse
+
+  def classes; end
+  def containers; end
+  def each_child(&block); end
+  def each_child_with_index(&block); end
+  def each_hyperlink; end
+  def each_hyperlink_uri(base_uri = T.unsafe(nil)); end
+  def each_uri(base_uri = T.unsafe(nil)); end
+  def filter(&block); end
+  def find_element(*names); end
+  def following_siblings; end
+  def get_element_by_id(id); end
+  def get_elements_by_tag_name(*a); end
+  def insert_after(nodes, ele); end
+  def insert_before(nodes, ele); end
+  def next_sibling; end
+  def preceding_siblings; end
+  def previous_sibling; end
+  def replace_child(old, new); end
+  def siblings_at(*pos); end
+  def traverse_text_internal(&block); end
+
+  private
+
+  def each_hyperlink_attribute; end
+end
+
+class Hpricot::Context
+  include ::Hpricot
+end
+
+class Hpricot::CssProxy < ::Hpricot::BlankSlate
+  def initialize(builder, sym); end
+
+  def method_missing(id_or_class, *args, &block); end
+end
+
+class Hpricot::Doc
+  include ::Hpricot
+  include ::Hpricot::Node
+  include ::Hpricot::Container
+  include ::Hpricot::Traverse
+  include ::Hpricot::Container::Trav
+  include ::Hpricot::Doc::Trav
+
+  def altered!; end
+  def inspect; end
+  def inspect_tree; end
+  def make(input = T.unsafe(nil), &blk); end
+  def output(out, opts = T.unsafe(nil)); end
+  def pretty_print(q); end
+end
+
+module Hpricot::Doc::Trav
+  include ::Hpricot::Traverse
+  include ::Hpricot::Container::Trav
+
+  def author; end
+  def css_path; end
+  def root; end
+  def title; end
+  def traverse_all_element(&block); end
+  def traverse_some_element(name_set, &block); end
+  def xpath; end
+end
+
+class Hpricot::DocType
+  include ::Hpricot
+  include ::Hpricot::Node
+  include ::Hpricot::Leaf
+  include ::Hpricot::Traverse
+  include ::Hpricot::Leaf::Trav
+  include ::Hpricot::DocType::Trav
+
+  def initialize(target, pub, sys); end
+
+  def clear_raw; end
+  def output(out, opts = T.unsafe(nil)); end
+  def pathname; end
+  def public_id; end
+  def public_id=(_arg0); end
+  def raw_string; end
+  def system_id; end
+  def system_id=(_arg0); end
+  def target; end
+  def target=(_arg0); end
+end
+
+module Hpricot::DocType::Trav
+  include ::Hpricot::Traverse
+  include ::Hpricot::Leaf::Trav
+end
+
+class Hpricot::ETag < ::Hpricot::BogusETag
+  include ::Hpricot::Tag
+
+  def inspect; end
+  def output(out, opts = T.unsafe(nil)); end
+  def pretty_print(q); end
+end
+
+class Hpricot::Elem
+  include ::Hpricot
+  include ::Hpricot::Node
+  include ::Hpricot::Container
+  include ::Hpricot::Traverse
+  include ::Hpricot::Container::Trav
+  include ::Hpricot::Elem::Trav
+
+  def initialize(tag, attrs = T.unsafe(nil), children = T.unsafe(nil), etag = T.unsafe(nil)); end
+
+  def attributes; end
+  def attributes_as_html; end
+  def clear_raw; end
+  def empty?; end
+  def inspect; end
+  def inspect_tree(depth = T.unsafe(nil)); end
+  def output(out, opts = T.unsafe(nil)); end
+  def pathname; end
+  def pretty_print(q); end
+  def pretty_print_stag(q); end
+  def to_plain_text; end
+end
+
+module Hpricot::Elem::Trav
+  include ::Hpricot::Traverse
+  include ::Hpricot::Container::Trav
+
+  def [](name); end
+  def []=(name, val); end
+  def get_attribute(name); end
+  def has_attribute?(name); end
+  def remove_attribute(name); end
+  def set_attribute(name, val); end
+  def traverse_all_element(&block); end
+  def traverse_some_element(name_set, &block); end
+end
+
+Hpricot::ElementContent = T.let(T.unsafe(nil), Hash)
+Hpricot::ElementExclusions = T.let(T.unsafe(nil), Hash)
+Hpricot::ElementInclusions = T.let(T.unsafe(nil), Hash)
+
+class Hpricot::Elements < ::Array
+  def %(expr, &blk); end
+  def /(*expr, &blk); end
+  def add_class(class_name); end
+  def after(str = T.unsafe(nil), &blk); end
+  def append(str = T.unsafe(nil), &blk); end
+  def at(expr, &blk); end
+  def attr(key, value = T.unsafe(nil), &blk); end
+  def before(str = T.unsafe(nil), &blk); end
+  def empty; end
+  def filter(expr); end
+  def html(*string); end
+  def html=(string); end
+  def innerHTML(*string); end
+  def innerHTML=(string); end
+  def inner_html(*string); end
+  def inner_html=(string); end
+  def inner_text; end
+  def inspect; end
+  def not(expr); end
+  def prepend(str = T.unsafe(nil), &blk); end
+  def pretty_print(q); end
+  def remove; end
+  def remove_attr(name); end
+  def remove_class(name = T.unsafe(nil)); end
+  def search(*expr, &blk); end
+  def set(key, value = T.unsafe(nil), &blk); end
+  def text; end
+  def to_html; end
+  def to_s; end
+  def wrap(str = T.unsafe(nil), &blk); end
+
+  private
+
+  def copy_node(node, l); end
+
+  class << self
+    def expand(ele1, ele2, excl = T.unsafe(nil)); end
+    def filter(nodes, expr, truth = T.unsafe(nil)); end
+  end
+end
+
+Hpricot::Elements::ATTR_RE = T.let(T.unsafe(nil), Regexp)
+Hpricot::Elements::BRACK_RE = T.let(T.unsafe(nil), Regexp)
+Hpricot::Elements::CATCH_RE = T.let(T.unsafe(nil), Regexp)
+Hpricot::Elements::CUST_RE = T.let(T.unsafe(nil), Regexp)
+Hpricot::Elements::FUNC_RE = T.let(T.unsafe(nil), Regexp)
+class Hpricot::EncodingError < ::StandardError; end
+class Hpricot::Error < ::StandardError; end
+Hpricot::FORM_TAGS = T.let(T.unsafe(nil), Array)
+
+module Hpricot::Leaf
+  include ::Hpricot
+  include ::Hpricot::Node
+
+  def inspect; end
+  def pretty_print(q); end
+end
+
+module Hpricot::Leaf::Trav
+  include ::Hpricot::Traverse
+
+  def traverse_all_element; end
+  def traverse_some_element(name_set); end
+  def traverse_text_internal; end
+end
+
+class Hpricot::Name
+  include ::Hpricot
+end
+
+Hpricot::NamedCharacters = T.let(T.unsafe(nil), Hash)
+Hpricot::NamedCharactersPattern = T.let(T.unsafe(nil), Regexp)
+
+module Hpricot::Node
+  include ::Hpricot
+
+  def altered!; end
+  def clear_raw; end
+  def html_quote(str); end
+  def if_output(opts); end
+  def inspect_tree(depth = T.unsafe(nil)); end
+  def pathname; end
+end
+
+Hpricot::OmittedAttrName = T.let(T.unsafe(nil), Hash)
+class Hpricot::ParseError < ::StandardError; end
+
+class Hpricot::ProcIns
+  include ::Hpricot
+  include ::Hpricot::Node
+  include ::Hpricot::Leaf
+  include ::Hpricot::Traverse
+  include ::Hpricot::Leaf::Trav
+  include ::Hpricot::ProcIns::Trav
+
+  def content; end
+  def content=(_arg0); end
+  def output(out, opts = T.unsafe(nil)); end
+  def pathname; end
+  def raw_string; end
+  def target; end
+  def target=(_arg0); end
+end
+
+module Hpricot::ProcIns::Trav
+  include ::Hpricot::Traverse
+  include ::Hpricot::Leaf::Trav
+end
+
+Hpricot::ProcInsParse = T.let(T.unsafe(nil), Regexp)
+Hpricot::SELF_CLOSING_TAGS = T.let(T.unsafe(nil), Array)
+
+module Hpricot::Tag
+  include ::Hpricot
+end
+
+class Hpricot::Text
+  include ::Hpricot
+  include ::Hpricot::Node
+  include ::Hpricot::Leaf
+  include ::Hpricot::Traverse
+  include ::Hpricot::Leaf::Trav
+  include ::Hpricot::Text::Trav
+
+  def initialize(content); end
+
+  def <<(str); end
+  def clear_raw; end
+  def content; end
+  def content=(_arg0); end
+  def inner_text; end
+  def output(out, opts = T.unsafe(nil)); end
+  def pathname; end
+  def pretty_print(q); end
+  def raw_string; end
+  def to_plain_text; end
+  def to_s; end
+end
+
+module Hpricot::Text::Trav
+  include ::Hpricot::Traverse
+  include ::Hpricot::Leaf::Trav
+
+  def traverse_text_internal; end
+end
+
+module Hpricot::Traverse
+  def %(expr); end
+  def /(expr, &blk); end
+  def after(html = T.unsafe(nil), &blk); end
+  def at(expr); end
+  def before(html = T.unsafe(nil), &blk); end
+  def bogusetag?; end
+  def children_of_type(tag_name); end
+  def clean_path(path); end
+  def comment?; end
+  def css_path; end
+  def doc?; end
+  def doctype?; end
+  def elem?; end
+  def following; end
+  def get_subnode(*indexes); end
+  def html(inner = T.unsafe(nil), &blk); end
+  def index(name); end
+  def innerHTML(inner = T.unsafe(nil), &blk); end
+  def innerHTML=(inner); end
+  def innerText; end
+  def inner_html(inner = T.unsafe(nil), &blk); end
+  def inner_html=(inner); end
+  def inner_text; end
+  def make(input = T.unsafe(nil), &blk); end
+  def next; end
+  def next_node; end
+  def node_position; end
+  def nodes_at(*pos); end
+  def position; end
+  def preceding; end
+  def previous; end
+  def previous_node; end
+  def procins?; end
+  def search(expr, &blk); end
+  def swap(html = T.unsafe(nil), &blk); end
+  def text?; end
+  def to_html; end
+  def to_original_html; end
+  def to_plain_text; end
+  def to_s; end
+  def traverse_element(*names, &block); end
+  def traverse_text(&block); end
+  def xmldecl?; end
+  def xpath; end
+
+  private
+
+  def reparent(nodes); end
+
+  class << self
+    def filter(tok, &blk); end
+  end
+end
+
+class Hpricot::XHTMLStrict
+  class << self
+    def doctype; end
+    def doctype=(_arg0); end
+    def forms; end
+    def forms=(_arg0); end
+    def self_closing; end
+    def self_closing=(_arg0); end
+    def tags; end
+    def tags=(_arg0); end
+    def tagset; end
+    def tagset=(_arg0); end
+  end
+end
+
+class Hpricot::XHTMLTransitional
+  class << self
+    def doctype; end
+    def doctype=(_arg0); end
+    def forms; end
+    def forms=(_arg0); end
+    def self_closing; end
+    def self_closing=(_arg0); end
+    def tags; end
+    def tags=(_arg0); end
+    def tagset; end
+    def tagset=(_arg0); end
+  end
+end
+
+class Hpricot::XMLDecl
+  include ::Hpricot
+  include ::Hpricot::Node
+  include ::Hpricot::Leaf
+  include ::Hpricot::Traverse
+  include ::Hpricot::Leaf::Trav
+  include ::Hpricot::XMLDecl::Trav
+
+  def clear_raw; end
+  def encoding; end
+  def encoding=(_arg0); end
+  def output(out, opts = T.unsafe(nil)); end
+  def pathname; end
+  def raw_string; end
+  def standalone; end
+  def standalone=(_arg0); end
+  def version; end
+  def version=(_arg0); end
+end
+
+module Hpricot::XMLDecl::Trav
+  include ::Hpricot::Traverse
+  include ::Hpricot::Leaf::Trav
+end
+
+class Object < ::BasicObject
+  include ::ActiveSupport::ForkTracker::CoreExt
+  include ::ActiveSupport::ForkTracker::CoreExtPrivate
+  include ::ActiveSupport::ToJsonWithActiveSupportEncoder
+  include ::Kernel
+  include ::JSON::Ext::Generator::GeneratorMethods::Object
+  include ::PP::ObjectMixin
+  include ::ActiveSupport::Tryable
+  include ::ActiveSupport::Dependencies::Loadable
+
+  private
+
+  def Hpricot(input = T.unsafe(nil), opts = T.unsafe(nil), &blk); end
+
+  class << self
+    def method_added(name); end
+  end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/i18n@1.8.10.rbi b/Library/Homebrew/sorbet/rbi/gems/i18n@1.8.10.rbi
index c07fa2ae06..3b5a668ab5 100644
--- a/Library/Homebrew/sorbet/rbi/gems/i18n@1.8.10.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/i18n@1.8.10.rbi
@@ -5,7 +5,7 @@
 # typed: true
 
 module I18n
-  extend(::I18n::Base)
+  extend ::I18n::Base
 
   class << self
     def interpolate(string, values); end
@@ -14,14 +14,11 @@ module I18n
   end
 end
 
-class I18n::ArgumentError < ::ArgumentError
-end
-
-module I18n::Backend
-end
+class I18n::ArgumentError < ::ArgumentError; end
+module I18n::Backend; end
 
 module I18n::Backend::Base
-  include(::I18n::Backend::Transliterator)
+  include ::I18n::Backend::Transliterator
 
   def available_locales; end
   def eager_load!; end
@@ -80,14 +77,14 @@ module I18n::Backend::Cascade
 end
 
 class I18n::Backend::Chain
-  include(::I18n::Backend::Transliterator)
-  include(::I18n::Backend::Base)
-  include(::I18n::Backend::Chain::Implementation)
+  include ::I18n::Backend::Transliterator
+  include ::I18n::Backend::Base
+  include ::I18n::Backend::Chain::Implementation
 end
 
 module I18n::Backend::Chain::Implementation
-  include(::I18n::Backend::Transliterator)
-  include(::I18n::Backend::Base)
+  include ::I18n::Backend::Transliterator
+  include ::I18n::Backend::Base
 
   def initialize(*backends); end
 
@@ -143,11 +140,9 @@ module I18n::Backend::Flatten
 end
 
 I18n::Backend::Flatten::FLATTEN_SEPARATOR = T.let(T.unsafe(nil), String)
-
 I18n::Backend::Flatten::SEPARATOR_ESCAPE_CHAR = T.let(T.unsafe(nil), String)
 
 module I18n::Backend::Gettext
-
   protected
 
   def load_po(filename); end
@@ -170,7 +165,7 @@ module I18n::Backend::InterpolationCompiler
 end
 
 module I18n::Backend::InterpolationCompiler::Compiler
-  extend(::I18n::Backend::InterpolationCompiler::Compiler)
+  extend ::I18n::Backend::InterpolationCompiler::Compiler
 
   def compile_if_an_interpolation(string); end
   def interpolated_str?(str); end
@@ -192,20 +187,19 @@ module I18n::Backend::InterpolationCompiler::Compiler
 end
 
 I18n::Backend::InterpolationCompiler::Compiler::INTERPOLATION_SYNTAX_PATTERN = T.let(T.unsafe(nil), Regexp)
-
 I18n::Backend::InterpolationCompiler::Compiler::TOKENIZER = T.let(T.unsafe(nil), Regexp)
 
 class I18n::Backend::KeyValue
-  include(::I18n::Backend::Flatten)
-  include(::I18n::Backend::Transliterator)
-  include(::I18n::Backend::Base)
-  include(::I18n::Backend::KeyValue::Implementation)
+  include ::I18n::Backend::Flatten
+  include ::I18n::Backend::Transliterator
+  include ::I18n::Backend::Base
+  include ::I18n::Backend::KeyValue::Implementation
 end
 
 module I18n::Backend::KeyValue::Implementation
-  include(::I18n::Backend::Flatten)
-  include(::I18n::Backend::Transliterator)
-  include(::I18n::Backend::Base)
+  include ::I18n::Backend::Flatten
+  include ::I18n::Backend::Transliterator
+  include ::I18n::Backend::Base
 
   def initialize(store, subtrees = T.unsafe(nil)); end
 
@@ -273,14 +267,14 @@ module I18n::Backend::Pluralization
 end
 
 class I18n::Backend::Simple
-  include(::I18n::Backend::Transliterator)
-  include(::I18n::Backend::Base)
-  include(::I18n::Backend::Simple::Implementation)
+  include ::I18n::Backend::Transliterator
+  include ::I18n::Backend::Base
+  include ::I18n::Backend::Simple::Implementation
 end
 
 module I18n::Backend::Simple::Implementation
-  include(::I18n::Backend::Transliterator)
-  include(::I18n::Backend::Base)
+  include ::I18n::Backend::Transliterator
+  include ::I18n::Backend::Base
 
   def available_locales; end
   def eager_load!; end
@@ -430,7 +424,7 @@ module I18n::Gettext::Helpers
 end
 
 I18n::Gettext::PLURAL_SEPARATOR = T.let(T.unsafe(nil), String)
-
+module I18n::HashRefinements; end
 I18n::INTERPOLATION_PATTERN = T.let(T.unsafe(nil), Regexp)
 
 class I18n::InvalidLocale < ::I18n::ArgumentError
@@ -453,8 +447,8 @@ class I18n::InvalidPluralizationData < ::I18n::ArgumentError
   def key; end
 end
 
-module I18n::Locale
-end
+I18n::JSON = ActiveSupport::JSON
+module I18n::Locale; end
 
 class I18n::Locale::Fallbacks < ::Hash
   def initialize(*mappings); end
@@ -483,8 +477,11 @@ module I18n::Locale::Tag::Parents
   def self_and_parents; end
 end
 
+I18n::Locale::Tag::RFC4646_FORMATS = T.let(T.unsafe(nil), Hash)
+I18n::Locale::Tag::RFC4646_SUBTAGS = T.let(T.unsafe(nil), Array)
+
 class I18n::Locale::Tag::Rfc4646 < ::Struct
-  include(::I18n::Locale::Tag::Parents)
+  include ::I18n::Locale::Tag::Parents
 
   def language; end
   def region; end
@@ -510,7 +507,7 @@ end
 I18n::Locale::Tag::Rfc4646::Parser::PATTERN = T.let(T.unsafe(nil), Regexp)
 
 class I18n::Locale::Tag::Simple
-  include(::I18n::Locale::Tag::Parents)
+  include ::I18n::Locale::Tag::Parents
 
   def initialize(*tag); end
 
@@ -540,7 +537,7 @@ class I18n::MissingInterpolationArgument < ::I18n::ArgumentError
 end
 
 class I18n::MissingTranslation < ::I18n::ArgumentError
-  include(::I18n::MissingTranslation::Base)
+  include ::I18n::MissingTranslation::Base
 end
 
 module I18n::MissingTranslation::Base
@@ -556,11 +553,10 @@ module I18n::MissingTranslation::Base
 end
 
 class I18n::MissingTranslationData < ::I18n::ArgumentError
-  include(::I18n::MissingTranslation::Base)
+  include ::I18n::MissingTranslation::Base
 end
 
 I18n::RESERVED_KEYS = T.let(T.unsafe(nil), Array)
-
 I18n::RESERVED_KEYS_PATTERN = T.let(T.unsafe(nil), Regexp)
 
 class I18n::ReservedInterpolationKey < ::I18n::ArgumentError
@@ -570,9 +566,19 @@ class I18n::ReservedInterpolationKey < ::I18n::ArgumentError
   def string; end
 end
 
-module I18n::Tests
+module I18n::Tests; end
+
+module I18n::Tests::Basics
+  def teardown; end
 end
 
+module I18n::Tests::Defaults
+  def setup; end
+end
+
+module I18n::Tests::Interpolation; end
+module I18n::Tests::Link; end
+
 module I18n::Tests::Localization
   class << self
     def included(base); end
@@ -583,44 +589,11 @@ module I18n::Tests::Localization::Date
   def setup; end
 end
 
-class I18n::UnknownFileType < ::I18n::ArgumentError
-  def initialize(type, filename); end
-
-  def filename; end
-  def type; end
-end
-
-I18n::VERSION = T.let(T.unsafe(nil), String)
-
-module I18n::HashRefinements
-end
-
-I18n::JSON = ActiveSupport::JSON
-
-I18n::Locale::Tag::RFC4646_FORMATS = T.let(T.unsafe(nil), Hash)
-
-I18n::Locale::Tag::RFC4646_SUBTAGS = T.let(T.unsafe(nil), Array)
-
-module I18n::Tests::Basics
-  def teardown; end
-end
-
-module I18n::Tests::Defaults
-  def setup; end
-end
-
-module I18n::Tests::Interpolation
-end
-
-module I18n::Tests::Link
-end
-
 module I18n::Tests::Localization::DateTime
   def setup; end
 end
 
-module I18n::Tests::Localization::Procs
-end
+module I18n::Tests::Localization::Procs; end
 
 module I18n::Tests::Localization::Time
   def setup; end
@@ -630,8 +603,14 @@ module I18n::Tests::Lookup
   def setup; end
 end
 
-module I18n::Tests::Pluralization
+module I18n::Tests::Pluralization; end
+module I18n::Tests::Procs; end
+
+class I18n::UnknownFileType < ::I18n::ArgumentError
+  def initialize(type, filename); end
+
+  def filename; end
+  def type; end
 end
 
-module I18n::Tests::Procs
-end
+I18n::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/json_schemer@0.2.18.rbi b/Library/Homebrew/sorbet/rbi/gems/json_schemer@0.2.18.rbi
index 2cad32d927..956c60374d 100644
--- a/Library/Homebrew/sorbet/rbi/gems/json_schemer@0.2.18.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/json_schemer@0.2.18.rbi
@@ -4,5 +4,170 @@
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module JSONSchemer
+  class << self
+    def schema(schema, **options); end
+
+    private
+
+    def draft_class(schema); end
+  end
+end
+
+class JSONSchemer::CachedRefResolver
+  def initialize(&ref_resolver); end
+
+  def call(uri); end
+end
+
+JSONSchemer::DEFAULT_META_SCHEMA = T.let(T.unsafe(nil), String)
+JSONSchemer::DRAFT_CLASS_BY_META_SCHEMA = T.let(T.unsafe(nil), Hash)
+
+module JSONSchemer::Errors
+  class << self
+    def pretty(error); end
+  end
+end
+
+JSONSchemer::FILE_URI_REF_RESOLVER = T.let(T.unsafe(nil), Proc)
+
+module JSONSchemer::Format
+  def iri_escape(data); end
+  def parse_uri_scheme(data); end
+  def valid_date_time?(data); end
+  def valid_email?(data); end
+  def valid_hostname?(data); end
+  def valid_ip?(data, type); end
+  def valid_json?(data); end
+  def valid_json_pointer?(data); end
+  def valid_relative_json_pointer?(data); end
+  def valid_spec_format?(data, format); end
+  def valid_uri?(data); end
+  def valid_uri_reference?(data); end
+  def valid_uri_template?(data); end
+end
+
+JSONSchemer::Format::DATE_TIME_OFFSET_REGEX = T.let(T.unsafe(nil), Regexp)
+JSONSchemer::Format::EMAIL_REGEX = T.let(T.unsafe(nil), Regexp)
+JSONSchemer::Format::HOSTNAME_REGEX = T.let(T.unsafe(nil), Regexp)
+JSONSchemer::Format::INVALID_QUERY_REGEX = T.let(T.unsafe(nil), Regexp)
+JSONSchemer::Format::JSON_POINTER_REGEX = T.let(T.unsafe(nil), Regexp)
+JSONSchemer::Format::JSON_POINTER_REGEX_STRING = T.let(T.unsafe(nil), String)
+JSONSchemer::Format::LABEL_REGEX_STRING = T.let(T.unsafe(nil), String)
+JSONSchemer::Format::RELATIVE_JSON_POINTER_REGEX = T.let(T.unsafe(nil), Regexp)
+class JSONSchemer::InvalidFileURI < ::StandardError; end
+class JSONSchemer::InvalidRefResolution < ::StandardError; end
+class JSONSchemer::InvalidSymbolKey < ::StandardError; end
+module JSONSchemer::Schema; end
+
+class JSONSchemer::Schema::Base
+  include ::JSONSchemer::Format
+
+  def initialize(schema, format: T.unsafe(nil), insert_property_defaults: T.unsafe(nil), before_property_validation: T.unsafe(nil), after_property_validation: T.unsafe(nil), formats: T.unsafe(nil), keywords: T.unsafe(nil), ref_resolver: T.unsafe(nil)); end
+
+  def valid?(data); end
+  def validate(data); end
+
+  protected
+
+  def ids; end
+  def valid_instance?(instance); end
+  def validate_instance(instance, &block); end
+
+  private
+
+  def child(schema); end
+  def custom_format?(format); end
+  def ecma_262_regex(pattern); end
+  def error(instance, type, details = T.unsafe(nil)); end
+  def format?; end
+  def formats; end
+  def id_keyword; end
+  def join_uri(a, b); end
+  def keywords; end
+  def pointer_uri(schema, pointer); end
+  def ref_resolver; end
+  def resolve_ids(schema, ids = T.unsafe(nil), parent_uri = T.unsafe(nil), pointer = T.unsafe(nil)); end
+  def resolve_ref(uri); end
+  def root; end
+  def safe_strict_decode64(data); end
+  def spec_format?(format); end
+  def validate_array(instance, &block); end
+  def validate_class(instance, &block); end
+  def validate_custom_format(instance, custom_format); end
+  def validate_exclusive_maximum(instance, exclusive_maximum, maximum); end
+  def validate_exclusive_minimum(instance, exclusive_minimum, minimum); end
+  def validate_integer(instance, &block); end
+  def validate_number(instance, &block); end
+  def validate_numeric(instance, &block); end
+  def validate_object(instance, &block); end
+  def validate_ref(instance, ref, &block); end
+  def validate_string(instance, &block); end
+  def validate_type(instance, type, &block); end
+end
+
+JSONSchemer::Schema::Base::BOOLEANS = T.let(T.unsafe(nil), Set)
+JSONSchemer::Schema::Base::DEFAULT_REF_RESOLVER = T.let(T.unsafe(nil), Proc)
+JSONSchemer::Schema::Base::ID_KEYWORD = T.let(T.unsafe(nil), String)
+JSONSchemer::Schema::Base::INSERT_DEFAULT_PROPERTY = T.let(T.unsafe(nil), Proc)
+
+class JSONSchemer::Schema::Base::Instance < ::Struct
+  def after_property_validation; end
+  def after_property_validation=(_); end
+  def before_property_validation; end
+  def before_property_validation=(_); end
+  def data; end
+  def data=(_); end
+  def data_pointer; end
+  def data_pointer=(_); end
+  def merge(data: T.unsafe(nil), data_pointer: T.unsafe(nil), schema: T.unsafe(nil), schema_pointer: T.unsafe(nil), parent_uri: T.unsafe(nil), before_property_validation: T.unsafe(nil), after_property_validation: T.unsafe(nil)); end
+  def parent_uri; end
+  def parent_uri=(_); end
+  def schema; end
+  def schema=(_); end
+  def schema_pointer; end
+  def schema_pointer=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+JSONSchemer::Schema::Base::NET_HTTP_REF_RESOLVER = T.let(T.unsafe(nil), Proc)
+JSONSchemer::Schema::Base::RUBY_REGEX_ANCHORS_TO_ECMA_262 = T.let(T.unsafe(nil), Hash)
+
+class JSONSchemer::Schema::Draft4 < ::JSONSchemer::Schema::Base
+  private
+
+  def id_keyword; end
+  def supported_format?(format); end
+  def validate_exclusive_maximum(instance, exclusive_maximum, maximum); end
+  def validate_exclusive_minimum(instance, exclusive_minimum, minimum); end
+  def validate_integer(instance, &block); end
+end
+
+JSONSchemer::Schema::Draft4::ID_KEYWORD = T.let(T.unsafe(nil), String)
+JSONSchemer::Schema::Draft4::SUPPORTED_FORMATS = T.let(T.unsafe(nil), Set)
+
+class JSONSchemer::Schema::Draft6 < ::JSONSchemer::Schema::Base
+  private
+
+  def supported_format?(format); end
+end
+
+JSONSchemer::Schema::Draft6::SUPPORTED_FORMATS = T.let(T.unsafe(nil), Set)
+
+class JSONSchemer::Schema::Draft7 < ::JSONSchemer::Schema::Base
+  private
+
+  def supported_format?(format); end
+end
+
+JSONSchemer::Schema::Draft7::SUPPORTED_FORMATS = T.let(T.unsafe(nil), Set)
+class JSONSchemer::UnknownRef < ::StandardError; end
+class JSONSchemer::UnsupportedMetaSchema < ::StandardError; end
+JSONSchemer::VERSION = T.let(T.unsafe(nil), String)
+JSONSchemer::WINDOWS_URI_PATH_REGEX = T.let(T.unsafe(nil), Regexp)
diff --git a/Library/Homebrew/sorbet/rbi/gems/mechanize@2.8.1.rbi b/Library/Homebrew/sorbet/rbi/gems/mechanize@2.8.1.rbi
index ae740567ed..91b86dea92 100644
--- a/Library/Homebrew/sorbet/rbi/gems/mechanize@2.8.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/mechanize@2.8.1.rbi
@@ -5,9 +5,9 @@
 # typed: true
 
 class HTTP::CookieJar
-  include(::Mechanize::CookieDeprecated)
-  include(::Mechanize::CookieJarIMethods)
-  include(::Enumerable)
+  include ::Mechanize::CookieDeprecated
+  include ::Mechanize::CookieJarIMethods
+  include ::Enumerable
 
   def initialize(options = T.unsafe(nil)); end
 
@@ -161,9 +161,7 @@ class Mechanize
 end
 
 Mechanize::AGENT_ALIASES = T.let(T.unsafe(nil), Hash)
-
-class Mechanize::ChunkedTerminationError < ::Mechanize::ResponseReadError
-end
+class Mechanize::ChunkedTerminationError < ::Mechanize::ResponseReadError; end
 
 class Mechanize::ContentTypeError < ::Mechanize::Error
   def initialize(content_type); end
@@ -174,20 +172,19 @@ end
 Mechanize::Cookie = HTTP::Cookie
 
 module Mechanize::CookieCMethods
-  include(::Mechanize::CookieDeprecated)
+  include ::Mechanize::CookieDeprecated
 
   def parse(arg1, arg2, arg3 = T.unsafe(nil), &block); end
 end
 
 module Mechanize::CookieDeprecated
-
   private
 
   def __deprecated__(to = T.unsafe(nil)); end
 end
 
 module Mechanize::CookieIMethods
-  include(::Mechanize::CookieDeprecated)
+  include ::Mechanize::CookieDeprecated
 
   def set_domain(domain); end
 end
@@ -198,7 +195,7 @@ class Mechanize::CookieJar < ::HTTP::CookieJar
 end
 
 module Mechanize::CookieJarIMethods
-  include(::Mechanize::CookieDeprecated)
+  include ::Mechanize::CookieDeprecated
 
   def add(arg1, arg2 = T.unsafe(nil)); end
   def add!(cookie); end
@@ -221,7 +218,7 @@ class Mechanize::DirectorySaver < ::Mechanize::Download
 end
 
 class Mechanize::Download
-  include(::Mechanize::Parser)
+  include ::Mechanize::Parser
 
   def initialize(uri = T.unsafe(nil), response = T.unsafe(nil), body_io = T.unsafe(nil), code = T.unsafe(nil)); end
 
@@ -247,11 +244,10 @@ class Mechanize::ElementNotFoundError < ::Mechanize::Error
   def source; end
 end
 
-class Mechanize::Error < ::RuntimeError
-end
+class Mechanize::Error < ::RuntimeError; end
 
 class Mechanize::File
-  include(::Mechanize::Parser)
+  include ::Mechanize::Parser
 
   def initialize(uri = T.unsafe(nil), response = T.unsafe(nil), body = T.unsafe(nil), code = T.unsafe(nil)); end
 
@@ -314,8 +310,8 @@ class Mechanize::FileSaver < ::Mechanize::Download
 end
 
 class Mechanize::Form
-  extend(::Forwardable)
-  extend(::Mechanize::ElementMatcher)
+  extend ::Forwardable
+  extend ::Mechanize::ElementMatcher
 
   def initialize(node, mech = T.unsafe(nil), page = T.unsafe(nil)); end
 
@@ -416,9 +412,7 @@ class Mechanize::Form
   def rand_string(len = T.unsafe(nil)); end
 end
 
-class Mechanize::Form::Button < ::Mechanize::Form::Field
-end
-
+class Mechanize::Form::Button < ::Mechanize::Form::Field; end
 Mechanize::Form::CRLF = T.let(T.unsafe(nil), String)
 
 class Mechanize::Form::CheckBox < ::Mechanize::Form::RadioButton
@@ -427,7 +421,7 @@ class Mechanize::Form::CheckBox < ::Mechanize::Form::RadioButton
 end
 
 class Mechanize::Form::Field
-  extend(::Forwardable)
+  extend ::Forwardable
 
   def initialize(node, value = T.unsafe(nil)); end
 
@@ -466,8 +460,7 @@ class Mechanize::Form::FileUpload < ::Mechanize::Form::Field
   def mime_type=(_arg0); end
 end
 
-class Mechanize::Form::Hidden < ::Mechanize::Form::Field
-end
+class Mechanize::Form::Hidden < ::Mechanize::Form::Field; end
 
 class Mechanize::Form::ImageButton < ::Mechanize::Form::Button
   def initialize(*args); end
@@ -488,7 +481,7 @@ class Mechanize::Form::Keygen < ::Mechanize::Form::Field
 end
 
 class Mechanize::Form::MultiSelectList < ::Mechanize::Form::Field
-  extend(::Mechanize::ElementMatcher)
+  extend ::Mechanize::ElementMatcher
 
   def initialize(node); end
 
@@ -551,8 +544,7 @@ class Mechanize::Form::RadioButton < ::Mechanize::Form::Field
   def uncheck_peers; end
 end
 
-class Mechanize::Form::Reset < ::Mechanize::Form::Button
-end
+class Mechanize::Form::Reset < ::Mechanize::Form::Button; end
 
 class Mechanize::Form::SelectList < ::Mechanize::Form::MultiSelectList
   def initialize(node); end
@@ -562,17 +554,10 @@ class Mechanize::Form::SelectList < ::Mechanize::Form::MultiSelectList
   def value=(new_value); end
 end
 
-class Mechanize::Form::Submit < ::Mechanize::Form::Button
-end
-
-class Mechanize::Form::Text < ::Mechanize::Form::Field
-end
-
-class Mechanize::Form::Textarea < ::Mechanize::Form::Field
-end
-
-class Mechanize::HTTP
-end
+class Mechanize::Form::Submit < ::Mechanize::Form::Button; end
+class Mechanize::Form::Text < ::Mechanize::Form::Field; end
+class Mechanize::Form::Textarea < ::Mechanize::Form::Field; end
+class Mechanize::HTTP; end
 
 class Mechanize::HTTP::Agent
   def initialize(connection_name = T.unsafe(nil)); end
@@ -701,9 +686,7 @@ class Mechanize::HTTP::Agent
 end
 
 Mechanize::HTTP::Agent::CREDENTIAL_HEADERS = T.let(T.unsafe(nil), Array)
-
 Mechanize::HTTP::Agent::POST_HEADERS = T.let(T.unsafe(nil), Array)
-
 Mechanize::HTTP::Agent::RobotsKey = T.let(T.unsafe(nil), Symbol)
 
 class Mechanize::HTTP::AuthChallenge < ::Struct
@@ -832,12 +815,11 @@ class Mechanize::History < ::Array
   def remove_from_index(page); end
 end
 
-class Mechanize::Image < ::Mechanize::Download
-end
+class Mechanize::Image < ::Mechanize::Download; end
 
 class Mechanize::Page < ::Mechanize::File
-  extend(::Forwardable)
-  extend(::Mechanize::ElementMatcher)
+  extend ::Forwardable
+  extend ::Mechanize::ElementMatcher
 
   def initialize(uri = T.unsafe(nil), response = T.unsafe(nil), body = T.unsafe(nil), code = T.unsafe(nil), mech = T.unsafe(nil)); end
 
@@ -920,9 +902,7 @@ class Mechanize::Page < ::Mechanize::File
   end
 end
 
-class Mechanize::Page::Base < ::Mechanize::Page::Link
-end
-
+class Mechanize::Page::Base < ::Mechanize::Page::Link; end
 Mechanize::Page::DEFAULT_RESPONSE = T.let(T.unsafe(nil), Hash)
 
 class Mechanize::Page::Frame < ::Mechanize::Page::Link
@@ -1010,11 +990,10 @@ class Mechanize::Page::MetaRefresh < ::Mechanize::Page::Link
 end
 
 Mechanize::Page::MetaRefresh::CONTENT_REGEXP = T.let(T.unsafe(nil), Regexp)
-
 Mechanize::Page::MetaRefresh::UNSAFE = T.let(T.unsafe(nil), Regexp)
 
 module Mechanize::Parser
-  extend(::Forwardable)
+  extend ::Forwardable
 
   def [](*args, &block); end
   def []=(*args, &block); end
@@ -1052,7 +1031,6 @@ class Mechanize::PluggableParser
 end
 
 Mechanize::PluggableParser::CONTENT_TYPES = T.let(T.unsafe(nil), Hash)
-
 Mechanize::PluggableParser::InvalidContentTypeError = MIME::Type::InvalidContentType
 
 class Mechanize::RedirectLimitReachedError < ::Mechanize::Error
@@ -1138,11 +1116,10 @@ class Mechanize::Util
 end
 
 Mechanize::Util::DefaultMimeTypes = T.let(T.unsafe(nil), Hash)
-
 Mechanize::VERSION = T.let(T.unsafe(nil), String)
 
 class Mechanize::XmlFile < ::Mechanize::File
-  extend(::Forwardable)
+  extend ::Forwardable
 
   def initialize(uri = T.unsafe(nil), response = T.unsafe(nil), body = T.unsafe(nil), code = T.unsafe(nil)); end
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/method_source@1.0.0.rbi b/Library/Homebrew/sorbet/rbi/gems/method_source@1.0.0.rbi
index 4fca830f45..22b4ab3e93 100644
--- a/Library/Homebrew/sorbet/rbi/gems/method_source@1.0.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/method_source@1.0.0.rbi
@@ -1,7 +1,72 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `method_source` gem.
-# Please instead update this file by running `tapioca generate --exclude json`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
+module MethodSource
+  extend ::MethodSource::CodeHelpers
 
+  class << self
+    def comment_helper(source_location, name = T.unsafe(nil)); end
+    def extract_code(source_location); end
+    def lines_for(file_name, name = T.unsafe(nil)); end
+    def source_helper(source_location, name = T.unsafe(nil)); end
+    def valid_expression?(str); end
+  end
+end
+
+module MethodSource::CodeHelpers
+  def comment_describing(file, line_number); end
+  def complete_expression?(str); end
+  def expression_at(file, line_number, options = T.unsafe(nil)); end
+
+  private
+
+  def extract_first_expression(lines, consume = T.unsafe(nil), &block); end
+  def extract_last_comment(lines); end
+end
+
+module MethodSource::CodeHelpers::IncompleteExpression
+  class << self
+    def ===(ex); end
+    def rbx?; end
+  end
+end
+
+MethodSource::CodeHelpers::IncompleteExpression::GENERIC_REGEXPS = T.let(T.unsafe(nil), Array)
+MethodSource::CodeHelpers::IncompleteExpression::RBX_ONLY_REGEXPS = T.let(T.unsafe(nil), Array)
+
+module MethodSource::MethodExtensions
+  def comment; end
+  def source; end
+
+  class << self
+    def included(klass); end
+  end
+end
+
+module MethodSource::ReeSourceLocation
+  def source_location; end
+end
+
+module MethodSource::SourceLocation; end
+
+module MethodSource::SourceLocation::MethodExtensions
+  def source_location; end
+
+  private
+
+  def trace_func(event, file, line, id, binding, classname); end
+end
+
+module MethodSource::SourceLocation::ProcExtensions
+  def source_location; end
+end
+
+module MethodSource::SourceLocation::UnboundMethodExtensions
+  def source_location; end
+end
+
+class MethodSource::SourceNotFoundError < ::StandardError; end
+MethodSource::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/mime-types@3.3.1.rbi b/Library/Homebrew/sorbet/rbi/gems/mime-types@3.3.1.rbi
index 786dd4c4e1..9c6f497051 100644
--- a/Library/Homebrew/sorbet/rbi/gems/mime-types@3.3.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/mime-types@3.3.1.rbi
@@ -1,14 +1,13 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `mime-types` gem.
-# Please instead update this file by running `tapioca generate --exclude json`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-module MIME
-end
+module MIME; end
 
 class MIME::Type
-  include(::Comparable)
+  include ::Comparable
 
   def initialize(content_type); end
 
@@ -20,7 +19,7 @@ class MIME::Type
   def content_type; end
   def default_encoding; end
   def docs; end
-  def docs=(_); end
+  def docs=(_arg0); end
   def encode_with(coder); end
   def encoding; end
   def encoding=(enc); end
@@ -34,7 +33,7 @@ class MIME::Type
   def like?(other); end
   def media_type; end
   def obsolete; end
-  def obsolete=(_); end
+  def obsolete=(_arg0); end
   def obsolete?; end
   def preferred_extension; end
   def preferred_extension=(value); end
@@ -42,10 +41,10 @@ class MIME::Type
   def raw_media_type; end
   def raw_sub_type; end
   def registered; end
-  def registered=(_); end
+  def registered=(_arg0); end
   def registered?; end
   def signature; end
-  def signature=(_); end
+  def signature=(_arg0); end
   def signature?; end
   def simplified; end
   def sub_type; end
@@ -54,7 +53,7 @@ class MIME::Type
   def to_s; end
   def to_str; end
   def use_instead; end
-  def use_instead=(_); end
+  def use_instead=(_arg0); end
   def xref_urls; end
   def xrefs; end
   def xrefs=(xrefs); end
@@ -81,6 +80,9 @@ class MIME::Type
   end
 end
 
+MIME::Type::ASCII_ENCODINGS = T.let(T.unsafe(nil), Array)
+MIME::Type::BINARY_ENCODINGS = T.let(T.unsafe(nil), Array)
+
 class MIME::Type::Columnar < ::MIME::Type
   def initialize(container, content_type, extensions); end
 
@@ -108,6 +110,8 @@ class MIME::Type::Columnar < ::MIME::Type
   def xrefs=(*args); end
 end
 
+MIME::Type::I18N_RE = T.let(T.unsafe(nil), Regexp)
+
 class MIME::Type::InvalidContentType < ::ArgumentError
   def initialize(type_string); end
 
@@ -120,11 +124,12 @@ class MIME::Type::InvalidEncoding < ::ArgumentError
   def to_s; end
 end
 
+MIME::Type::MEDIA_TYPE_RE = T.let(T.unsafe(nil), Regexp)
 MIME::Type::VERSION = T.let(T.unsafe(nil), String)
 
 class MIME::Types
-  include(::Enumerable)
-  extend(::Enumerable)
+  include ::Enumerable
+  extend ::Enumerable
 
   def initialize; end
 
@@ -151,8 +156,8 @@ class MIME::Types
     def count; end
     def each; end
     def logger; end
-    def logger=(_); end
-    def new(*_); end
+    def logger=(_arg0); end
+    def new(*_arg0); end
     def of(filename); end
     def type_for(filename); end
 
@@ -174,11 +179,11 @@ class MIME::Types::Cache < ::Struct
   def version=(_); end
 
   class << self
-    def [](*_); end
+    def [](*_arg0); end
     def inspect; end
     def load(cache_file = T.unsafe(nil)); end
     def members; end
-    def new(*_); end
+    def new(*_arg0); end
     def save(types = T.unsafe(nil), cache_file = T.unsafe(nil)); end
   end
 end
@@ -209,7 +214,7 @@ end
 MIME::Types::Columnar::LOAD_MUTEX = T.let(T.unsafe(nil), Thread::Mutex)
 
 class MIME::Types::Container
-  extend(::Forwardable)
+  extend ::Forwardable
 
   def initialize(hash = T.unsafe(nil)); end
 
@@ -236,10 +241,12 @@ class MIME::Types::Container
   protected
 
   def container; end
-  def container=(_); end
+  def container=(_arg0); end
   def normalize; end
 end
 
+MIME::Types::Container::EMPTY_SET = T.let(T.unsafe(nil), Set)
+
 class MIME::Types::Loader
   def initialize(path = T.unsafe(nil), container = T.unsafe(nil)); end
 
@@ -274,7 +281,7 @@ class MIME::Types::WarnLogger < ::Logger
 end
 
 class MIME::Types::WarnLogger::WarnLogDevice < ::Logger::LogDevice
-  def initialize(*_); end
+  def initialize(*_arg0); end
 
   def close; end
   def write(m); end
diff --git a/Library/Homebrew/sorbet/rbi/gems/mini_portile2@2.5.3.rbi b/Library/Homebrew/sorbet/rbi/gems/mini_portile2@2.5.3.rbi
index c689517861..dcc7db1ed5 100644
--- a/Library/Homebrew/sorbet/rbi/gems/mini_portile2@2.5.3.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/mini_portile2@2.5.3.rbi
@@ -4,5 +4,91 @@
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+class MiniPortile
+  def initialize(name, version); end
+
+  def activate; end
+  def apply_patch(patch_file); end
+  def compile; end
+  def configure; end
+  def configure_options; end
+  def configure_options=(_arg0); end
+  def configured?; end
+  def cook; end
+  def download; end
+  def downloaded?; end
+  def extract; end
+  def files; end
+  def files=(_arg0); end
+  def host; end
+  def host=(_arg0); end
+  def install; end
+  def installed?; end
+  def logger; end
+  def logger=(_arg0); end
+  def name; end
+  def original_host; end
+  def patch; end
+  def patch_files; end
+  def patch_files=(_arg0); end
+  def path; end
+  def target; end
+  def target=(_arg0); end
+  def version; end
+
+  private
+
+  def archives_path; end
+  def computed_options; end
+  def configure_defaults; end
+  def configure_prefix; end
+  def detect_host; end
+  def download_file(url, full_path, count = T.unsafe(nil)); end
+  def download_file_file(uri, full_path); end
+  def download_file_ftp(uri, full_path); end
+  def download_file_http(url, full_path, count = T.unsafe(nil)); end
+  def execute(action, command, command_opts = T.unsafe(nil)); end
+  def extract_file(file, target); end
+  def files_hashs; end
+  def gcc_cmd; end
+  def log_file(action); end
+  def make_cmd; end
+  def message(text); end
+  def newer?(target, checkpoint); end
+  def output(text = T.unsafe(nil)); end
+  def port_path; end
+  def tar_compression_switch(filename); end
+  def tar_exe; end
+  def tmp_path; end
+  def verify_file(file); end
+  def which(cmd); end
+  def with_tempfile(filename, full_path); end
+  def work_path; end
+
+  class << self
+    def mingw?; end
+    def mswin?; end
+    def windows?; end
+  end
+end
+
+MiniPortile::KEYRING_NAME = T.let(T.unsafe(nil), String)
+MiniPortile::TAR_EXECUTABLES = T.let(T.unsafe(nil), Array)
+MiniPortile::VERSION = T.let(T.unsafe(nil), String)
+
+class MiniPortileCMake < ::MiniPortile
+  def configure; end
+  def configure_defaults; end
+  def configure_prefix; end
+  def configured?; end
+  def make_cmd; end
+end
+
+class Net::HTTP < ::Net::Protocol
+  private
+
+  def edit_path(path); end
+end
+
+Net::HTTP::ENVIRONMENT_VARIABLE_IS_MULTIUSER_SAFE = T.let(T.unsafe(nil), TrueClass)
+Net::HTTP::ProxyMod = Net::HTTP::ProxyDelta
diff --git a/Library/Homebrew/sorbet/rbi/gems/minitest@5.14.4.rbi b/Library/Homebrew/sorbet/rbi/gems/minitest@5.14.4.rbi
index 2a1c883812..31f2ddd6b1 100644
--- a/Library/Homebrew/sorbet/rbi/gems/minitest@5.14.4.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/minitest@5.14.4.rbi
@@ -1,8 +1,344 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `minitest` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module Minitest
+  class << self
+    def __run(reporter, options); end
+    def after_run(&block); end
+    def autorun; end
+    def backtrace_filter; end
+    def backtrace_filter=(_arg0); end
+    def clock_time; end
+    def extensions; end
+    def extensions=(_arg0); end
+    def filter_backtrace(bt); end
+    def info_signal; end
+    def info_signal=(_arg0); end
+    def init_plugins(options); end
+    def load_plugins; end
+    def parallel_executor; end
+    def parallel_executor=(_arg0); end
+    def process_args(args = T.unsafe(nil)); end
+    def reporter; end
+    def reporter=(_arg0); end
+    def run(args = T.unsafe(nil)); end
+    def run_one_method(klass, method_name); end
+  end
+end
+
+class Minitest::AbstractReporter
+  include ::Mutex_m
+
+  def lock; end
+  def locked?; end
+  def passed?; end
+  def prerecord(klass, name); end
+  def record(result); end
+  def report; end
+  def start; end
+  def synchronize(&block); end
+  def try_lock; end
+  def unlock; end
+end
+
+class Minitest::Assertion < ::Exception
+  def error; end
+  def location; end
+  def result_code; end
+  def result_label; end
+end
+
+module Minitest::Assertions
+  def _synchronize; end
+  def assert(test, msg = T.unsafe(nil)); end
+  def assert_empty(obj, msg = T.unsafe(nil)); end
+  def assert_equal(exp, act, msg = T.unsafe(nil)); end
+  def assert_in_delta(exp, act, delta = T.unsafe(nil), msg = T.unsafe(nil)); end
+  def assert_in_epsilon(exp, act, epsilon = T.unsafe(nil), msg = T.unsafe(nil)); end
+  def assert_includes(collection, obj, msg = T.unsafe(nil)); end
+  def assert_instance_of(cls, obj, msg = T.unsafe(nil)); end
+  def assert_kind_of(cls, obj, msg = T.unsafe(nil)); end
+  def assert_match(matcher, obj, msg = T.unsafe(nil)); end
+  def assert_nil(obj, msg = T.unsafe(nil)); end
+  def assert_operator(o1, op, o2 = T.unsafe(nil), msg = T.unsafe(nil)); end
+  def assert_output(stdout = T.unsafe(nil), stderr = T.unsafe(nil)); end
+  def assert_path_exists(path, msg = T.unsafe(nil)); end
+  def assert_predicate(o1, op, msg = T.unsafe(nil)); end
+  def assert_raises(*exp); end
+  def assert_respond_to(obj, meth, msg = T.unsafe(nil)); end
+  def assert_same(exp, act, msg = T.unsafe(nil)); end
+  def assert_send(send_ary, m = T.unsafe(nil)); end
+  def assert_silent; end
+  def assert_throws(sym, msg = T.unsafe(nil)); end
+  def capture_io; end
+  def capture_subprocess_io; end
+  def diff(exp, act); end
+  def exception_details(e, msg); end
+  def fail_after(y, m, d, msg); end
+  def flunk(msg = T.unsafe(nil)); end
+  def message(msg = T.unsafe(nil), ending = T.unsafe(nil), &default); end
+  def mu_pp(obj); end
+  def mu_pp_for_diff(obj); end
+  def pass(_msg = T.unsafe(nil)); end
+  def refute(test, msg = T.unsafe(nil)); end
+  def refute_empty(obj, msg = T.unsafe(nil)); end
+  def refute_equal(exp, act, msg = T.unsafe(nil)); end
+  def refute_in_delta(exp, act, delta = T.unsafe(nil), msg = T.unsafe(nil)); end
+  def refute_in_epsilon(a, b, epsilon = T.unsafe(nil), msg = T.unsafe(nil)); end
+  def refute_includes(collection, obj, msg = T.unsafe(nil)); end
+  def refute_instance_of(cls, obj, msg = T.unsafe(nil)); end
+  def refute_kind_of(cls, obj, msg = T.unsafe(nil)); end
+  def refute_match(matcher, obj, msg = T.unsafe(nil)); end
+  def refute_nil(obj, msg = T.unsafe(nil)); end
+  def refute_operator(o1, op, o2 = T.unsafe(nil), msg = T.unsafe(nil)); end
+  def refute_path_exists(path, msg = T.unsafe(nil)); end
+  def refute_predicate(o1, op, msg = T.unsafe(nil)); end
+  def refute_respond_to(obj, meth, msg = T.unsafe(nil)); end
+  def refute_same(exp, act, msg = T.unsafe(nil)); end
+  def skip(msg = T.unsafe(nil), bt = T.unsafe(nil)); end
+  def skip_until(y, m, d, msg); end
+  def skipped?; end
+  def things_to_diff(exp, act); end
+
+  class << self
+    def diff; end
+    def diff=(o); end
+  end
+end
+
+Minitest::Assertions::E = T.let(T.unsafe(nil), String)
+Minitest::Assertions::UNDEFINED = T.let(T.unsafe(nil), Object)
+
+class Minitest::BacktraceFilter
+  def filter(bt); end
+end
+
+Minitest::BacktraceFilter::MT_RE = T.let(T.unsafe(nil), Regexp)
+
+class Minitest::CompositeReporter < ::Minitest::AbstractReporter
+  def initialize(*reporters); end
+
+  def <<(reporter); end
+  def io; end
+  def passed?; end
+  def prerecord(klass, name); end
+  def record(result); end
+  def report; end
+  def reporters; end
+  def reporters=(_arg0); end
+  def start; end
+end
+
+Minitest::ENCS = T.let(T.unsafe(nil), TrueClass)
+
+module Minitest::Guard
+  def jruby?(platform = T.unsafe(nil)); end
+  def maglev?(platform = T.unsafe(nil)); end
+  def mri?(platform = T.unsafe(nil)); end
+  def osx?(platform = T.unsafe(nil)); end
+  def rubinius?(platform = T.unsafe(nil)); end
+  def windows?(platform = T.unsafe(nil)); end
+end
+
+module Minitest::Parallel; end
+
+class Minitest::Parallel::Executor
+  def initialize(size); end
+
+  def <<(work); end
+  def shutdown; end
+  def size; end
+  def start; end
+end
+
+module Minitest::Parallel::Test
+  def _synchronize; end
+end
+
+module Minitest::Parallel::Test::ClassMethods
+  def run_one_method(klass, method_name, reporter); end
+  def test_order; end
+end
+
+class Minitest::ProgressReporter < ::Minitest::Reporter
+  def prerecord(klass, name); end
+  def record(result); end
+end
+
+module Minitest::Reportable
+  def class_name; end
+  def error?; end
+  def location; end
+  def passed?; end
+  def result_code; end
+  def skipped?; end
+end
+
+class Minitest::Reporter < ::Minitest::AbstractReporter
+  def initialize(io = T.unsafe(nil), options = T.unsafe(nil)); end
+
+  def io; end
+  def io=(_arg0); end
+  def options; end
+  def options=(_arg0); end
+end
+
+class Minitest::Result < ::Minitest::Runnable
+  include ::Minitest::Reportable
+
+  def class_name; end
+  def klass; end
+  def klass=(_arg0); end
+  def source_location; end
+  def source_location=(_arg0); end
+  def to_s; end
+
+  class << self
+    def from(runnable); end
+  end
+end
+
+class Minitest::Runnable
+  def initialize(name); end
+
+  def assertions; end
+  def assertions=(_arg0); end
+  def failure; end
+  def failures; end
+  def failures=(_arg0); end
+  def marshal_dump; end
+  def marshal_load(ary); end
+  def name; end
+  def name=(o); end
+  def passed?; end
+  def result_code; end
+  def run; end
+  def skipped?; end
+  def time; end
+  def time=(_arg0); end
+  def time_it; end
+
+  class << self
+    def inherited(klass); end
+    def methods_matching(re); end
+    def on_signal(name, action); end
+    def reset; end
+    def run(reporter, options = T.unsafe(nil)); end
+    def run_one_method(klass, method_name, reporter); end
+    def runnable_methods; end
+    def runnables; end
+    def with_info_handler(reporter, &block); end
+  end
+end
+
+Minitest::Runnable::SIGNALS = T.let(T.unsafe(nil), Hash)
+
+class Minitest::Skip < ::Minitest::Assertion
+  def result_label; end
+end
+
+class Minitest::StatisticsReporter < ::Minitest::Reporter
+  def initialize(io = T.unsafe(nil), options = T.unsafe(nil)); end
+
+  def assertions; end
+  def assertions=(_arg0); end
+  def count; end
+  def count=(_arg0); end
+  def errors; end
+  def errors=(_arg0); end
+  def failures; end
+  def failures=(_arg0); end
+  def passed?; end
+  def record(result); end
+  def report; end
+  def results; end
+  def results=(_arg0); end
+  def skips; end
+  def skips=(_arg0); end
+  def start; end
+  def start_time; end
+  def start_time=(_arg0); end
+  def total_time; end
+  def total_time=(_arg0); end
+end
+
+class Minitest::SummaryReporter < ::Minitest::StatisticsReporter
+  def aggregated_results(io); end
+  def old_sync; end
+  def old_sync=(_arg0); end
+  def report; end
+  def start; end
+  def statistics; end
+  def summary; end
+  def sync; end
+  def sync=(_arg0); end
+  def to_s; end
+
+  private
+
+  def binary_string; end
+end
+
+class Minitest::Test < ::Minitest::Runnable
+  include ::Minitest::Assertions
+  include ::Minitest::Reportable
+  include ::Minitest::Test::LifecycleHooks
+  include ::Minitest::Guard
+  extend ::Minitest::Guard
+
+  def capture_exceptions; end
+  def class_name; end
+  def run; end
+  def with_info_handler(&block); end
+
+  class << self
+    def i_suck_and_my_tests_are_order_dependent!; end
+    def io_lock; end
+    def io_lock=(_arg0); end
+    def make_my_diffs_pretty!; end
+    def parallelize_me!; end
+    def runnable_methods; end
+    def test_order; end
+  end
+end
+
+module Minitest::Test::LifecycleHooks
+  def after_setup; end
+  def after_teardown; end
+  def before_setup; end
+  def before_teardown; end
+  def setup; end
+  def teardown; end
+end
+
+Minitest::Test::PASSTHROUGH_EXCEPTIONS = T.let(T.unsafe(nil), Array)
+Minitest::Test::TEARDOWN_METHODS = T.let(T.unsafe(nil), Array)
+
+class Minitest::UnexpectedError < ::Minitest::Assertion
+  def initialize(error); end
+
+  def backtrace; end
+  def error; end
+  def error=(_arg0); end
+  def message; end
+  def result_label; end
+end
+
+class Minitest::Unit
+  class << self
+    def after_tests(&b); end
+    def autorun; end
+  end
+end
+
+class Minitest::Unit::TestCase < ::Minitest::Test
+  class << self
+    def inherited(klass); end
+  end
+end
+
+Minitest::Unit::VERSION = T.let(T.unsafe(nil), String)
+Minitest::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/msgpack@1.4.2.rbi b/Library/Homebrew/sorbet/rbi/gems/msgpack@1.4.2.rbi
index fc385bdfb8..be8ff17603 100644
--- a/Library/Homebrew/sorbet/rbi/gems/msgpack@1.4.2.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/msgpack@1.4.2.rbi
@@ -1,7 +1,184 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `msgpack` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
+class Array
+  include ::Enumerable
+  include ::JSON::Ext::Generator::GeneratorMethods::Array
+  include ::Plist::Emit
+  include ::MessagePack::CoreExt
+
+  private
+
+  def to_msgpack_with_packer(packer); end
+end
+
 Bignum = Integer
+
+class FalseClass
+  include ::JSON::Ext::Generator::GeneratorMethods::FalseClass
+  include ::MessagePack::CoreExt
+
+  private
+
+  def to_msgpack_with_packer(packer); end
+end
+
+class Float < ::Numeric
+  include ::JSON::Ext::Generator::GeneratorMethods::Float
+  include ::MessagePack::CoreExt
+
+  private
+
+  def to_msgpack_with_packer(packer); end
+end
+
+class Hash
+  include ::Enumerable
+  include ::JSON::Ext::Generator::GeneratorMethods::Hash
+  include ::Plist::Emit
+  include ::MessagePack::CoreExt
+
+  private
+
+  def to_msgpack_with_packer(packer); end
+end
+
+class Integer < ::Numeric
+  include ::JSON::Ext::Generator::GeneratorMethods::Integer
+  include ::MessagePack::CoreExt
+
+  private
+
+  def to_msgpack_with_packer(packer); end
+end
+
+module MessagePack
+  private
+
+  def dump(v, *rest); end
+  def load(src, param = T.unsafe(nil)); end
+  def pack(v, *rest); end
+  def unpack(src, param = T.unsafe(nil)); end
+
+  class << self
+    def dump(v, *rest); end
+    def load(src, param = T.unsafe(nil)); end
+    def pack(v, *rest); end
+    def unpack(src, param = T.unsafe(nil)); end
+  end
+end
+
+module MessagePack::CoreExt
+  def to_msgpack(packer_or_io = T.unsafe(nil)); end
+end
+
+MessagePack::DEFAULT_EMPTY_PARAMS = T.let(T.unsafe(nil), Hash)
+
+class MessagePack::ExtensionValue < ::Struct
+  include ::MessagePack::CoreExt
+
+  def payload=(_); end
+  def type=(_); end
+
+  private
+
+  def to_msgpack_with_packer(packer); end
+end
+
+class MessagePack::Factory
+  def dump(v, *rest); end
+  def load(src, param = T.unsafe(nil)); end
+  def pack(v, *rest); end
+  def registered_types(selector = T.unsafe(nil)); end
+  def type_registered?(klass_or_type, selector = T.unsafe(nil)); end
+  def unpack(src, param = T.unsafe(nil)); end
+end
+
+class MessagePack::Packer
+  def registered_types; end
+  def type_registered?(klass_or_type); end
+end
+
+module MessagePack::Time; end
+MessagePack::Time::Packer = T.let(T.unsafe(nil), Proc)
+MessagePack::Time::TIME_AT_3_AVAILABLE = T.let(T.unsafe(nil), TrueClass)
+MessagePack::Time::Unpacker = T.let(T.unsafe(nil), Proc)
+
+class MessagePack::Timestamp
+  def initialize(sec, nsec); end
+
+  def ==(other); end
+  def nsec; end
+  def sec; end
+  def to_msgpack_ext; end
+
+  class << self
+    def from_msgpack_ext(data); end
+    def to_msgpack_ext(sec, nsec); end
+  end
+end
+
+MessagePack::Timestamp::TIMESTAMP32_MAX_SEC = T.let(T.unsafe(nil), Integer)
+MessagePack::Timestamp::TIMESTAMP64_MAX_SEC = T.let(T.unsafe(nil), Integer)
+MessagePack::Timestamp::TYPE = T.let(T.unsafe(nil), Integer)
+
+class MessagePack::UnexpectedTypeError < ::MessagePack::UnpackError
+  include ::MessagePack::TypeError
+end
+
+class MessagePack::Unpacker
+  def registered_types; end
+  def type_registered?(klass_or_type); end
+end
+
+class NilClass
+  include ::JSON::Ext::Generator::GeneratorMethods::NilClass
+  include ::MessagePack::CoreExt
+
+  private
+
+  def to_msgpack_with_packer(packer); end
+end
+
+class String
+  include ::Comparable
+  include ::JSON::Ext::Generator::GeneratorMethods::String
+  include ::Colorize::InstanceMethods
+  include ::MessagePack::CoreExt
+  extend ::JSON::Ext::Generator::GeneratorMethods::String::Extend
+  extend ::Colorize::ClassMethods
+
+  private
+
+  def to_msgpack_with_packer(packer); end
+end
+
+String::BLANK_RE = T.let(T.unsafe(nil), Regexp)
+String::ENCODED_BLANKS = T.let(T.unsafe(nil), Concurrent::Map)
+
+class Symbol
+  include ::Comparable
+  include ::MessagePack::CoreExt
+
+  def to_msgpack_ext; end
+
+  private
+
+  def to_msgpack_with_packer(packer); end
+
+  class << self
+    def from_msgpack_ext(data); end
+  end
+end
+
+class TrueClass
+  include ::JSON::Ext::Generator::GeneratorMethods::TrueClass
+  include ::MessagePack::CoreExt
+
+  private
+
+  def to_msgpack_with_packer(packer); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/mustache@1.1.1.rbi b/Library/Homebrew/sorbet/rbi/gems/mustache@1.1.1.rbi
index c197d416ee..52eb183fc1 100644
--- a/Library/Homebrew/sorbet/rbi/gems/mustache@1.1.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/mustache@1.1.1.rbi
@@ -1,7 +1,189 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `mustache` gem.
-# Please instead update this file by running `tapioca generate --exclude json`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
+class Mustache
+  def initialize(options = T.unsafe(nil)); end
 
+  def [](key); end
+  def []=(key, value); end
+  def compiled?; end
+  def context; end
+  def escape(value); end
+  def escapeHTML(str); end
+  def initialize_settings; end
+  def partial(name); end
+  def path; end
+  def raise_on_context_miss=(boolean); end
+  def raise_on_context_miss?; end
+  def render(data = T.unsafe(nil), ctx = T.unsafe(nil)); end
+  def render_file(name, context = T.unsafe(nil)); end
+  def template; end
+  def template=(template); end
+  def template_extension; end
+  def template_extension=(template_extension); end
+  def template_file; end
+  def template_file=(template_file); end
+  def template_name; end
+  def template_name=(template_name); end
+  def template_path; end
+  def template_path=(path); end
+
+  private
+
+  def templateify(obj); end
+
+  class << self
+    def classify(underscored); end
+    def compiled?; end
+    def const_from_file(name); end
+    def inheritable_config_for(attr_name, default); end
+    def inherited(subclass); end
+    def initialize_settings; end
+    def partial(name); end
+    def path; end
+    def path=(path); end
+    def raise_on_context_miss=(boolean); end
+    def raise_on_context_miss?; end
+    def render(*args); end
+    def render_file(name, context = T.unsafe(nil)); end
+    def rescued_const_get(name); end
+    def template; end
+    def template=(template); end
+    def template_extension; end
+    def template_extension=(template_extension); end
+    def template_file; end
+    def template_file=(template_file); end
+    def template_name; end
+    def template_name=(template_name); end
+    def template_path; end
+    def template_path=(path); end
+    def templateify(obj, options = T.unsafe(nil)); end
+    def underscore(classified = T.unsafe(nil)); end
+    def view_class(name); end
+    def view_namespace; end
+    def view_namespace=(namespace); end
+    def view_path; end
+    def view_path=(path); end
+  end
+end
+
+class Mustache::Context
+  def initialize(mustache); end
+
+  def [](name); end
+  def []=(name, value); end
+  def current; end
+  def escape(value); end
+  def fetch(name, default = T.unsafe(nil)); end
+  def find(obj, key, default = T.unsafe(nil)); end
+  def has_key?(key); end
+  def mustache_in_stack; end
+  def partial(name, indentation = T.unsafe(nil)); end
+  def pop; end
+  def push(new_obj); end
+  def template_for_partial(partial); end
+
+  private
+
+  def find_in_hash(obj, key, default); end
+end
+
+class Mustache::ContextMiss < ::RuntimeError; end
+module Mustache::Enumerable; end
+
+class Mustache::Generator
+  def initialize(options = T.unsafe(nil)); end
+
+  def compile(exp); end
+
+  private
+
+  def compile!(exp); end
+  def ev(s); end
+  def on_etag(name, offset); end
+  def on_fetch(names); end
+  def on_inverted_section(name, offset, content, raw, delims); end
+  def on_partial(name, offset, indentation); end
+  def on_section(name, offset, content, raw, delims); end
+  def on_utag(name, offset); end
+  def str(s); end
+end
+
+class Mustache::Parser
+  def initialize(options = T.unsafe(nil)); end
+
+  def compile(template); end
+  def ctag; end
+  def ctag=(value); end
+  def otag; end
+  def otag=(value); end
+
+  private
+
+  def content_tags(type, current_ctag_regex); end
+  def dispatch_based_on_type(type, content, fetch, padding, pre_match_position); end
+  def error(message, pos = T.unsafe(nil)); end
+  def find_closing_tag(scanner, current_ctag_regex); end
+  def offset; end
+  def position; end
+  def regexp(thing); end
+  def scan_tag_(content, fetch, padding, pre_match_position); end
+  def scan_tag_!(content, fetch, padding, pre_match_position); end
+  def scan_tag_=(content, fetch, padding, pre_match_position); end
+  def scan_tag_block(content, fetch, padding, pre_match_position); end
+  def scan_tag_close(content, fetch, padding, pre_match_position); end
+  def scan_tag_comment(content, fetch, padding, pre_match_position); end
+  def scan_tag_delimiter(content, fetch, padding, pre_match_position); end
+  def scan_tag_inverted(content, fetch, padding, pre_match_position); end
+  def scan_tag_open_partial(content, fetch, padding, pre_match_position); end
+  def scan_tag_unescaped(content, fetch, padding, pre_match_position); end
+  def scan_tags; end
+  def scan_text; end
+  def scan_until_exclusive(regexp); end
+
+  class << self
+    def add_type(*types, &block); end
+    def valid_types; end
+  end
+end
+
+Mustache::Parser::ALLOWED_CONTENT = T.let(T.unsafe(nil), Regexp)
+Mustache::Parser::ANY_CONTENT = T.let(T.unsafe(nil), Array)
+Mustache::Parser::SKIP_WHITESPACE = T.let(T.unsafe(nil), Array)
+
+class Mustache::Parser::SyntaxError < ::StandardError
+  def initialize(message, position); end
+
+  def to_s; end
+end
+
+Mustache::Parser::VALID_TYPES = T.let(T.unsafe(nil), Array)
+
+class Mustache::Template
+  def initialize(source, options = T.unsafe(nil)); end
+
+  def compile(src = T.unsafe(nil)); end
+  def partials; end
+  def render(context); end
+  def sections; end
+  def source; end
+  def tags; end
+  def to_s(src = T.unsafe(nil)); end
+  def tokens(src = T.unsafe(nil)); end
+
+  class << self
+    def recursor(toks, section, &block); end
+  end
+end
+
+module Mustache::Utils; end
+
+class Mustache::Utils::String
+  def initialize(string); end
+
+  def classify; end
+  def underscore(view_namespace); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/net-http-digest_auth@1.4.1.rbi b/Library/Homebrew/sorbet/rbi/gems/net-http-digest_auth@1.4.1.rbi
index 8d040b7e6e..f608e4d85e 100644
--- a/Library/Homebrew/sorbet/rbi/gems/net-http-digest_auth@1.4.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/net-http-digest_auth@1.4.1.rbi
@@ -1,7 +1,8 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `net-http-digest_auth` gem.
-# Please instead update this file by running `tapioca generate --exclude json`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
diff --git a/Library/Homebrew/sorbet/rbi/gems/net-http-persistent@4.0.1.rbi b/Library/Homebrew/sorbet/rbi/gems/net-http-persistent@4.0.1.rbi
index 46dcb4b1f7..fc8473d482 100644
--- a/Library/Homebrew/sorbet/rbi/gems/net-http-persistent@4.0.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/net-http-persistent@4.0.1.rbi
@@ -1,6 +1,6 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `net-http-persistent` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
@@ -108,11 +108,8 @@ class Net::HTTP::Persistent::Connection
 end
 
 Net::HTTP::Persistent::DEFAULT_POOL_SIZE = T.let(T.unsafe(nil), Integer)
-
 Net::HTTP::Persistent::EPOCH = T.let(T.unsafe(nil), Time)
-
-class Net::HTTP::Persistent::Error < ::StandardError
-end
+class Net::HTTP::Persistent::Error < ::StandardError; end
 
 class Net::HTTP::Persistent::Pool < ::ConnectionPool
   def initialize(options = T.unsafe(nil), &block); end
diff --git a/Library/Homebrew/sorbet/rbi/gems/parallel@1.20.1.rbi b/Library/Homebrew/sorbet/rbi/gems/parallel@1.20.1.rbi
index 2040146562..d205949e4f 100644
--- a/Library/Homebrew/sorbet/rbi/gems/parallel@1.20.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/parallel@1.20.1.rbi
@@ -1,11 +1,11 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `parallel` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
 module Parallel
-  extend(::Parallel::ProcessorCount)
+  extend ::Parallel::ProcessorCount
 
   class << self
     def all?(*args, &block); end
@@ -42,8 +42,7 @@ class Parallel::Break < ::StandardError
   def value; end
 end
 
-class Parallel::DeadWorker < ::StandardError
-end
+class Parallel::DeadWorker < ::StandardError; end
 
 class Parallel::ExceptionWrapper
   def initialize(exception); end
@@ -65,8 +64,7 @@ class Parallel::JobFactory
   def queue_wrapper(array); end
 end
 
-class Parallel::Kill < ::Parallel::Break
-end
+class Parallel::Kill < ::Parallel::Break; end
 
 module Parallel::ProcessorCount
   def physical_processor_count; end
@@ -94,9 +92,7 @@ class Parallel::UserInterruptHandler
 end
 
 Parallel::UserInterruptHandler::INTERRUPT_SIGNAL = T.let(T.unsafe(nil), Symbol)
-
 Parallel::VERSION = T.let(T.unsafe(nil), String)
-
 Parallel::Version = T.let(T.unsafe(nil), String)
 
 class Parallel::Worker
diff --git a/Library/Homebrew/sorbet/rbi/gems/parallel_tests@3.7.1.rbi b/Library/Homebrew/sorbet/rbi/gems/parallel_tests@3.7.1.rbi
index def786570e..72fa4ff9aa 100644
--- a/Library/Homebrew/sorbet/rbi/gems/parallel_tests@3.7.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/parallel_tests@3.7.1.rbi
@@ -4,5 +4,92 @@
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module ParallelTests
+  class << self
+    def bundler_enabled?; end
+    def delta; end
+    def determine_number_of_processes(count); end
+    def first_process?; end
+    def last_process?; end
+    def now; end
+    def number_of_running_processes; end
+    def pid_file_path; end
+    def pids; end
+    def stop_all_processes; end
+    def wait_for_other_processes_to_finish; end
+    def with_pid_file; end
+    def with_ruby_binary(command); end
+  end
+end
+
+class ParallelTests::CLI
+  def run(argv); end
+
+  private
+
+  def any_test_failed?(test_results); end
+  def append_test_options(options, argv); end
+  def detailed_duration(seconds); end
+  def execute_in_parallel(items, num_processes, options); end
+  def execute_shell_command_in_parallel(command, num_processes, options); end
+  def extract_file_paths(argv); end
+  def extract_test_options(argv); end
+  def final_fail_message; end
+  def first_is_1?; end
+  def handle_interrupt; end
+  def load_runner(type); end
+  def lock(lockfile); end
+  def parse_options!(argv); end
+  def pluralize(n, singular); end
+  def report_failure_rerun_commmand(test_results, options); end
+  def report_number_of_tests(groups); end
+  def report_results(test_results, options); end
+  def report_time_taken(&block); end
+  def reprint_output(result, lockfile); end
+  def run_tests(group, process_number, num_processes, options); end
+  def run_tests_in_parallel(num_processes, options); end
+  def simulate_output_for_ci(simulate); end
+  def use_colors?; end
+end
+
+class ParallelTests::Grouper
+  class << self
+    def by_scenarios(tests, num_groups, options = T.unsafe(nil)); end
+    def by_steps(tests, num_groups, options); end
+    def in_even_groups_by_size(items, num_groups, options = T.unsafe(nil)); end
+
+    private
+
+    def add_to_group(group, item, size); end
+    def group_by_features_with_steps(tests, options); end
+    def group_by_scenarios(tests, options = T.unsafe(nil)); end
+    def group_features_by_size(items, groups_to_fill); end
+    def isolate_count(options); end
+    def items_to_group(items); end
+    def largest_first(files); end
+    def smallest_group(groups); end
+    def specify_groups(items, num_groups, options, groups); end
+  end
+end
+
+class ParallelTests::Pids
+  def initialize(file_path); end
+
+  def add(pid); end
+  def all; end
+  def count; end
+  def delete(pid); end
+  def file_path; end
+  def mutex; end
+
+  private
+
+  def clear; end
+  def pids; end
+  def read; end
+  def save; end
+  def sync(&block); end
+end
+
+ParallelTests::RUBY_BINARY = T.let(T.unsafe(nil), String)
+ParallelTests::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/parlour@6.0.1.rbi b/Library/Homebrew/sorbet/rbi/gems/parlour@6.0.1.rbi
index ef05efa111..ba8e08110c 100644
--- a/Library/Homebrew/sorbet/rbi/gems/parlour@6.0.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/parlour@6.0.1.rbi
@@ -4,39 +4,6 @@
 
 # typed: true
 
-class AST::Node
-  def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
-
-  def +(array); end
-  def <<(element); end
-  def ==(other); end
-  def append(element); end
-  def children; end
-  def clone; end
-  def concat(array); end
-  def deconstruct; end
-  def dup; end
-  def eql?(other); end
-  def hash; end
-  def inspect(indent = T.unsafe(nil)); end
-  def to_a; end
-  def to_ast; end
-  def to_s(indent = T.unsafe(nil)); end
-  def to_sexp(indent = T.unsafe(nil)); end
-  def to_sexp_array; end
-  def type; end
-  def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end
-
-  protected
-
-  def assign_properties(properties); end
-  def fancy_type; end
-
-  private
-
-  def original_dup; end
-end
-
 module Parlour; end
 
 class Parlour::ConflictResolver
@@ -1641,86 +1608,3 @@ class Parlour::Types::Untyped < ::Parlour::Types::Type
 end
 
 Parlour::VERSION = T.let(T.unsafe(nil), String)
-
-class Parser::AST::Node < ::AST::Node
-  def assign_properties(properties); end
-  def loc; end
-  def location; end
-end
-
-class Parser::Source::Buffer
-  def initialize(name, first_line = T.unsafe(nil), source: T.unsafe(nil)); end
-
-  def column_for_position(position); end
-  def decompose_position(position); end
-  def first_line; end
-  def freeze; end
-  def inspect; end
-  def last_line; end
-  def line_for_position(position); end
-  def line_range(lineno); end
-  def name; end
-  def raw_source=(input); end
-  def read; end
-  def slice(range); end
-  def source; end
-  def source=(input); end
-  def source_line(lineno); end
-  def source_lines; end
-  def source_range; end
-
-  private
-
-  def bsearch(line_begins, position); end
-  def line_begins; end
-  def line_index_for_position(position); end
-
-  class << self
-    def recognize_encoding(string); end
-    def reencode_string(input); end
-  end
-end
-
-Parser::Source::Buffer::ENCODING_RE = T.let(T.unsafe(nil), Regexp)
-
-class Parser::Source::Range
-  include ::Comparable
-  include ::RuboCop::AST::Ext::Range
-
-  def initialize(source_buffer, begin_pos, end_pos); end
-
-  def <=>(other); end
-  def adjust(begin_pos: T.unsafe(nil), end_pos: T.unsafe(nil)); end
-  def begin; end
-  def begin_pos; end
-  def column; end
-  def column_range; end
-  def contained?(other); end
-  def contains?(other); end
-  def crossing?(other); end
-  def disjoint?(other); end
-  def empty?; end
-  def end; end
-  def end_pos; end
-  def eql?(_arg0); end
-  def first_line; end
-  def hash; end
-  def inspect; end
-  def intersect(other); end
-  def is?(*what); end
-  def join(other); end
-  def last_column; end
-  def last_line; end
-  def length; end
-  def line; end
-  def overlaps?(other); end
-  def resize(new_size); end
-  def size; end
-  def source; end
-  def source_buffer; end
-  def source_line; end
-  def to_a; end
-  def to_range; end
-  def to_s; end
-  def with(begin_pos: T.unsafe(nil), end_pos: T.unsafe(nil)); end
-end
diff --git a/Library/Homebrew/sorbet/rbi/gems/parser@3.0.2.0.rbi b/Library/Homebrew/sorbet/rbi/gems/parser@3.0.2.0.rbi
index 5bb1c3b6b0..219e77e42a 100644
--- a/Library/Homebrew/sorbet/rbi/gems/parser@3.0.2.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/parser@3.0.2.0.rbi
@@ -4,49 +4,6 @@
 
 # typed: true
 
-class AST::Node
-  def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
-
-  def +(array); end
-  def <<(element); end
-  def ==(other); end
-  def append(element); end
-  def children; end
-  def clone; end
-  def concat(array); end
-  def deconstruct; end
-  def dup; end
-  def eql?(other); end
-  def hash; end
-  def inspect(indent = T.unsafe(nil)); end
-  def to_a; end
-  def to_ast; end
-  def to_s(indent = T.unsafe(nil)); end
-  def to_sexp(indent = T.unsafe(nil)); end
-  def to_sexp_array; end
-  def type; end
-  def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end
-
-  protected
-
-  def assign_properties(properties); end
-  def fancy_type; end
-
-  private
-
-  def original_dup; end
-end
-
-class AST::Processor
-  include ::AST::Processor::Mixin
-end
-
-module AST::Processor::Mixin
-  def handler_missing(node); end
-  def process(node); end
-  def process_all(nodes); end
-end
-
 module Parser
   class << self
     private
diff --git a/Library/Homebrew/sorbet/rbi/gems/patchelf@1.3.0.rbi b/Library/Homebrew/sorbet/rbi/gems/patchelf@1.3.0.rbi
index 2cef17cf0b..381a66a8bb 100644
--- a/Library/Homebrew/sorbet/rbi/gems/patchelf@1.3.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/patchelf@1.3.0.rbi
@@ -1,14 +1,12 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `patchelf` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-module PatchELF
-end
+module PatchELF; end
 
 module PatchELF::Helper
-
   private
 
   def aligndown(val, align = T.unsafe(nil)); end
@@ -25,11 +23,9 @@ module PatchELF::Helper
 end
 
 PatchELF::Helper::COLOR_CODE = T.let(T.unsafe(nil), Hash)
-
 PatchELF::Helper::PAGE_SIZE = T.let(T.unsafe(nil), Integer)
 
 module PatchELF::Logger
-
   private
 
   def debug(msg); end
@@ -72,14 +68,9 @@ class PatchELF::MM
   def writable?(seg); end
 end
 
-class PatchELF::MissingSegmentError < ::PatchELF::PatchError
-end
-
-class PatchELF::MissingTagError < ::PatchELF::PatchError
-end
-
-class PatchELF::PatchError < ::ELFTools::ELFError
-end
+class PatchELF::MissingSegmentError < ::PatchELF::PatchError; end
+class PatchELF::MissingTagError < ::PatchELF::PatchError; end
+class PatchELF::PatchError < ::ELFTools::ELFError; end
 
 class PatchELF::Patcher
   def initialize(filename, on_error: T.unsafe(nil), logging: T.unsafe(nil)); end
@@ -139,5 +130,4 @@ class PatchELF::Saver
 end
 
 PatchELF::Saver::IGNORE = T.let(T.unsafe(nil), Integer)
-
 PatchELF::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/plist@3.6.0.rbi b/Library/Homebrew/sorbet/rbi/gems/plist@3.6.0.rbi
index 75cbcab250..e9cbfc15bd 100644
--- a/Library/Homebrew/sorbet/rbi/gems/plist@3.6.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/plist@3.6.0.rbi
@@ -1,6 +1,6 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `plist` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
@@ -119,20 +119,11 @@ class Plist::StreamParser
 end
 
 Plist::StreamParser::CDATA = T.let(T.unsafe(nil), Regexp)
-
 Plist::StreamParser::COMMENT_END = T.let(T.unsafe(nil), Regexp)
-
 Plist::StreamParser::COMMENT_START = T.let(T.unsafe(nil), Regexp)
-
 Plist::StreamParser::DOCTYPE_PATTERN = T.let(T.unsafe(nil), Regexp)
-
 Plist::StreamParser::TEXT = T.let(T.unsafe(nil), Regexp)
-
 Plist::StreamParser::UNIMPLEMENTED_ERROR = T.let(T.unsafe(nil), String)
-
 Plist::StreamParser::XMLDECL_PATTERN = T.let(T.unsafe(nil), Regexp)
-
-class Plist::UnimplementedElementError < ::RuntimeError
-end
-
+class Plist::UnimplementedElementError < ::RuntimeError; end
 Plist::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/pry@0.14.1.rbi b/Library/Homebrew/sorbet/rbi/gems/pry@0.14.1.rbi
index 9f8d9e38ce..bf7ee57e8c 100644
--- a/Library/Homebrew/sorbet/rbi/gems/pry@0.14.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/pry@0.14.1.rbi
@@ -4,5 +4,2488 @@
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+class BasicObject
+  def __binding__; end
+end
+
+class Object < ::BasicObject
+  include ::ActiveSupport::ForkTracker::CoreExt
+  include ::ActiveSupport::ForkTracker::CoreExtPrivate
+  include ::ActiveSupport::ToJsonWithActiveSupportEncoder
+  include ::Kernel
+  include ::JSON::Ext::Generator::GeneratorMethods::Object
+  include ::PP::ObjectMixin
+  include ::ActiveSupport::Tryable
+  include ::ActiveSupport::Dependencies::Loadable
+
+  def __binding__; end
+  def pry(object = T.unsafe(nil), hash = T.unsafe(nil)); end
+end
+
+class Pry
+  extend ::Forwardable
+  extend ::Pry::Forwardable
+
+  def initialize(options = T.unsafe(nil)); end
+
+  def add_sticky_local(name, &block); end
+  def backtrace; end
+  def backtrace=(_arg0); end
+  def binding_stack; end
+  def binding_stack=(_arg0); end
+  def color(*args, &block); end
+  def color=(*args, &block); end
+  def commands(*args, &block); end
+  def commands=(*args, &block); end
+  def complete(str); end
+  def config; end
+  def current_binding; end
+  def current_context; end
+  def custom_completions; end
+  def custom_completions=(_arg0); end
+  def editor(*args, &block); end
+  def editor=(*args, &block); end
+  def eval(line, options = T.unsafe(nil)); end
+  def eval_string; end
+  def eval_string=(_arg0); end
+  def evaluate_ruby(code); end
+  def exception_handler(*args, &block); end
+  def exception_handler=(*args, &block); end
+  def exec_hook(name, *args, &block); end
+  def exit_value; end
+  def extra_sticky_locals(*args, &block); end
+  def extra_sticky_locals=(*args, &block); end
+  def hooks(*args, &block); end
+  def hooks=(*args, &block); end
+  def inject_local(name, value, binding); end
+  def inject_sticky_locals!; end
+  def input(*args, &block); end
+  def input=(*args, &block); end
+  def input_ring; end
+  def last_dir; end
+  def last_dir=(_arg0); end
+  def last_exception; end
+  def last_exception=(exception); end
+  def last_file; end
+  def last_file=(_arg0); end
+  def last_result; end
+  def last_result=(_arg0); end
+  def last_result_is_exception?; end
+  def memory_size; end
+  def memory_size=(size); end
+  def output; end
+  def output=(*args, &block); end
+  def output_ring; end
+  def pager; end
+  def pager=(*args, &block); end
+  def pop_prompt; end
+  def print(*args, &block); end
+  def print=(*args, &block); end
+  def process_command(val); end
+  def process_command_safely(val); end
+  def prompt; end
+  def prompt=(new_prompt); end
+  def push_binding(object); end
+  def push_initial_binding(target = T.unsafe(nil)); end
+  def push_prompt(new_prompt); end
+  def quiet?; end
+  def raise_up(*args); end
+  def raise_up!(*args); end
+  def raise_up_common(force, *args); end
+  def repl(target = T.unsafe(nil)); end
+  def reset_eval_string; end
+  def run_command(val); end
+  def select_prompt; end
+  def set_last_result(result, code = T.unsafe(nil)); end
+  def should_print?; end
+  def show_result(result); end
+  def sticky_locals; end
+  def suppress_output; end
+  def suppress_output=(_arg0); end
+  def update_input_history(code); end
+
+  private
+
+  def ensure_correct_encoding!(val); end
+  def generate_prompt(prompt_proc, conf); end
+  def handle_line(line, options); end
+  def prompt_stack; end
+
+  class << self
+    def Code(obj); end
+    def Method(obj); end
+    def WrappedModule(obj); end
+    def auto_resize!; end
+    def binding_for(target); end
+    def cli; end
+    def cli=(_arg0); end
+    def color(*args, &block); end
+    def color=(*args, &block); end
+    def commands(*args, &block); end
+    def commands=(*args, &block); end
+    def config; end
+    def config=(_arg0); end
+    def configure; end
+    def critical_section; end
+    def current; end
+    def current_line; end
+    def current_line=(_arg0); end
+    def custom_completions; end
+    def custom_completions=(_arg0); end
+    def editor(*args, &block); end
+    def editor=(*args, &block); end
+    def eval_path; end
+    def eval_path=(_arg0); end
+    def exception_handler(*args, &block); end
+    def exception_handler=(*args, &block); end
+    def extra_sticky_locals(*args, &block); end
+    def extra_sticky_locals=(*args, &block); end
+    def final_session_setup; end
+    def history(*args, &block); end
+    def history=(*args, &block); end
+    def hooks(*args, &block); end
+    def hooks=(*args, &block); end
+    def in_critical_section?; end
+    def init; end
+    def initial_session?; end
+    def initial_session_setup; end
+    def input(*args, &block); end
+    def input=(*args, &block); end
+    def last_internal_error; end
+    def last_internal_error=(_arg0); end
+    def line_buffer; end
+    def line_buffer=(_arg0); end
+    def load_file_at_toplevel(file); end
+    def load_file_through_repl(file_name); end
+    def load_history; end
+    def load_rc_files; end
+    def load_requires; end
+    def load_traps; end
+    def load_win32console; end
+    def main; end
+    def memory_size(*args, &block); end
+    def memory_size=(*args, &block); end
+    def output(*args, &block); end
+    def output=(*args, &block); end
+    def pager(*args, &block); end
+    def pager=(*args, &block); end
+    def print(*args, &block); end
+    def print=(*args, &block); end
+    def prompt(*args, &block); end
+    def prompt=(*args, &block); end
+    def quiet; end
+    def quiet=(_arg0); end
+    def rc_files_to_load; end
+    def real_path_to(file); end
+    def reset_defaults; end
+    def run_command(command_string, options = T.unsafe(nil)); end
+    def start(target = T.unsafe(nil), options = T.unsafe(nil)); end
+    def toplevel_binding; end
+    def toplevel_binding=(_arg0); end
+    def view_clip(obj, options = T.unsafe(nil)); end
+  end
+end
+
+Pry::BINDING_METHOD_IMPL = T.let(T.unsafe(nil), Array)
+
+class Pry::BasicObject < ::BasicObject
+  include ::Kernel
+end
+
+Pry::BasicObject::Dir = Dir
+Pry::BasicObject::ENV = T.let(T.unsafe(nil), Object)
+Pry::BasicObject::File = File
+Pry::BasicObject::Kernel = Kernel
+Pry::BasicObject::LoadError = LoadError
+Pry::BasicObject::Pry = Pry
+
+class Pry::BlockCommand < ::Pry::Command
+  def call(*args); end
+  def help; end
+end
+
+class Pry::CLI
+  class << self
+    def add_option_processor(&block); end
+    def add_options(&block); end
+    def input_args; end
+    def input_args=(_arg0); end
+    def option_processors; end
+    def option_processors=(_arg0); end
+    def options; end
+    def options=(_arg0); end
+    def parse_options(args = T.unsafe(nil)); end
+    def reset; end
+    def start(opts); end
+  end
+end
+
+class Pry::CLI::NoOptionsError < ::StandardError; end
+
+class Pry::ClassCommand < ::Pry::Command
+  def args; end
+  def args=(_arg0); end
+  def call(*args); end
+  def complete(search); end
+  def help; end
+  def options(opt); end
+  def opts; end
+  def opts=(_arg0); end
+  def process; end
+  def setup; end
+  def slop; end
+  def subcommands(cmd); end
+
+  class << self
+    def doc; end
+    def file; end
+    def inherited(klass); end
+    def line; end
+    def source; end
+    def source_file; end
+    def source_line; end
+    def source_location; end
+
+    private
+
+    def source_object; end
+  end
+end
+
+class Pry::Code
+  extend ::MethodSource::CodeHelpers
+
+  def initialize(lines = T.unsafe(nil), start_line = T.unsafe(nil), code_type = T.unsafe(nil)); end
+
+  def <<(line); end
+  def ==(other); end
+  def after(lineno, lines = T.unsafe(nil)); end
+  def around(lineno, lines = T.unsafe(nil)); end
+  def before(lineno, lines = T.unsafe(nil)); end
+  def between(start_line, end_line = T.unsafe(nil)); end
+  def code_type; end
+  def code_type=(_arg0); end
+  def comment_describing(line_number); end
+  def expression_at(line_number, consume = T.unsafe(nil)); end
+  def grep(pattern); end
+  def highlighted; end
+  def length; end
+  def max_lineno_width; end
+  def method_missing(method_name, *args, &block); end
+  def nesting_at(line_number); end
+  def print_to_output(output, color = T.unsafe(nil)); end
+  def push(line); end
+  def raw; end
+  def reject(&block); end
+  def select(&block); end
+  def take_lines(start_line, num_lines); end
+  def to_s; end
+  def with_indentation(spaces = T.unsafe(nil)); end
+  def with_line_numbers(y_n = T.unsafe(nil)); end
+  def with_marker(lineno = T.unsafe(nil)); end
+
+  protected
+
+  def alter(&block); end
+
+  private
+
+  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
+
+  class << self
+    def from_file(filename, code_type = T.unsafe(nil)); end
+    def from_method(meth, start_line = T.unsafe(nil)); end
+    def from_module(mod, candidate_rank = T.unsafe(nil), start_line = T.unsafe(nil)); end
+  end
+end
+
+class Pry::Code::CodeRange
+  def initialize(start_line, end_line = T.unsafe(nil)); end
+
+  def indices_range(lines); end
+
+  private
+
+  def end_line; end
+  def find_end_index(lines); end
+  def find_start_index(lines); end
+  def force_set_end_line; end
+  def indices(lines); end
+  def set_end_line_from_range; end
+  def start_line; end
+end
+
+class Pry::Code::LOC
+  def initialize(line, lineno); end
+
+  def ==(other); end
+  def add_line_number(max_width = T.unsafe(nil), color = T.unsafe(nil)); end
+  def add_marker(marker_lineno); end
+  def colorize(code_type); end
+  def dup; end
+  def handle_multiline_entries_from_edit_command(line, max_width); end
+  def indent(distance); end
+  def line; end
+  def lineno; end
+  def tuple; end
+end
+
+class Pry::CodeFile
+  def initialize(filename, code_type = T.unsafe(nil)); end
+
+  def code; end
+  def code_type; end
+
+  private
+
+  def abs_path; end
+  def code_path; end
+  def from_load_path; end
+  def from_pry_init_pwd; end
+  def from_pwd; end
+  def readable?(path); end
+  def type_from_filename(filename, default = T.unsafe(nil)); end
+end
+
+Pry::CodeFile::DEFAULT_EXT = T.let(T.unsafe(nil), String)
+Pry::CodeFile::EXTENSIONS = T.let(T.unsafe(nil), Hash)
+Pry::CodeFile::FILES = T.let(T.unsafe(nil), Hash)
+Pry::CodeFile::INITIAL_PWD = T.let(T.unsafe(nil), String)
+
+class Pry::CodeObject
+  include ::Pry::Helpers::OptionsHelpers
+  include ::Pry::Helpers::CommandHelpers
+
+  def initialize(str, pry_instance, options = T.unsafe(nil)); end
+
+  def command_lookup; end
+  def default_lookup; end
+  def empty_lookup; end
+  def method_or_class_lookup; end
+  def pry_instance; end
+  def pry_instance=(_arg0); end
+  def str; end
+  def str=(_arg0); end
+  def super_level; end
+  def super_level=(_arg0); end
+  def target; end
+  def target=(_arg0); end
+
+  private
+
+  def looks_like_an_instance_method?(str); end
+  def lookup_super(obj, super_level); end
+  def safe_to_evaluate?(str); end
+  def sourcable_object?(obj); end
+  def target_self; end
+
+  class << self
+    def lookup(str, pry_instance, options = T.unsafe(nil)); end
+  end
+end
+
+module Pry::CodeObject::Helpers
+  def c_method?; end
+  def c_module?; end
+  def command?; end
+  def module_with_yard_docs?; end
+  def real_method_object?; end
+end
+
+class Pry::ColorPrinter < ::PP
+  def pp(object); end
+  def text(str, max_width = T.unsafe(nil)); end
+
+  private
+
+  def highlight_object_literal(object_literal); end
+  def inspect_object(object); end
+
+  class << self
+    def default(_output, value, pry_instance); end
+    def pp(obj, output = T.unsafe(nil), max_width = T.unsafe(nil)); end
+  end
+end
+
+class Pry::Command
+  include ::Pry::Helpers::BaseHelpers
+  include ::Pry::Helpers::OptionsHelpers
+  include ::Pry::Helpers::CommandHelpers
+  include ::Pry::Helpers::Text
+  extend ::Pry::Helpers::DocumentationHelpers
+  extend ::Pry::CodeObject::Helpers
+
+  def initialize(context = T.unsafe(nil)); end
+
+  def _pry_; end
+  def _pry_=(_arg0); end
+  def arg_string; end
+  def arg_string=(_arg0); end
+  def block; end
+  def captures; end
+  def captures=(_arg0); end
+  def check_for_command_collision(command_match, arg_string); end
+  def command_block; end
+  def command_block=(_arg0); end
+  def command_name; end
+  def command_options; end
+  def command_set; end
+  def command_set=(_arg0); end
+  def commands; end
+  def complete(_search); end
+  def context; end
+  def context=(_arg0); end
+  def description; end
+  def eval_string; end
+  def eval_string=(_arg0); end
+  def hooks; end
+  def hooks=(_arg0); end
+  def interpolate_string(str); end
+  def match; end
+  def name; end
+  def output; end
+  def output=(_arg0); end
+  def process_line(line); end
+  def pry_instance; end
+  def pry_instance=(_arg0); end
+  def run(command_string, *args); end
+  def source; end
+  def state; end
+  def target; end
+  def target=(_arg0); end
+  def target_self; end
+  def tokenize(val); end
+  def void; end
+
+  private
+
+  def after_hooks; end
+  def before_hooks; end
+  def call_safely(*args); end
+  def call_with_hooks(*args); end
+  def find_hooks(event); end
+  def normalize_method_args(method, args); end
+  def pass_block(arg_string); end
+  def use_unpatched_symbol; end
+
+  class << self
+    def banner(arg = T.unsafe(nil)); end
+    def block; end
+    def block=(_arg0); end
+    def command_name; end
+    def command_options(arg = T.unsafe(nil)); end
+    def command_options=(_arg0); end
+    def command_regex; end
+    def convert_to_regex(obj); end
+    def default_options(match); end
+    def description(arg = T.unsafe(nil)); end
+    def description=(_arg0); end
+    def doc; end
+    def file; end
+    def group(name = T.unsafe(nil)); end
+    def inspect; end
+    def line; end
+    def match(arg = T.unsafe(nil)); end
+    def match=(_arg0); end
+    def match_score(val); end
+    def matches?(val); end
+    def name; end
+    def options(arg = T.unsafe(nil)); end
+    def options=(_arg0); end
+    def source; end
+    def source_file; end
+    def source_line; end
+    def state; end
+    def subclass(match, description, options, helpers, &block); end
+  end
+end
+
+class Pry::Command::AmendLine < ::Pry::ClassCommand
+  def process; end
+
+  private
+
+  def amend_input; end
+  def delete_from_array(array, range); end
+  def insert_into_array(array, range); end
+  def line_count; end
+  def line_range; end
+  def replace_in_array(array, range); end
+  def start_and_end_line_number; end
+  def zero_indexed_range_from_one_indexed_numbers(start_line_number, end_line_number); end
+end
+
+class Pry::Command::Bang < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::BangPry < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::Cat < ::Pry::ClassCommand
+  def complete(search); end
+  def load_path_completions; end
+  def options(opt); end
+  def process; end
+end
+
+class Pry::Command::Cat::AbstractFormatter
+  include ::Pry::Helpers::OptionsHelpers
+  include ::Pry::Helpers::CommandHelpers
+  include ::Pry::Helpers::BaseHelpers
+
+  private
+
+  def between_lines; end
+  def code_type; end
+  def decorate(content); end
+  def use_line_numbers?; end
+end
+
+class Pry::Command::Cat::ExceptionFormatter < ::Pry::Command::Cat::AbstractFormatter
+  include ::Pry::Helpers::Text
+
+  def initialize(exception, pry_instance, opts); end
+
+  def ex; end
+  def format; end
+  def opts; end
+  def pry_instance; end
+
+  private
+
+  def backtrace_file; end
+  def backtrace_level; end
+  def backtrace_line; end
+  def check_for_errors; end
+  def code_window_size; end
+  def header; end
+  def increment_backtrace_level; end
+  def start_and_end_line_for_code_window; end
+end
+
+class Pry::Command::Cat::FileFormatter < ::Pry::Command::Cat::AbstractFormatter
+  def initialize(file_with_embedded_line, pry_instance, opts); end
+
+  def file_and_line; end
+  def file_with_embedded_line; end
+  def format; end
+  def opts; end
+  def pry_instance; end
+
+  private
+
+  def code_type; end
+  def code_window_size; end
+  def decorate(content); end
+  def detect_code_type_from_file(file_name); end
+  def file_name; end
+  def line_number; end
+end
+
+class Pry::Command::Cat::InputExpressionFormatter < ::Pry::Command::Cat::AbstractFormatter
+  def initialize(input_expressions, opts); end
+
+  def format; end
+  def input_expressions; end
+  def input_expressions=(_arg0); end
+  def opts; end
+  def opts=(_arg0); end
+
+  private
+
+  def normalized_expression_range; end
+  def numbered_input_items; end
+  def selected_input_items; end
+end
+
+class Pry::Command::Cd < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::ChangeInspector < ::Pry::ClassCommand
+  def process(inspector); end
+
+  private
+
+  def inspector_map; end
+end
+
+class Pry::Command::ChangePrompt < ::Pry::ClassCommand
+  def options(opt); end
+  def process(prompt); end
+
+  private
+
+  def change_prompt(prompt); end
+  def list_prompts; end
+end
+
+class Pry::Command::ClearScreen < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::CodeCollector
+  include ::Pry::Helpers::OptionsHelpers
+  include ::Pry::Helpers::CommandHelpers
+
+  def initialize(args, opts, pry_instance); end
+
+  def args; end
+  def code_object; end
+  def content; end
+  def file; end
+  def file=(_arg0); end
+  def line_range; end
+  def obj_name; end
+  def opts; end
+  def pry_input_content; end
+  def pry_instance; end
+  def pry_output_content; end
+  def restrict_to_lines(content, range); end
+
+  private
+
+  def bad_option_combination?; end
+  def code_object_doc; end
+  def code_object_source_or_file; end
+  def convert_to_range(range); end
+  def could_not_locate(name); end
+  def file_content; end
+  def pry_array_content_as_string(array, ranges); end
+
+  class << self
+    def inject_options(opt); end
+    def input_expression_ranges; end
+    def input_expression_ranges=(_arg0); end
+    def output_result_ranges; end
+    def output_result_ranges=(_arg0); end
+  end
+end
+
+class Pry::Command::DisablePry < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::Edit < ::Pry::ClassCommand
+  def apply_runtime_patch; end
+  def bad_option_combination?; end
+  def code_object; end
+  def ensure_file_name_is_valid(file_name); end
+  def file_and_line; end
+  def file_and_line_for_current_exception; end
+  def file_based_exception?; end
+  def file_edit; end
+  def filename_argument; end
+  def initial_temp_file_content; end
+  def input_expression; end
+  def never_reload?; end
+  def options(opt); end
+  def patch_exception?; end
+  def previously_patched?(code_object); end
+  def probably_a_file?(str); end
+  def process; end
+  def pry_method?(code_object); end
+  def reload?(file_name = T.unsafe(nil)); end
+  def reloadable?; end
+  def repl_edit; end
+  def repl_edit?; end
+  def runtime_patch?; end
+end
+
+class Pry::Command::Edit::ExceptionPatcher
+  def initialize(pry_instance, state, exception_file_and_line); end
+
+  def file_and_line; end
+  def file_and_line=(_arg0); end
+  def perform_patch; end
+  def pry_instance; end
+  def pry_instance=(_arg0); end
+  def state; end
+  def state=(_arg0); end
+end
+
+module Pry::Command::Edit::FileAndLineLocator
+  class << self
+    def from_binding(target); end
+    def from_code_object(code_object, filename_argument); end
+    def from_exception(exception, backtrace_level); end
+    def from_filename_argument(filename_argument); end
+  end
+end
+
+class Pry::Command::Exit < ::Pry::ClassCommand
+  def process; end
+  def process_pop_and_return; end
+end
+
+class Pry::Command::ExitAll < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::ExitProgram < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::FindMethod < ::Pry::ClassCommand
+  extend ::Pry::Helpers::BaseHelpers
+
+  def options(opt); end
+  def process; end
+
+  private
+
+  def additional_info(header, method); end
+  def content_search(namespace); end
+  def matched_method_lines(header, method); end
+  def name_search(namespace); end
+  def pattern; end
+  def print_matches(matches); end
+  def print_matches_for_class(klass, grouped); end
+  def recurse_namespace(klass, done = T.unsafe(nil), &block); end
+  def search_all_methods(namespace); end
+  def search_class; end
+  def show_search_results(matches); end
+end
+
+class Pry::Command::FixIndent < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::Help < ::Pry::ClassCommand
+  def command_groups; end
+  def display_command(command); end
+  def display_filtered_commands(search); end
+  def display_filtered_search_results(search); end
+  def display_index(groups); end
+  def display_search(search); end
+  def group_sort_key(group_name); end
+  def help_text_for_commands(name, commands); end
+  def normalize(key); end
+  def process; end
+  def search_hash(search, hash); end
+  def sorted_commands(commands); end
+  def sorted_group_names(groups); end
+  def visible_commands; end
+end
+
+class Pry::Command::Hist < ::Pry::ClassCommand
+  def options(opt); end
+  def process; end
+
+  private
+
+  def check_for_juxtaposed_replay(replay_sequence); end
+  def find_history; end
+  def process_clear; end
+  def process_display; end
+  def process_replay; end
+  def process_save; end
+end
+
+class Pry::Command::ImportSet < ::Pry::ClassCommand
+  def process(_command_set_name); end
+end
+
+class Pry::Command::JumpTo < ::Pry::ClassCommand
+  def process(break_level); end
+end
+
+class Pry::Command::ListInspectors < ::Pry::ClassCommand
+  def process; end
+
+  private
+
+  def inspector_map; end
+  def selected_inspector?(inspector); end
+  def selected_text; end
+end
+
+class Pry::Command::Ls < ::Pry::ClassCommand
+  def no_user_opts?; end
+  def options(opt); end
+  def process; end
+
+  private
+
+  def error_list; end
+  def raise_errors_if_arguments_are_weird; end
+end
+
+class Pry::Command::Ls::Constants < ::Pry::Command::Ls::Formatter
+  include ::Pry::Command::Ls::Interrogatable
+
+  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
+
+  def correct_opts?; end
+  def output_self; end
+
+  private
+
+  def format(mod, constants); end
+  def show_deprecated_constants?; end
+end
+
+Pry::Command::Ls::Constants::DEPRECATED_CONSTANTS = T.let(T.unsafe(nil), Array)
+Pry::Command::Ls::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+
+class Pry::Command::Ls::Formatter
+  def initialize(pry_instance); end
+
+  def grep=(_arg0); end
+  def pry_instance; end
+  def write_out; end
+
+  private
+
+  def color(type, str); end
+  def correct_opts?; end
+  def format_value(value); end
+  def grep; end
+  def output_section(heading, body); end
+  def output_self; end
+end
+
+class Pry::Command::Ls::Globals < ::Pry::Command::Ls::Formatter
+  def initialize(opts, pry_instance); end
+
+  def output_self; end
+
+  private
+
+  def format(globals); end
+end
+
+Pry::Command::Ls::Globals::BUILTIN_GLOBALS = T.let(T.unsafe(nil), Array)
+Pry::Command::Ls::Globals::PSEUDO_GLOBALS = T.let(T.unsafe(nil), Array)
+
+class Pry::Command::Ls::Grep
+  def initialize(grep_regexp); end
+
+  def regexp; end
+end
+
+class Pry::Command::Ls::InstanceVars < ::Pry::Command::Ls::Formatter
+  include ::Pry::Command::Ls::Interrogatable
+
+  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
+
+  def correct_opts?; end
+  def output_self; end
+
+  private
+
+  def format(type, vars); end
+end
+
+module Pry::Command::Ls::Interrogatable
+  private
+
+  def interrogatee_mod; end
+  def interrogating_a_module?; end
+end
+
+module Pry::Command::Ls::JRubyHacks
+  private
+
+  def rubbishness(name); end
+  def trim_jruby_aliases(methods); end
+end
+
+class Pry::Command::Ls::LocalNames < ::Pry::Command::Ls::Formatter
+  def initialize(no_user_opts, args, pry_instance); end
+
+  def correct_opts?; end
+  def output_self; end
+
+  private
+
+  def format(locals); end
+end
+
+class Pry::Command::Ls::LocalVars < ::Pry::Command::Ls::Formatter
+  def initialize(opts, pry_instance); end
+
+  def output_self; end
+
+  private
+
+  def colorized_assignment_style(lhs, rhs, desired_width = T.unsafe(nil)); end
+  def format(name_value_pairs); end
+end
+
+class Pry::Command::Ls::LsEntity
+  def initialize(opts); end
+
+  def entities_table; end
+  def pry_instance; end
+
+  private
+
+  def constants; end
+  def entities; end
+  def globals; end
+  def grep(entity); end
+  def instance_vars; end
+  def local_names; end
+  def local_vars; end
+  def methods; end
+  def self_methods; end
+end
+
+class Pry::Command::Ls::Methods < ::Pry::Command::Ls::Formatter
+  include ::Pry::Command::Ls::Interrogatable
+  include ::Pry::Command::Ls::JRubyHacks
+  include ::Pry::Command::Ls::MethodsHelper
+
+  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
+
+  def output_self; end
+
+  private
+
+  def below_ceiling; end
+  def correct_opts?; end
+end
+
+module Pry::Command::Ls::MethodsHelper
+  include ::Pry::Command::Ls::JRubyHacks
+
+  private
+
+  def all_methods(instance_methods = T.unsafe(nil)); end
+  def format(methods); end
+  def resolution_order; end
+end
+
+class Pry::Command::Ls::SelfMethods < ::Pry::Command::Ls::Formatter
+  include ::Pry::Command::Ls::Interrogatable
+  include ::Pry::Command::Ls::JRubyHacks
+  include ::Pry::Command::Ls::MethodsHelper
+
+  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
+
+  def output_self; end
+
+  private
+
+  def correct_opts?; end
+end
+
+class Pry::Command::Nesting < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::Play < ::Pry::ClassCommand
+  def code_object; end
+  def content; end
+  def content_after_options; end
+  def content_at_expression; end
+  def default_file; end
+  def file_content; end
+  def options(opt); end
+  def perform_play; end
+  def process; end
+  def should_use_default_file?; end
+  def show_input; end
+end
+
+class Pry::Command::PryBacktrace < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::RaiseUp < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::ReloadCode < ::Pry::ClassCommand
+  def process; end
+
+  private
+
+  def check_for_reloadability(code_object, identifier); end
+  def current_file; end
+  def reload_current_file; end
+  def reload_object(identifier); end
+end
+
+class Pry::Command::Reset < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::Ri < ::Pry::ClassCommand
+  def process(spec); end
+end
+
+class Pry::Command::SaveFile < ::Pry::ClassCommand
+  def display_content; end
+  def file_name; end
+  def mode; end
+  def options(opt); end
+  def process; end
+  def save_file; end
+end
+
+class Pry::Command::ShellCommand < ::Pry::ClassCommand
+  def process(cmd); end
+
+  private
+
+  def cd_path_env; end
+  def cd_path_exists?; end
+  def parse_destination(dest); end
+  def path_from_cd_path(dest); end
+  def process_cd(dest); end
+  def special_case_path?(dest); end
+end
+
+class Pry::Command::ShellMode < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::ShowDoc < ::Pry::Command::ShowInfo
+  include ::Pry::Helpers::DocumentationHelpers
+
+  def content_for(code_object); end
+  def docs_for(code_object); end
+  def header_options; end
+  def process; end
+  def render_doc_markup_for(code_object); end
+  def start_line_for(code_object); end
+end
+
+class Pry::Command::ShowInfo < ::Pry::ClassCommand
+  extend ::Pry::Helpers::BaseHelpers
+
+  def initialize(*_arg0); end
+
+  def code_object_header(code_object, line_num); end
+  def code_object_with_accessible_source(code_object); end
+  def complete(input); end
+  def content_and_header_for_code_object(code_object); end
+  def content_and_headers_for_all_module_candidates(mod); end
+  def file_and_line_for(code_object); end
+  def header(code_object); end
+  def header_options; end
+  def method_header(code_object, line_num); end
+  def method_sections(code_object); end
+  def module_header(code_object, line_num); end
+  def no_definition_message; end
+  def obj_name; end
+  def options(opt); end
+  def process; end
+  def show_all_modules?(code_object); end
+  def start_line_for(code_object); end
+  def use_line_numbers?; end
+  def valid_superclass?(code_object); end
+end
+
+class Pry::Command::ShowInput < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::ShowSource < ::Pry::Command::ShowInfo
+  include ::Pry::Helpers::DocumentationHelpers
+
+  def content_for(code_object); end
+  def docs_for(code_object); end
+  def header_options; end
+  def options(opt); end
+  def process; end
+  def render_doc_markup_for(code_object); end
+  def start_line_for(code_object); end
+end
+
+class Pry::Command::Stat < ::Pry::ClassCommand
+  def options(opt); end
+  def process; end
+end
+
+class Pry::Command::SwitchTo < ::Pry::ClassCommand
+  def process(selection); end
+end
+
+class Pry::Command::ToggleColor < ::Pry::ClassCommand
+  def color_toggle; end
+  def process; end
+end
+
+Pry::Command::VOID_VALUE = T.let(T.unsafe(nil), Object)
+
+class Pry::Command::Version < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::WatchExpression < ::Pry::ClassCommand
+  def options(opt); end
+  def process; end
+
+  private
+
+  def add_expression(_arguments); end
+  def add_hook; end
+  def delete(index); end
+  def eval_and_print_changed(output); end
+  def expressions; end
+  def list; end
+end
+
+class Pry::Command::WatchExpression::Expression
+  def initialize(pry_instance, target, source); end
+
+  def changed?; end
+  def eval!; end
+  def previous_value; end
+  def pry_instance; end
+  def source; end
+  def target; end
+  def to_s; end
+  def value; end
+
+  private
+
+  def target_eval(target, source); end
+end
+
+class Pry::Command::Whereami < ::Pry::ClassCommand
+  def initialize(*_arg0); end
+
+  def bad_option_combination?; end
+  def code; end
+  def code?; end
+  def location; end
+  def options(opt); end
+  def process; end
+  def setup; end
+
+  private
+
+  def class_code; end
+  def code_window; end
+  def default_code; end
+  def expand_path(filename); end
+  def handle_internal_binding; end
+  def marker; end
+  def method_code; end
+  def nothing_to_do?; end
+  def small_method?; end
+  def target_class; end
+  def top_level?; end
+  def use_line_numbers?; end
+  def valid_method?; end
+  def window_size; end
+
+  class << self
+    def method_size_cutoff; end
+    def method_size_cutoff=(_arg0); end
+  end
+end
+
+class Pry::Command::Wtf < ::Pry::ClassCommand
+  def options(opt); end
+  def process; end
+
+  private
+
+  def format_backtrace(backtrace); end
+  def format_header(title, exception); end
+  def read_line(file, line); end
+  def trim_backtrace(backtrace); end
+  def unwind_exceptions; end
+end
+
+Pry::Command::Wtf::RUBY_FRAME_PATTERN = T.let(T.unsafe(nil), Regexp)
+class Pry::CommandError < ::StandardError; end
+
+class Pry::CommandSet
+  include ::Enumerable
+  include ::Pry::Helpers::BaseHelpers
+
+  def initialize(*imported_sets, &block); end
+
+  def [](pattern); end
+  def []=(pattern, command); end
+  def add_command(command); end
+  def alias_command(match, action, options = T.unsafe(nil)); end
+  def block_command(match, description = T.unsafe(nil), options = T.unsafe(nil), &block); end
+  def command(match, description = T.unsafe(nil), options = T.unsafe(nil), &block); end
+  def complete(search, context = T.unsafe(nil)); end
+  def create_command(match, description = T.unsafe(nil), options = T.unsafe(nil), &block); end
+  def delete(*searches); end
+  def desc(search, description = T.unsafe(nil)); end
+  def each(&block); end
+  def find_command(pattern); end
+  def find_command_by_match_or_listing(match_or_listing); end
+  def find_command_for_help(search); end
+  def helper_module; end
+  def import(*sets); end
+  def import_from(set, *matches); end
+  def keys; end
+  def list_commands; end
+  def process_line(val, context = T.unsafe(nil)); end
+  def rename_command(new_match, search, options = T.unsafe(nil)); end
+  def to_h; end
+  def to_hash; end
+  def valid_command?(val); end
+
+  private
+
+  def helpers(&block); end
+end
+
+class Pry::CommandState
+  def initialize; end
+
+  def reset(command_name); end
+  def state_for(command_name); end
+
+  class << self
+    def default; end
+  end
+end
+
+Pry::Commands = T.let(T.unsafe(nil), Pry::CommandSet)
+
+class Pry::Config
+  extend ::Pry::Config::Attributable
+
+  def initialize; end
+
+  def [](attr); end
+  def []=(attr, value); end
+  def auto_indent; end
+  def auto_indent=(_arg0); end
+  def collision_warning; end
+  def collision_warning=(_arg0); end
+  def color; end
+  def color=(_arg0); end
+  def command_completions; end
+  def command_completions=(_arg0); end
+  def command_prefix; end
+  def command_prefix=(_arg0); end
+  def commands; end
+  def commands=(_arg0); end
+  def completer; end
+  def completer=(_arg0); end
+  def control_d_handler; end
+  def control_d_handler=(value); end
+  def correct_indent; end
+  def correct_indent=(_arg0); end
+  def default_window_size; end
+  def default_window_size=(_arg0); end
+  def disable_auto_reload; end
+  def disable_auto_reload=(_arg0); end
+  def editor; end
+  def editor=(_arg0); end
+  def exception_handler; end
+  def exception_handler=(_arg0); end
+  def exception_whitelist; end
+  def exception_whitelist=(_arg0); end
+  def exec_string; end
+  def exec_string=(_arg0); end
+  def extra_sticky_locals; end
+  def extra_sticky_locals=(_arg0); end
+  def file_completions; end
+  def file_completions=(_arg0); end
+  def history; end
+  def history=(_arg0); end
+  def history_file; end
+  def history_file=(_arg0); end
+  def history_ignorelist; end
+  def history_ignorelist=(_arg0); end
+  def history_load; end
+  def history_load=(_arg0); end
+  def history_save; end
+  def history_save=(_arg0); end
+  def hooks; end
+  def hooks=(_arg0); end
+  def input; end
+  def input=(_arg0); end
+  def ls; end
+  def ls=(_arg0); end
+  def memory_size; end
+  def memory_size=(_arg0); end
+  def merge(config_hash); end
+  def merge!(config_hash); end
+  def method_missing(method_name, *args, &_block); end
+  def output; end
+  def output=(_arg0); end
+  def output_prefix; end
+  def output_prefix=(_arg0); end
+  def pager; end
+  def pager=(_arg0); end
+  def print; end
+  def print=(_arg0); end
+  def prompt; end
+  def prompt=(_arg0); end
+  def prompt_name; end
+  def prompt_name=(_arg0); end
+  def prompt_safe_contexts; end
+  def prompt_safe_contexts=(_arg0); end
+  def quiet; end
+  def quiet=(_arg0); end
+  def rc_file; end
+  def rc_file=(_arg0); end
+  def requires; end
+  def requires=(_arg0); end
+  def should_load_local_rc; end
+  def should_load_local_rc=(_arg0); end
+  def should_load_rc; end
+  def should_load_rc=(_arg0); end
+  def should_load_requires; end
+  def should_load_requires=(_arg0); end
+  def should_trap_interrupts; end
+  def should_trap_interrupts=(_arg0); end
+  def system; end
+  def system=(_arg0); end
+  def unrescued_exceptions; end
+  def unrescued_exceptions=(_arg0); end
+  def windows_console_warning; end
+  def windows_console_warning=(_arg0); end
+
+  private
+
+  def default_rc_file; end
+  def initialize_dup(other); end
+  def lazy_readline; end
+  def respond_to_missing?(method_name, include_all = T.unsafe(nil)); end
+end
+
+module Pry::Config::Attributable
+  def attribute(attr_name); end
+end
+
+class Pry::Config::LazyValue
+  def initialize(&block); end
+
+  def call; end
+end
+
+class Pry::Config::MemoizedValue
+  def initialize(&block); end
+
+  def call; end
+end
+
+class Pry::Config::Value
+  def initialize(value); end
+
+  def call; end
+end
+
+module Pry::ControlDHandler
+  class << self
+    def default(pry_instance); end
+  end
+end
+
+Pry::EMPTY_COMPLETIONS = T.let(T.unsafe(nil), Array)
+
+class Pry::Editor
+  include ::Pry::Helpers::OptionsHelpers
+  include ::Pry::Helpers::CommandHelpers
+
+  def initialize(pry_instance); end
+
+  def build_editor_invocation_string(file, line, blocking); end
+  def edit_tempfile_with_content(initial_content, line = T.unsafe(nil)); end
+  def invoke_editor(file, line, blocking = T.unsafe(nil)); end
+  def pry_instance; end
+
+  private
+
+  def blocking_flag_for_editor(blocking); end
+  def editor_name; end
+  def open_editor(editor_invocation); end
+  def open_editor_on_jruby(editor_invocation); end
+  def start_line_syntax_for_editor(file_name, line_number); end
+
+  class << self
+    def default; end
+  end
+end
+
+module Pry::Env
+  class << self
+    def [](key); end
+  end
+end
+
+module Pry::ExceptionHandler
+  class << self
+    def handle_exception(output, exception, _pry_instance); end
+
+    private
+
+    def cause_text(cause); end
+    def exception_text(exception); end
+    def standard_error_text_for(exception); end
+  end
+end
+
+module Pry::Forwardable
+  include ::Forwardable
+
+  def def_private_delegators(target, *private_delegates); end
+end
+
+module Pry::FrozenObjectException
+  class << self
+    def ===(exception); end
+  end
+end
+
+Pry::HAS_SAFE_LEVEL = T.let(T.unsafe(nil), TrueClass)
+
+module Pry::Helpers
+  class << self
+    def tablify(things, line_length, pry_instance = T.unsafe(nil)); end
+    def tablify_or_one_line(heading, things, pry_instance = T.unsafe(nil)); end
+    def tablify_to_screen_width(things, options, pry_instance = T.unsafe(nil)); end
+  end
+end
+
+module Pry::Helpers::BaseHelpers
+  extend ::Pry::Helpers::BaseHelpers
+
+  def colorize_code(code); end
+  def find_command(name, set = T.unsafe(nil)); end
+  def heading(text); end
+  def highlight(string, regexp, highlight_color = T.unsafe(nil)); end
+  def not_a_real_file?(file); end
+  def safe_send(obj, method, *args, &block); end
+  def silence_warnings; end
+  def stagger_output(text, _out = T.unsafe(nil)); end
+  def use_ansi_codes?; end
+end
+
+module Pry::Helpers::CommandHelpers
+  include ::Pry::Helpers::OptionsHelpers
+  extend ::Pry::Helpers::OptionsHelpers
+  extend ::Pry::Helpers::CommandHelpers
+
+  def absolute_index_number(line_number, array_length); end
+  def absolute_index_range(range_or_number, array_length); end
+  def get_method_or_raise(method_name, context, opts = T.unsafe(nil)); end
+  def internal_binding?(context); end
+  def one_index_number(line_number); end
+  def one_index_range(range); end
+  def one_index_range_or_number(range_or_number); end
+  def restrict_to_lines(content, lines); end
+  def set_file_and_dir_locals(file_name, pry = T.unsafe(nil), ctx = T.unsafe(nil)); end
+  def temp_file(ext = T.unsafe(nil)); end
+  def unindent(dirty_text, left_padding = T.unsafe(nil)); end
+end
+
+module Pry::Helpers::DocumentationHelpers
+  private
+
+  def get_comment_content(comment); end
+  def process_comment_markup(comment); end
+  def process_rdoc(comment); end
+  def process_yardoc(comment); end
+  def process_yardoc_tag(comment, tag); end
+  def strip_comments_from_c_code(code); end
+  def strip_leading_whitespace(text); end
+
+  class << self
+    def get_comment_content(comment); end
+    def process_comment_markup(comment); end
+    def process_rdoc(comment); end
+    def process_yardoc(comment); end
+    def process_yardoc_tag(comment, tag); end
+    def strip_comments_from_c_code(code); end
+    def strip_leading_whitespace(text); end
+  end
+end
+
+Pry::Helpers::DocumentationHelpers::YARD_TAGS = T.let(T.unsafe(nil), Array)
+
+module Pry::Helpers::OptionsHelpers
+  private
+
+  def method_object; end
+  def method_options(opt); end
+
+  class << self
+    def method_object; end
+    def method_options(opt); end
+  end
+end
+
+module Pry::Helpers::Platform
+  class << self
+    def jruby?; end
+    def jruby_19?; end
+    def linux?; end
+    def mac_osx?; end
+    def mri?; end
+    def mri_19?; end
+    def mri_2?; end
+    def windows?; end
+    def windows_ansi?; end
+  end
+end
+
+class Pry::Helpers::Table
+  def initialize(items, args, pry_instance = T.unsafe(nil)); end
+
+  def ==(other); end
+  def column_count; end
+  def column_count=(count); end
+  def columns; end
+  def fits_on_line?(line_length); end
+  def items; end
+  def items=(items); end
+  def rows_to_s(style = T.unsafe(nil)); end
+  def to_a; end
+  def to_s; end
+
+  private
+
+  def _max_width(things); end
+  def _rebuild_colorless_cache; end
+  def _recall_color_for(thing); end
+  def _recolumn; end
+end
+
+module Pry::Helpers::Text
+  extend ::Pry::Helpers::Text
+
+  def black(text); end
+  def black_on_black(text); end
+  def black_on_blue(text); end
+  def black_on_cyan(text); end
+  def black_on_green(text); end
+  def black_on_magenta(text); end
+  def black_on_purple(text); end
+  def black_on_red(text); end
+  def black_on_white(text); end
+  def black_on_yellow(text); end
+  def blue(text); end
+  def blue_on_black(text); end
+  def blue_on_blue(text); end
+  def blue_on_cyan(text); end
+  def blue_on_green(text); end
+  def blue_on_magenta(text); end
+  def blue_on_purple(text); end
+  def blue_on_red(text); end
+  def blue_on_white(text); end
+  def blue_on_yellow(text); end
+  def bold(text); end
+  def bright_black(text); end
+  def bright_black_on_black(text); end
+  def bright_black_on_blue(text); end
+  def bright_black_on_cyan(text); end
+  def bright_black_on_green(text); end
+  def bright_black_on_magenta(text); end
+  def bright_black_on_purple(text); end
+  def bright_black_on_red(text); end
+  def bright_black_on_white(text); end
+  def bright_black_on_yellow(text); end
+  def bright_blue(text); end
+  def bright_blue_on_black(text); end
+  def bright_blue_on_blue(text); end
+  def bright_blue_on_cyan(text); end
+  def bright_blue_on_green(text); end
+  def bright_blue_on_magenta(text); end
+  def bright_blue_on_purple(text); end
+  def bright_blue_on_red(text); end
+  def bright_blue_on_white(text); end
+  def bright_blue_on_yellow(text); end
+  def bright_cyan(text); end
+  def bright_cyan_on_black(text); end
+  def bright_cyan_on_blue(text); end
+  def bright_cyan_on_cyan(text); end
+  def bright_cyan_on_green(text); end
+  def bright_cyan_on_magenta(text); end
+  def bright_cyan_on_purple(text); end
+  def bright_cyan_on_red(text); end
+  def bright_cyan_on_white(text); end
+  def bright_cyan_on_yellow(text); end
+  def bright_green(text); end
+  def bright_green_on_black(text); end
+  def bright_green_on_blue(text); end
+  def bright_green_on_cyan(text); end
+  def bright_green_on_green(text); end
+  def bright_green_on_magenta(text); end
+  def bright_green_on_purple(text); end
+  def bright_green_on_red(text); end
+  def bright_green_on_white(text); end
+  def bright_green_on_yellow(text); end
+  def bright_magenta(text); end
+  def bright_magenta_on_black(text); end
+  def bright_magenta_on_blue(text); end
+  def bright_magenta_on_cyan(text); end
+  def bright_magenta_on_green(text); end
+  def bright_magenta_on_magenta(text); end
+  def bright_magenta_on_purple(text); end
+  def bright_magenta_on_red(text); end
+  def bright_magenta_on_white(text); end
+  def bright_magenta_on_yellow(text); end
+  def bright_purple(text); end
+  def bright_purple_on_black(text); end
+  def bright_purple_on_blue(text); end
+  def bright_purple_on_cyan(text); end
+  def bright_purple_on_green(text); end
+  def bright_purple_on_magenta(text); end
+  def bright_purple_on_purple(text); end
+  def bright_purple_on_red(text); end
+  def bright_purple_on_white(text); end
+  def bright_purple_on_yellow(text); end
+  def bright_red(text); end
+  def bright_red_on_black(text); end
+  def bright_red_on_blue(text); end
+  def bright_red_on_cyan(text); end
+  def bright_red_on_green(text); end
+  def bright_red_on_magenta(text); end
+  def bright_red_on_purple(text); end
+  def bright_red_on_red(text); end
+  def bright_red_on_white(text); end
+  def bright_red_on_yellow(text); end
+  def bright_white(text); end
+  def bright_white_on_black(text); end
+  def bright_white_on_blue(text); end
+  def bright_white_on_cyan(text); end
+  def bright_white_on_green(text); end
+  def bright_white_on_magenta(text); end
+  def bright_white_on_purple(text); end
+  def bright_white_on_red(text); end
+  def bright_white_on_white(text); end
+  def bright_white_on_yellow(text); end
+  def bright_yellow(text); end
+  def bright_yellow_on_black(text); end
+  def bright_yellow_on_blue(text); end
+  def bright_yellow_on_cyan(text); end
+  def bright_yellow_on_green(text); end
+  def bright_yellow_on_magenta(text); end
+  def bright_yellow_on_purple(text); end
+  def bright_yellow_on_red(text); end
+  def bright_yellow_on_white(text); end
+  def bright_yellow_on_yellow(text); end
+  def cyan(text); end
+  def cyan_on_black(text); end
+  def cyan_on_blue(text); end
+  def cyan_on_cyan(text); end
+  def cyan_on_green(text); end
+  def cyan_on_magenta(text); end
+  def cyan_on_purple(text); end
+  def cyan_on_red(text); end
+  def cyan_on_white(text); end
+  def cyan_on_yellow(text); end
+  def default(text); end
+  def green(text); end
+  def green_on_black(text); end
+  def green_on_blue(text); end
+  def green_on_cyan(text); end
+  def green_on_green(text); end
+  def green_on_magenta(text); end
+  def green_on_purple(text); end
+  def green_on_red(text); end
+  def green_on_white(text); end
+  def green_on_yellow(text); end
+  def indent(text, chars); end
+  def magenta(text); end
+  def magenta_on_black(text); end
+  def magenta_on_blue(text); end
+  def magenta_on_cyan(text); end
+  def magenta_on_green(text); end
+  def magenta_on_magenta(text); end
+  def magenta_on_purple(text); end
+  def magenta_on_red(text); end
+  def magenta_on_white(text); end
+  def magenta_on_yellow(text); end
+  def no_color; end
+  def no_pager; end
+  def purple(text); end
+  def purple_on_black(text); end
+  def purple_on_blue(text); end
+  def purple_on_cyan(text); end
+  def purple_on_green(text); end
+  def purple_on_magenta(text); end
+  def purple_on_purple(text); end
+  def purple_on_red(text); end
+  def purple_on_white(text); end
+  def purple_on_yellow(text); end
+  def red(text); end
+  def red_on_black(text); end
+  def red_on_blue(text); end
+  def red_on_cyan(text); end
+  def red_on_green(text); end
+  def red_on_magenta(text); end
+  def red_on_purple(text); end
+  def red_on_red(text); end
+  def red_on_white(text); end
+  def red_on_yellow(text); end
+  def strip_color(text); end
+  def white(text); end
+  def white_on_black(text); end
+  def white_on_blue(text); end
+  def white_on_cyan(text); end
+  def white_on_green(text); end
+  def white_on_magenta(text); end
+  def white_on_purple(text); end
+  def white_on_red(text); end
+  def white_on_white(text); end
+  def white_on_yellow(text); end
+  def with_line_numbers(text, offset, color = T.unsafe(nil)); end
+  def yellow(text); end
+  def yellow_on_black(text); end
+  def yellow_on_blue(text); end
+  def yellow_on_cyan(text); end
+  def yellow_on_green(text); end
+  def yellow_on_magenta(text); end
+  def yellow_on_purple(text); end
+  def yellow_on_red(text); end
+  def yellow_on_white(text); end
+  def yellow_on_yellow(text); end
+end
+
+Pry::Helpers::Text::COLORS = T.let(T.unsafe(nil), Hash)
+
+class Pry::History
+  def initialize(options = T.unsafe(nil)); end
+
+  def <<(line); end
+  def clear; end
+  def filter(history); end
+  def history_line_count; end
+  def load; end
+  def loader; end
+  def loader=(_arg0); end
+  def original_lines; end
+  def push(line); end
+  def saver; end
+  def saver=(_arg0); end
+  def session_line_count; end
+  def to_a; end
+
+  private
+
+  def history_file; end
+  def history_file_path; end
+  def invalid_readline_line?(line); end
+  def read_from_file; end
+  def save_to_file(line); end
+  def should_ignore?(line); end
+
+  class << self
+    def default_file; end
+  end
+end
+
+class Pry::Hooks
+  def initialize; end
+
+  def add_hook(event_name, hook_name, callable = T.unsafe(nil), &block); end
+  def clear_event_hooks(event_name); end
+  def delete_hook(event_name, hook_name); end
+  def errors; end
+  def exec_hook(event_name, *args, &block); end
+  def get_hook(event_name, hook_name); end
+  def get_hooks(event_name); end
+  def hook_count(event_name); end
+  def hook_exists?(event_name, hook_name); end
+  def merge(other); end
+  def merge!(other); end
+
+  protected
+
+  def hooks; end
+
+  private
+
+  def initialize_copy(_orig); end
+
+  class << self
+    def default; end
+  end
+end
+
+class Pry::Indent
+  include ::Pry::Helpers::BaseHelpers
+
+  def initialize(pry_instance = T.unsafe(nil)); end
+
+  def correct_indentation(prompt, code, overhang = T.unsafe(nil)); end
+  def current_prefix; end
+  def end_of_statement?(last_token, last_kind); end
+  def in_string?; end
+  def indent(input); end
+  def indent_level; end
+  def indentation_delta(tokens); end
+  def module_nesting; end
+  def open_delimiters; end
+  def open_delimiters_line; end
+  def reset; end
+  def stack; end
+  def tokenize(string); end
+  def track_delimiter(token); end
+  def track_module_nesting(token, kind); end
+  def track_module_nesting_end(token, kind = T.unsafe(nil)); end
+
+  class << self
+    def indent(str); end
+    def nesting_at(str, line_number); end
+  end
+end
+
+Pry::Indent::IGNORE_TOKENS = T.let(T.unsafe(nil), Array)
+Pry::Indent::MIDWAY_TOKENS = T.let(T.unsafe(nil), Array)
+Pry::Indent::OPEN_TOKENS = T.let(T.unsafe(nil), Hash)
+Pry::Indent::OPTIONAL_DO_TOKENS = T.let(T.unsafe(nil), Array)
+Pry::Indent::SINGLELINE_TOKENS = T.let(T.unsafe(nil), Array)
+Pry::Indent::SPACES = T.let(T.unsafe(nil), String)
+Pry::Indent::STATEMENT_END_TOKENS = T.let(T.unsafe(nil), Array)
+class Pry::Indent::UnparseableNestingError < ::StandardError; end
+
+class Pry::InputCompleter
+  def initialize(input, pry = T.unsafe(nil)); end
+
+  def build_path(input); end
+  def call(str, options = T.unsafe(nil)); end
+  def ignored_modules; end
+  def select_message(path, receiver, message, candidates); end
+end
+
+Pry::InputCompleter::ARRAY_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::CONSTANT_OR_METHOD_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::CONSTANT_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::GLOBALVARIABLE_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::HEX_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::NUMERIC_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::PROC_OR_HASH_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::REGEX_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::RESERVED_WORDS = T.let(T.unsafe(nil), Array)
+Pry::InputCompleter::SYMBOL_METHOD_CALL_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::SYMBOL_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::TOPLEVEL_LOOKUP_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::VARIABLE_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::WORD_ESCAPE_STR = T.let(T.unsafe(nil), String)
+
+class Pry::InputLock
+  def initialize; end
+
+  def __with_ownership; end
+  def enter_interruptible_region; end
+  def interruptible_region; end
+  def leave_interruptible_region; end
+  def with_ownership(&block); end
+
+  class << self
+    def for(input); end
+    def global_lock; end
+    def global_lock=(_arg0); end
+    def input_locks; end
+    def input_locks=(_arg0); end
+  end
+end
+
+class Pry::InputLock::Interrupt < ::Exception; end
+class Pry::Inspector; end
+Pry::Inspector::MAP = T.let(T.unsafe(nil), Hash)
+Pry::LOCAL_RC_FILE = T.let(T.unsafe(nil), String)
+
+class Pry::LastException < ::BasicObject
+  def initialize(exception); end
+
+  def bt_index; end
+  def bt_index=(_arg0); end
+  def bt_source_location_for(index); end
+  def file; end
+  def inc_bt_index; end
+  def line; end
+  def method_missing(name, *args, &block); end
+  def wrapped_exception; end
+
+  private
+
+  def respond_to_missing?(name, include_all = T.unsafe(nil)); end
+end
+
+class Pry::Method
+  include ::Pry::Helpers::BaseHelpers
+  include ::Pry::Helpers::DocumentationHelpers
+  include ::Pry::CodeObject::Helpers
+  extend ::Pry::Helpers::BaseHelpers
+  extend ::Forwardable
+  extend ::Pry::Forwardable
+
+  def initialize(method, known_info = T.unsafe(nil)); end
+
+  def ==(other); end
+  def alias?; end
+  def aliases; end
+  def bound_method?; end
+  def comment; end
+  def doc; end
+  def dynamically_defined?; end
+  def is_a?(klass); end
+  def kind_of?(klass); end
+  def method_missing(method_name, *args, &block); end
+  def name; end
+  def name_with_owner; end
+  def original_name; end
+  def owner(*args, &block); end
+  def parameters(*args, &block); end
+  def pry_method?; end
+  def receiver(*args, &block); end
+  def redefine(source); end
+  def respond_to?(method_name, include_all = T.unsafe(nil)); end
+  def signature; end
+  def singleton_method?; end
+  def source; end
+  def source?; end
+  def source_file; end
+  def source_line; end
+  def source_range; end
+  def source_type; end
+  def super(times = T.unsafe(nil)); end
+  def unbound_method?; end
+  def undefined?; end
+  def visibility; end
+  def wrapped; end
+  def wrapped_owner; end
+
+  private
+
+  def c_source; end
+  def method_name_from_first_line(first_ln); end
+  def pry_doc_info; end
+  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
+  def ruby_source; end
+  def super_using_ancestors(ancestors, times = T.unsafe(nil)); end
+
+  class << self
+    def all_from_class(klass, include_super = T.unsafe(nil)); end
+    def all_from_obj(obj, include_super = T.unsafe(nil)); end
+    def from_binding(binding); end
+    def from_class(klass, name, target = T.unsafe(nil)); end
+    def from_module(klass, name, target = T.unsafe(nil)); end
+    def from_obj(obj, name, target = T.unsafe(nil)); end
+    def from_str(name, target = T.unsafe(nil), options = T.unsafe(nil)); end
+    def instance_method_definition?(name, definition_line); end
+    def instance_resolution_order(klass); end
+    def lookup_method_via_binding(obj, method_name, method_type, target = T.unsafe(nil)); end
+    def method_definition?(name, definition_line); end
+    def resolution_order(obj); end
+    def singleton_class_of(obj); end
+    def singleton_class_resolution_order(klass); end
+    def singleton_method_definition?(name, definition_line); end
+  end
+end
+
+class Pry::Method::Disowned < ::Pry::Method
+  def initialize(receiver, method_name); end
+
+  def method_missing(method_name, *args, &block); end
+  def name; end
+  def owner; end
+  def receiver; end
+  def source?; end
+  def undefined?; end
+
+  private
+
+  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
+end
+
+class Pry::Method::Patcher
+  def initialize(method); end
+
+  def method; end
+  def method=(_arg0); end
+  def patch_in_ram(source); end
+
+  private
+
+  def cache_key; end
+  def definition_for_owner(line); end
+  def redefine(source); end
+  def with_method_transaction; end
+  def wrap(source); end
+  def wrap_for_nesting(source); end
+  def wrap_for_owner(source); end
+
+  class << self
+    def code_for(filename); end
+  end
+end
+
+class Pry::Method::WeirdMethodLocator
+  def initialize(method, target); end
+
+  def find_method; end
+  def lost_method?; end
+  def method; end
+  def method=(_arg0); end
+  def target; end
+  def target=(_arg0); end
+
+  private
+
+  def all_methods_for(obj); end
+  def expanded_source_location(source_location); end
+  def find_method_in_superclass; end
+  def find_renamed_method; end
+  def index_to_line_number(index); end
+  def lines_for_file(file); end
+  def normal_method?(method); end
+  def pry_file?; end
+  def renamed_method_source_location; end
+  def skip_superclass_search?; end
+  def target_file; end
+  def target_line; end
+  def target_self; end
+  def valid_file?(file); end
+
+  class << self
+    def normal_method?(method, binding); end
+    def weird_method?(method, binding); end
+  end
+end
+
+class Pry::MethodNotFound < ::Pry::CommandError; end
+
+class Pry::NoCommandError < ::StandardError
+  def initialize(match, owner); end
+end
+
+class Pry::ObjectPath
+  def initialize(path_string, current_stack); end
+
+  def resolve; end
+
+  private
+
+  def complete?(segment); end
+  def handle_failure(context, err); end
+end
+
+Pry::ObjectPath::SPECIAL_TERMS = T.let(T.unsafe(nil), Array)
+class Pry::ObsoleteError < ::StandardError; end
+
+class Pry::Output
+  def initialize(pry_instance); end
+
+  def <<(*objs); end
+  def decolorize_maybe(str); end
+  def height; end
+  def method_missing(method_name, *args, &block); end
+  def print(*objs); end
+  def pry_instance; end
+  def puts(*objs); end
+  def size; end
+  def tty?; end
+  def width; end
+  def write(*objs); end
+
+  private
+
+  def actual_screen_size; end
+  def ansicon_env_size; end
+  def env_size; end
+  def io_console_size; end
+  def nonzero_column?(size); end
+  def readline_size; end
+  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
+end
+
+Pry::Output::DEFAULT_SIZE = T.let(T.unsafe(nil), Array)
+
+class Pry::Pager
+  def initialize(pry_instance); end
+
+  def open; end
+  def page(text); end
+  def pry_instance; end
+
+  private
+
+  def best_available; end
+  def enabled?; end
+  def output; end
+end
+
+class Pry::Pager::NullPager
+  def initialize(out); end
+
+  def <<(str); end
+  def close; end
+  def print(str); end
+  def puts(str); end
+  def write(str); end
+
+  private
+
+  def height; end
+  def width; end
+end
+
+class Pry::Pager::PageTracker
+  def initialize(rows, cols); end
+
+  def page?; end
+  def record(str); end
+  def reset; end
+
+  private
+
+  def line_length(line); end
+end
+
+class Pry::Pager::SimplePager < ::Pry::Pager::NullPager
+  def initialize(*_arg0); end
+
+  def write(str); end
+end
+
+class Pry::Pager::StopPaging < ::StandardError; end
+
+class Pry::Pager::SystemPager < ::Pry::Pager::NullPager
+  def initialize(*_arg0); end
+
+  def close; end
+  def write(str); end
+
+  private
+
+  def invoked_pager?; end
+  def pager; end
+  def write_to_pager(text); end
+
+  class << self
+    def available?; end
+    def default_pager; end
+  end
+end
+
+class Pry::Prompt
+  def initialize(name, description, prompt_procs); end
+
+  def [](key); end
+  def description; end
+  def incomplete_proc; end
+  def name; end
+  def prompt_procs; end
+  def wait_proc; end
+
+  class << self
+    def [](name); end
+    def add(name, description = T.unsafe(nil), separators = T.unsafe(nil)); end
+    def all; end
+  end
+end
+
+class Pry::REPL
+  extend ::Forwardable
+  extend ::Pry::Forwardable
+
+  def initialize(pry, options = T.unsafe(nil)); end
+
+  def input(*args, &block); end
+  def output(*args, &block); end
+  def pry; end
+  def pry=(_arg0); end
+  def start; end
+
+  private
+
+  def calculate_overhang(current_prompt, original_val, indented_val); end
+  def coolline_available?; end
+  def epilogue; end
+  def handle_read_errors; end
+  def input_readline(*args); end
+  def piping?; end
+  def prologue; end
+  def read; end
+  def read_line(current_prompt); end
+  def readline_available?; end
+  def repl; end
+  def set_readline_output; end
+
+  class << self
+    def start(options); end
+  end
+end
+
+class Pry::REPLFileLoader
+  def initialize(file_name); end
+
+  def define_additional_commands; end
+  def interactive_mode(pry_instance); end
+  def load; end
+  def non_interactive_mode(pry_instance, content); end
+end
+
+module Pry::RescuableException
+  class << self
+    def ===(exception); end
+  end
+end
+
+class Pry::Result
+  def initialize(is_command, retval = T.unsafe(nil)); end
+
+  def command?; end
+  def retval; end
+  def void_command?; end
+end
+
+class Pry::Ring
+  def initialize(max_size); end
+
+  def <<(value); end
+  def [](index); end
+  def clear; end
+  def count; end
+  def max_size; end
+  def size; end
+  def to_a; end
+
+  private
+
+  def transpose_buffer_tail; end
+end
+
+class Pry::Slop
+  include ::Enumerable
+
+  def initialize(config = T.unsafe(nil), &block); end
+
+  def [](key); end
+  def add_callback(label, &block); end
+  def banner(banner = T.unsafe(nil)); end
+  def banner=(banner); end
+  def command(command, options = T.unsafe(nil), &block); end
+  def config; end
+  def description(desc = T.unsafe(nil)); end
+  def description=(desc); end
+  def each(&block); end
+  def fetch_command(command); end
+  def fetch_option(key); end
+  def get(key); end
+  def help; end
+  def missing; end
+  def on(*objects, &block); end
+  def opt(*objects, &block); end
+  def option(*objects, &block); end
+  def options; end
+  def parse(items = T.unsafe(nil), &block); end
+  def parse!(items = T.unsafe(nil), &block); end
+  def present?(*keys); end
+  def run(callable = T.unsafe(nil), &block); end
+  def separator(text); end
+  def strict?; end
+  def to_h(include_commands = T.unsafe(nil)); end
+  def to_hash(include_commands = T.unsafe(nil)); end
+  def to_s; end
+
+  private
+
+  def autocreate(items, index); end
+  def build_option(objects, &block); end
+  def clean(object); end
+  def commands_to_help; end
+  def execute_multiple_switches(option, argument, index); end
+  def execute_option(option, argument, index, item = T.unsafe(nil)); end
+  def extract_long_flag(objects, config); end
+  def extract_option(flag); end
+  def extract_short_flag(objects, config); end
+  def method_missing(method, *args, &block); end
+  def process_item(items, index, &block); end
+  def respond_to_missing?(method_name, include_all = T.unsafe(nil)); end
+
+  class << self
+    def optspec(string, config = T.unsafe(nil)); end
+    def parse(items = T.unsafe(nil), config = T.unsafe(nil), &block); end
+    def parse!(items = T.unsafe(nil), config = T.unsafe(nil), &block); end
+  end
+end
+
+class Pry::Slop::Commands
+  include ::Enumerable
+
+  def initialize(config = T.unsafe(nil), &block); end
+
+  def [](key); end
+  def arguments; end
+  def banner(banner = T.unsafe(nil)); end
+  def banner=(_arg0); end
+  def commands; end
+  def config; end
+  def default(config = T.unsafe(nil), &block); end
+  def each(&block); end
+  def get(key); end
+  def global(config = T.unsafe(nil), &block); end
+  def help; end
+  def inspect; end
+  def on(command, config = T.unsafe(nil), &block); end
+  def parse(items = T.unsafe(nil)); end
+  def parse!(items = T.unsafe(nil)); end
+  def present?(key); end
+  def to_hash; end
+  def to_s; end
+
+  private
+
+  def execute_arguments!(items); end
+  def execute_global_opts!(items); end
+end
+
+Pry::Slop::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+class Pry::Slop::Error < ::StandardError; end
+class Pry::Slop::InvalidArgumentError < ::Pry::Slop::Error; end
+class Pry::Slop::InvalidCommandError < ::Pry::Slop::Error; end
+class Pry::Slop::InvalidOptionError < ::Pry::Slop::Error; end
+class Pry::Slop::MissingArgumentError < ::Pry::Slop::Error; end
+class Pry::Slop::MissingOptionError < ::Pry::Slop::Error; end
+
+class Pry::Slop::Option
+  def initialize(slop, short, long, description, config = T.unsafe(nil), &block); end
+
+  def accepts_optional_argument?; end
+  def argument_in_value; end
+  def argument_in_value=(_arg0); end
+  def call(*objects); end
+  def config; end
+  def count; end
+  def count=(_arg0); end
+  def description; end
+  def expects_argument?; end
+  def help; end
+  def inspect; end
+  def key; end
+  def long; end
+  def short; end
+  def to_s; end
+  def types; end
+  def value; end
+  def value=(new_value); end
+
+  private
+
+  def value_to_float(value); end
+  def value_to_integer(value); end
+  def value_to_range(value); end
+end
+
+Pry::Slop::Option::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+Pry::Slop::VERSION = T.let(T.unsafe(nil), String)
+
+class Pry::SyntaxHighlighter
+  class << self
+    def highlight(code, language = T.unsafe(nil)); end
+    def keyword_token_color; end
+    def overwrite_coderay_comment_token!; end
+    def tokenize(code, language = T.unsafe(nil)); end
+  end
+end
+
+module Pry::SystemCommandHandler
+  class << self
+    def default(output, command, _pry_instance); end
+  end
+end
+
+module Pry::TooSafeException
+  class << self
+    def ===(exception); end
+  end
+end
+
+module Pry::UserError; end
+Pry::VERSION = T.let(T.unsafe(nil), String)
+
+module Pry::Warning
+  class << self
+    def warn(message); end
+  end
+end
+
+class Pry::WrappedModule
+  include ::Pry::Helpers::BaseHelpers
+  include ::Pry::CodeObject::Helpers
+
+  def initialize(mod); end
+
+  def candidate(rank); end
+  def candidates; end
+  def class?; end
+  def constants(inherit = T.unsafe(nil)); end
+  def doc; end
+  def file; end
+  def line; end
+  def method_missing(method_name, *args, &block); end
+  def method_prefix; end
+  def module?; end
+  def nonblank_name; end
+  def number_of_candidates; end
+  def singleton_class?; end
+  def singleton_instance; end
+  def source; end
+  def source_file; end
+  def source_line; end
+  def source_location; end
+  def super(times = T.unsafe(nil)); end
+  def wrapped; end
+  def yard_doc; end
+  def yard_docs?; end
+  def yard_file; end
+  def yard_line; end
+
+  private
+
+  def all_methods_for(mod); end
+  def all_relevant_methods_for(mod); end
+  def all_source_locations_by_popularity; end
+  def lines_for_file(file); end
+  def method_candidates; end
+  def method_defined_by_forwardable_module?(method); end
+  def nested_module?(parent, name); end
+  def primary_candidate; end
+  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
+
+  class << self
+    def from_str(mod_name, target = T.unsafe(nil)); end
+
+    private
+
+    def safe_to_evaluate?(str, target); end
+  end
+end
+
+class Pry::WrappedModule::Candidate
+  include ::Pry::Helpers::DocumentationHelpers
+  include ::Pry::CodeObject::Helpers
+  extend ::Forwardable
+  extend ::Pry::Forwardable
+
+  def initialize(wrapper, rank); end
+
+  def class?(*args, &block); end
+  def doc; end
+  def file; end
+  def line; end
+  def module?(*args, &block); end
+  def nonblank_name(*args, &block); end
+  def number_of_candidates(*args, &block); end
+  def source; end
+  def source_file; end
+  def source_line; end
+  def source_location; end
+  def wrapped(*args, &block); end
+
+  private
+
+  def class_regexes; end
+  def first_line_of_module_definition(file, line); end
+  def first_method_source_location; end
+  def last_method_source_location; end
+  def lines_for_file(*a, &b); end
+  def method_candidates(*a, &b); end
+  def name(*a, &b); end
+  def number_of_lines_in_first_chunk; end
+  def yard_docs?(*a, &b); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/public_suffix@4.0.6.rbi b/Library/Homebrew/sorbet/rbi/gems/public_suffix@4.0.6.rbi
index 18b49dfcf1..05212f6d01 100644
--- a/Library/Homebrew/sorbet/rbi/gems/public_suffix@4.0.6.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/public_suffix@4.0.6.rbi
@@ -15,7 +15,6 @@ module PublicSuffix
 end
 
 PublicSuffix::BANG = T.let(T.unsafe(nil), String)
-
 PublicSuffix::DOT = T.let(T.unsafe(nil), String)
 
 class PublicSuffix::Domain
@@ -37,14 +36,9 @@ class PublicSuffix::Domain
   end
 end
 
-class PublicSuffix::DomainInvalid < ::PublicSuffix::Error
-end
-
-class PublicSuffix::DomainNotAllowed < ::PublicSuffix::DomainInvalid
-end
-
-class PublicSuffix::Error < ::StandardError
-end
+class PublicSuffix::DomainInvalid < ::PublicSuffix::Error; end
+class PublicSuffix::DomainNotAllowed < ::PublicSuffix::DomainInvalid; end
+class PublicSuffix::Error < ::StandardError; end
 
 class PublicSuffix::List
   def initialize; end
@@ -148,5 +142,4 @@ class PublicSuffix::Rule::Wildcard < ::PublicSuffix::Rule::Base
 end
 
 PublicSuffix::STAR = T.let(T.unsafe(nil), String)
-
 PublicSuffix::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/racc@1.5.2.rbi b/Library/Homebrew/sorbet/rbi/gems/racc@1.5.2.rbi
index 0f9dfd942a..a085878a3a 100644
--- a/Library/Homebrew/sorbet/rbi/gems/racc@1.5.2.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/racc@1.5.2.rbi
@@ -1,13 +1,257 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `racc` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
+class Object < ::BasicObject
+  include ::ActiveSupport::ForkTracker::CoreExt
+  include ::ActiveSupport::ForkTracker::CoreExtPrivate
+  include ::ActiveSupport::ToJsonWithActiveSupportEncoder
+  include ::Kernel
+  include ::JSON::Ext::Generator::GeneratorMethods::Object
+  include ::PP::ObjectMixin
+  include ::ActiveSupport::Tryable
+  include ::ActiveSupport::Dependencies::Loadable
+end
+
 ParseError = Racc::ParseError
 
+class Racc::Accept
+  def inspect; end
+end
+
+class Racc::ActionTable
+  def initialize(rt, st); end
+
+  def accept; end
+  def each_reduce(&block); end
+  def each_shift(&block); end
+  def error; end
+  def init; end
+  def reduce(i); end
+  def reduce_n; end
+  def shift(i); end
+  def shift_n; end
+end
+
+class Racc::CompileError < ::Racc::Error; end
 Racc::Copyright = T.let(T.unsafe(nil), String)
 
+class Racc::DebugFlags
+  def initialize(parse = T.unsafe(nil), rule = T.unsafe(nil), token = T.unsafe(nil), state = T.unsafe(nil), la = T.unsafe(nil), prec = T.unsafe(nil), conf = T.unsafe(nil)); end
+
+  def any?; end
+  def la; end
+  def parse; end
+  def prec; end
+  def rule; end
+  def state; end
+  def status_logging; end
+  def token; end
+
+  class << self
+    def parse_option_string(s); end
+  end
+end
+
+class Racc::Error < ::StandardError
+  def inspect; end
+end
+
+class Racc::Goto
+  def initialize(ident, sym, from, to); end
+
+  def from_state; end
+  def ident; end
+  def inspect; end
+  def symbol; end
+  def to_state; end
+end
+
+class Racc::Grammar
+  extend ::Forwardable
+
+  def initialize(debug_flags = T.unsafe(nil)); end
+
+  def [](x); end
+  def add(rule); end
+  def added?(sym); end
+  def declare_precedence(assoc, syms); end
+  def dfa; end
+  def each(&block); end
+  def each_index(&block); end
+  def each_nonterminal(*args, &block); end
+  def each_rule(&block); end
+  def each_symbol(*args, &block); end
+  def each_terminal(*args, &block); end
+  def each_useless_nonterminal; end
+  def each_useless_rule; end
+  def each_with_index(&block); end
+  def end_precedence_declaration(reverse); end
+  def init; end
+  def intern(value, dummy = T.unsafe(nil)); end
+  def n_expected_srconflicts; end
+  def n_expected_srconflicts=(_arg0); end
+  def n_useless_nonterminals; end
+  def n_useless_rules; end
+  def nfa; end
+  def nonterminal_base; end
+  def parser_class; end
+  def size; end
+  def start; end
+  def start_symbol=(s); end
+  def state_transition_table; end
+  def states; end
+  def symbols; end
+  def symboltable; end
+  def to_s; end
+  def useless_nonterminal_exist?; end
+  def useless_rule_exist?; end
+  def write_log(path); end
+
+  private
+
+  def _compute_expand(t, set, lock); end
+  def add_start_rule; end
+  def check_rules_nullable(rules); end
+  def check_rules_useless(rules); end
+  def check_symbols_nullable(symbols); end
+  def check_symbols_useless(s); end
+  def compute_expand(t); end
+  def compute_hash; end
+  def compute_heads; end
+  def compute_locate; end
+  def compute_nullable; end
+  def compute_nullable_0; end
+  def compute_useless; end
+  def determine_terminals; end
+  def fix_ident; end
+
+  class << self
+    def define(&block); end
+  end
+end
+
+class Racc::Grammar::DefinitionEnv
+  def initialize; end
+
+  def _(&block); end
+  def _add(target, x); end
+  def _added?(sym); end
+  def _delayed_add(rule); end
+  def _intern(x); end
+  def action(&block); end
+  def flush_delayed; end
+  def grammar; end
+  def many(sym, &block); end
+  def many1(sym, &block); end
+  def method_missing(mid, *args, &block); end
+  def null(&block); end
+  def option(sym, default = T.unsafe(nil), &block); end
+  def precedence_table(&block); end
+  def separated_by(sep, sym, &block); end
+  def separated_by1(sep, sym, &block); end
+  def seq(*list, &block); end
+
+  private
+
+  def _defmetasyntax(type, id, action, &block); end
+  def _regist(target_name); end
+  def _wrap(target_name, sym, block); end
+end
+
+class Racc::Grammar::PrecedenceDefinitionEnv
+  def initialize(g); end
+
+  def higher; end
+  def left(*syms); end
+  def lower; end
+  def nonassoc(*syms); end
+  def reverse; end
+  def right(*syms); end
+end
+
+class Racc::ISet
+  def initialize(a = T.unsafe(nil)); end
+
+  def [](key); end
+  def []=(key, val); end
+  def add(i); end
+  def clear; end
+  def delete(key); end
+  def dup; end
+  def each(&block); end
+  def empty?; end
+  def include?(key); end
+  def inspect; end
+  def key?(key); end
+  def set; end
+  def size; end
+  def to_a; end
+  def to_s; end
+  def update(other); end
+  def update_a(a); end
+end
+
+class Racc::Item
+  def initialize(rule, la); end
+
+  def each_la(tbl); end
+  def la; end
+  def rule; end
+end
+
+class Racc::LocationPointer
+  def initialize(rule, i, sym); end
+
+  def ==(ot); end
+  def before(len); end
+  def dereference; end
+  def eql?(ot); end
+  def hash; end
+  def head?; end
+  def ident; end
+  def increment; end
+  def index; end
+  def inspect; end
+  def next; end
+  def reduce; end
+  def reduce?; end
+  def rule; end
+  def symbol; end
+  def to_s; end
+
+  private
+
+  def ptr_bug!; end
+end
+
+class Racc::LogFileGenerator
+  def initialize(states, debug_flags = T.unsafe(nil)); end
+
+  def action_out(f, state); end
+  def outact(f, t, act); end
+  def output(out); end
+  def output_conflict(out); end
+  def output_rule(out); end
+  def output_state(out); end
+  def output_token(out); end
+  def output_useless(out); end
+  def outrrconf(f, confs); end
+  def outsrconf(f, confs); end
+  def pointer_out(out, ptr); end
+  def symbol_locations(locs); end
+end
+
+class Racc::OrMark
+  def initialize(lineno); end
+
+  def inspect; end
+  def lineno; end
+  def name; end
+end
+
 class Racc::Parser
   def _racc_do_parse_rb(arg, in_debug); end
   def _racc_do_reduce(arg, act); end
@@ -37,21 +281,357 @@ class Racc::Parser
 end
 
 Racc::Parser::Racc_Main_Parsing_Routine = T.let(T.unsafe(nil), Symbol)
-
 Racc::Parser::Racc_Runtime_Core_Id_C = T.let(T.unsafe(nil), String)
-
 Racc::Parser::Racc_Runtime_Core_Version = T.let(T.unsafe(nil), String)
-
 Racc::Parser::Racc_Runtime_Core_Version_C = T.let(T.unsafe(nil), String)
-
 Racc::Parser::Racc_Runtime_Core_Version_R = T.let(T.unsafe(nil), String)
-
 Racc::Parser::Racc_Runtime_Type = T.let(T.unsafe(nil), String)
-
 Racc::Parser::Racc_Runtime_Version = T.let(T.unsafe(nil), String)
-
 Racc::Parser::Racc_YY_Parse_Method = T.let(T.unsafe(nil), Symbol)
 
-Racc::VERSION = T.let(T.unsafe(nil), String)
+class Racc::ParserClassGenerator
+  def initialize(states); end
 
+  def generate; end
+
+  private
+
+  def define_actions(c); end
+end
+
+class Racc::Prec
+  def initialize(symbol, lineno); end
+
+  def inspect; end
+  def lineno; end
+  def name; end
+  def symbol; end
+end
+
+class Racc::RRconflict
+  def initialize(sid, high, low, tok); end
+
+  def high_prec; end
+  def low_prec; end
+  def stateid; end
+  def to_s; end
+  def token; end
+end
+
+class Racc::Reduce
+  def initialize(rule); end
+
+  def decref; end
+  def incref; end
+  def inspect; end
+  def refn; end
+  def rule; end
+  def ruleid; end
+end
+
+class Racc::Rule
+  def initialize(target, syms, act); end
+
+  def ==(other); end
+  def [](idx); end
+  def accept?; end
+  def action; end
+  def each(&block); end
+  def each_rule(&block); end
+  def empty?; end
+  def hash; end
+  def hash=(n); end
+  def ident; end
+  def ident=(_arg0); end
+  def inspect; end
+  def null=(n); end
+  def nullable?; end
+  def prec(sym, &block); end
+  def precedence; end
+  def precedence=(sym); end
+  def ptrs; end
+  def replace(src, dest); end
+  def rule; end
+  def size; end
+  def specified_prec; end
+  def specified_prec=(_arg0); end
+  def symbols; end
+  def target; end
+  def target=(_arg0); end
+  def to_s; end
+  def useless=(u); end
+  def useless?; end
+  def |(x); end
+end
+
+class Racc::SRconflict
+  def initialize(sid, shift, reduce); end
+
+  def reduce; end
+  def shift; end
+  def stateid; end
+  def to_s; end
+end
+
+class Racc::Shift
+  def initialize(goto); end
+
+  def goto_id; end
+  def goto_state; end
+  def inspect; end
+end
+
+class Racc::SourceText
+  def initialize(text, filename, lineno); end
+
+  def filename; end
+  def lineno; end
+  def location; end
+  def text; end
+  def to_s; end
+end
+
+class Racc::State
+  def initialize(ident, core); end
+
+  def ==(oth); end
+  def action; end
+  def check_la(la_rules); end
+  def closure; end
+  def conflict?; end
+  def core; end
+  def defact; end
+  def defact=(_arg0); end
+  def eql?(oth); end
+  def goto_table; end
+  def gotos; end
+  def hash; end
+  def ident; end
+  def inspect; end
+  def la=(la); end
+  def make_closure(core); end
+  def n_rrconflicts; end
+  def n_srconflicts; end
+  def ritems; end
+  def rr_conflict(high, low, ctok); end
+  def rrconf; end
+  def rruleid(rule); end
+  def rrules; end
+  def sr_conflict(shift, reduce); end
+  def srconf; end
+  def stateid; end
+  def stokens; end
+  def to_s; end
+end
+
+class Racc::StateTransitionTable < ::Struct
+  def initialize(states); end
+
+  def action_check; end
+  def action_check=(_); end
+  def action_default; end
+  def action_default=(_); end
+  def action_pointer; end
+  def action_pointer=(_); end
+  def action_table; end
+  def action_table=(_); end
+  def debug_parser; end
+  def debug_parser=(_); end
+  def goto_check; end
+  def goto_check=(_); end
+  def goto_default; end
+  def goto_default=(_); end
+  def goto_pointer; end
+  def goto_pointer=(_); end
+  def goto_table; end
+  def goto_table=(_); end
+  def grammar; end
+  def nt_base; end
+  def nt_base=(_); end
+  def parser_class; end
+  def reduce_n; end
+  def reduce_n=(_); end
+  def reduce_table; end
+  def reduce_table=(_); end
+  def shift_n; end
+  def shift_n=(_); end
+  def states; end
+  def token_table; end
+  def token_table=(_); end
+  def token_to_s_table; end
+  def token_to_s_table=(_); end
+  def token_value_table; end
+  def use_result_var; end
+  def use_result_var=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def generate(states); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class Racc::StateTransitionTableGenerator
+  def initialize(states); end
+
+  def act2actid(act); end
+  def addent(all, arr, chkval, ptr); end
+  def gen_action_tables(t, states); end
+  def gen_goto_tables(t, grammar); end
+  def generate; end
+  def mkmapexp(arr); end
+  def reduce_table(grammar); end
+  def set_table(entries, dummy, tbl, chk, ptr); end
+  def token_table(grammar); end
+end
+
+Racc::StateTransitionTableGenerator::RE_DUP_MAX = T.let(T.unsafe(nil), Integer)
+
+class Racc::States
+  include ::Enumerable
+  extend ::Forwardable
+
+  def initialize(grammar, debug_flags = T.unsafe(nil)); end
+
+  def [](i); end
+  def actions; end
+  def dfa; end
+  def each(&block); end
+  def each_index(&block); end
+  def each_state(&block); end
+  def grammar; end
+  def inspect; end
+  def n_rrconflicts; end
+  def n_srconflicts; end
+  def nfa; end
+  def nt_base(*args, &block); end
+  def reduce_n(*args, &block); end
+  def rrconflict_exist?; end
+  def shift_n(*args, &block); end
+  def should_report_srconflict?; end
+  def size; end
+  def srconflict_exist?; end
+  def state_transition_table; end
+  def to_s; end
+
+  private
+
+  def addrel(tbl, i, item); end
+  def addsym(table, sym, ptr); end
+  def check_useless; end
+  def compute_dfa; end
+  def compute_nfa; end
+  def core_to_state(core); end
+  def create_tmap(size); end
+  def digraph(map, relation); end
+  def do_resolve_sr(stok, rtok); end
+  def each_t(tbl, set); end
+  def fingerprint(arr); end
+  def generate_states(state); end
+  def lookahead; end
+  def pack(state); end
+  def print_atab(idx, tab); end
+  def print_tab(idx, rel, tab); end
+  def print_tab_i(idx, rel, tab, i); end
+  def printb(i); end
+  def record_path(begst, rule); end
+  def resolve(state); end
+  def resolve_rr(state, r); end
+  def resolve_sr(state, s); end
+  def set_accept; end
+  def transpose(rel); end
+  def traverse(i, index, vertices, map, relation); end
+end
+
+Racc::States::ASSOC = T.let(T.unsafe(nil), Hash)
+
+class Racc::Sym
+  def initialize(value, dummyp); end
+
+  def assoc; end
+  def assoc=(_arg0); end
+  def dummy?; end
+  def expand; end
+  def expand=(v); end
+  def hash; end
+  def heads; end
+  def ident; end
+  def ident=(v); end
+  def inspect; end
+  def locate; end
+  def nonterminal?; end
+  def null=(n); end
+  def nullable?; end
+  def precedence; end
+  def precedence=(_arg0); end
+  def rule; end
+  def self_null?; end
+  def serialize; end
+  def serialized=(_arg0); end
+  def should_terminal; end
+  def should_terminal?; end
+  def snull=(v); end
+  def string_symbol?; end
+  def term=(t); end
+  def terminal?; end
+  def to_s; end
+  def useless=(f); end
+  def useless?; end
+  def value; end
+  def |(x); end
+
+  class << self
+    def once_writer(nm); end
+  end
+end
+
+class Racc::SymbolTable
+  include ::Enumerable
+
+  def initialize; end
+
+  def [](id); end
+  def anchor; end
+  def delete(sym); end
+  def dummy; end
+  def each(&block); end
+  def each_nonterminal(&block); end
+  def each_terminal(&block); end
+  def error; end
+  def fix; end
+  def intern(val, dummy = T.unsafe(nil)); end
+  def nonterminals; end
+  def nt_base; end
+  def nt_max; end
+  def symbols; end
+  def terminals(&block); end
+  def to_a; end
+
+  private
+
+  def check_terminals; end
+  def fix_ident; end
+end
+
+class Racc::UserAction
+  def initialize(src, proc); end
+
+  def empty?; end
+  def inspect; end
+  def name; end
+  def proc; end
+  def proc?; end
+  def source; end
+  def source?; end
+
+  class << self
+    def empty; end
+    def proc(pr = T.unsafe(nil), &block); end
+    def source_text(src); end
+  end
+end
+
+Racc::VERSION = T.let(T.unsafe(nil), String)
 Racc::Version = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/rack@2.2.3.rbi b/Library/Homebrew/sorbet/rbi/gems/rack@2.2.3.rbi
index a1119dbde9..6bbba62197 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rack@2.2.3.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rack@2.2.3.rbi
@@ -1,12 +1,840 @@
 # 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`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
 module Rack
+  class << self
+    def release; end
+    def version; end
+  end
 end
 
+module Rack::Auth; end
+
+class Rack::Auth::AbstractHandler
+  def initialize(app, realm = T.unsafe(nil), &authenticator); end
+
+  def realm; end
+  def realm=(_arg0); end
+
+  private
+
+  def bad_request; end
+  def unauthorized(www_authenticate = T.unsafe(nil)); end
+end
+
+class Rack::Auth::AbstractRequest
+  def initialize(env); end
+
+  def params; end
+  def parts; end
+  def provided?; end
+  def request; end
+  def scheme; end
+  def valid?; end
+
+  private
+
+  def authorization_key; end
+end
+
+Rack::Auth::AbstractRequest::AUTHORIZATION_KEYS = T.let(T.unsafe(nil), Array)
+
+class Rack::Auth::Basic < ::Rack::Auth::AbstractHandler
+  def call(env); end
+
+  private
+
+  def challenge; end
+  def valid?(auth); end
+end
+
+class Rack::Auth::Basic::Request < ::Rack::Auth::AbstractRequest
+  def basic?; end
+  def credentials; end
+  def username; end
+end
+
+module Rack::Auth::Digest; end
+
+class Rack::Auth::Digest::MD5 < ::Rack::Auth::AbstractHandler
+  def initialize(app, realm = T.unsafe(nil), opaque = T.unsafe(nil), &authenticator); end
+
+  def call(env); end
+  def opaque; end
+  def opaque=(_arg0); end
+  def passwords_hashed=(_arg0); end
+  def passwords_hashed?; end
+
+  private
+
+  def A1(auth, password); end
+  def A2(auth); end
+  def H(data); end
+  def KD(secret, data); end
+  def challenge(hash = T.unsafe(nil)); end
+  def digest(auth, password); end
+  def md5(data); end
+  def params(hash = T.unsafe(nil)); end
+  def valid?(auth); end
+  def valid_digest?(auth); end
+  def valid_nonce?(auth); end
+  def valid_opaque?(auth); end
+  def valid_qop?(auth); end
+end
+
+Rack::Auth::Digest::MD5::QOP = T.let(T.unsafe(nil), String)
+
+class Rack::Auth::Digest::Nonce
+  def initialize(timestamp = T.unsafe(nil), given_digest = T.unsafe(nil)); end
+
+  def digest; end
+  def fresh?; end
+  def stale?; end
+  def to_s; end
+  def valid?; end
+
+  class << self
+    def parse(string); end
+    def private_key; end
+    def private_key=(_arg0); end
+    def time_limit; end
+    def time_limit=(_arg0); end
+  end
+end
+
+class Rack::Auth::Digest::Params < ::Hash
+  def initialize; end
+
+  def [](k); end
+  def []=(k, v); end
+  def quote(str); end
+  def to_s; end
+
+  class << self
+    def dequote(str); end
+    def parse(str); end
+    def split_header_value(str); end
+  end
+end
+
+Rack::Auth::Digest::Params::UNQUOTED = T.let(T.unsafe(nil), Array)
+
+class Rack::Auth::Digest::Request < ::Rack::Auth::AbstractRequest
+  def correct_uri?; end
+  def digest?; end
+  def method; end
+  def method_missing(sym, *args); end
+  def nonce; end
+  def params; end
+  def respond_to?(sym, *_arg1); end
+end
+
+class Rack::BodyProxy
+  def initialize(body, &block); end
+
+  def close; end
+  def closed?; end
+  def method_missing(method_name, *args, &block); end
+
+  private
+
+  def respond_to_missing?(method_name, include_all = T.unsafe(nil)); end
+end
+
+class Rack::Builder
+  def initialize(default_app = T.unsafe(nil), &block); end
+
+  def call(env); end
+  def freeze_app; end
+  def map(path, &block); end
+  def run(app); end
+  def to_app; end
+  def use(middleware, *args, &block); end
+  def warmup(prc = T.unsafe(nil), &block); end
+
+  private
+
+  def generate_map(default_app, mapping); end
+
+  class << self
+    def app(default_app = T.unsafe(nil), &block); end
+    def load_file(path, opts = T.unsafe(nil)); end
+    def new_from_string(builder_script, file = T.unsafe(nil)); end
+    def parse_file(config, opts = T.unsafe(nil)); end
+  end
+end
+
+Rack::Builder::UTF_8_BOM = T.let(T.unsafe(nil), String)
+Rack::CACHE_CONTROL = T.let(T.unsafe(nil), String)
+Rack::CONTENT_LENGTH = T.let(T.unsafe(nil), String)
+Rack::CONTENT_TYPE = T.let(T.unsafe(nil), String)
+
+class Rack::Cascade
+  def initialize(apps, cascade_for = T.unsafe(nil)); end
+
+  def <<(app); end
+  def add(app); end
+  def apps; end
+  def call(env); end
+  def include?(app); end
+end
+
+Rack::Cascade::NotFound = T.let(T.unsafe(nil), Array)
+
+class Rack::Chunked
+  include ::Rack::Utils
+
+  def initialize(app); end
+
+  def call(env); end
+  def chunkable_version?(ver); end
+end
+
+class Rack::Chunked::Body
+  def initialize(body); end
+
+  def close; end
+  def each(&block); end
+
+  private
+
+  def yield_trailers; end
+end
+
+Rack::Chunked::Body::TAIL = T.let(T.unsafe(nil), String)
+Rack::Chunked::Body::TERM = T.let(T.unsafe(nil), String)
+
+class Rack::Chunked::TrailerBody < ::Rack::Chunked::Body
+  private
+
+  def yield_trailers; end
+end
+
+class Rack::CommonLogger
+  def initialize(app, logger = T.unsafe(nil)); end
+
+  def call(env); end
+
+  private
+
+  def extract_content_length(headers); end
+  def log(env, status, header, began_at); end
+end
+
+Rack::CommonLogger::FORMAT = T.let(T.unsafe(nil), String)
+
+class Rack::ConditionalGet
+  def initialize(app); end
+
+  def call(env); end
+
+  private
+
+  def etag_matches?(none_match, headers); end
+  def fresh?(env, headers); end
+  def modified_since?(modified_since, headers); end
+  def to_rfc2822(since); end
+end
+
+class Rack::Config
+  def initialize(app, &block); end
+
+  def call(env); end
+end
+
+class Rack::ContentLength
+  include ::Rack::Utils
+
+  def initialize(app); end
+
+  def call(env); end
+end
+
+class Rack::ContentType
+  include ::Rack::Utils
+
+  def initialize(app, content_type = T.unsafe(nil)); end
+
+  def call(env); end
+end
+
+Rack::DELETE = T.let(T.unsafe(nil), String)
+
+class Rack::Deflater
+  def initialize(app, options = T.unsafe(nil)); end
+
+  def call(env); end
+
+  private
+
+  def should_deflate?(env, status, headers, body); end
+end
+
+class Rack::Deflater::GzipStream
+  def initialize(body, mtime, sync); end
+
+  def close; end
+  def each(&block); end
+  def write(data); end
+end
+
+class Rack::Directory
+  def initialize(root, app = T.unsafe(nil)); end
+
+  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 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
+end
+
+Rack::Directory::DIR_FILE = T.let(T.unsafe(nil), String)
+Rack::Directory::DIR_PAGE_FOOTER = T.let(T.unsafe(nil), String)
+Rack::Directory::DIR_PAGE_HEADER = T.let(T.unsafe(nil), String)
+
+class Rack::Directory::DirectoryBody < ::Struct
+  def each; end
+
+  private
+
+  def DIR_FILE_escape(htmls); end
+end
+
+Rack::Directory::FILESIZE_FORMAT = T.let(T.unsafe(nil), Array)
+Rack::ETAG = T.let(T.unsafe(nil), String)
+
+class Rack::ETag
+  def initialize(app, no_cache_control = T.unsafe(nil), cache_control = T.unsafe(nil)); end
+
+  def call(env); end
+
+  private
+
+  def digest_body(body); end
+  def etag_body?(body); end
+  def etag_status?(status); end
+  def skip_caching?(headers); end
+end
+
+Rack::ETag::DEFAULT_CACHE_CONTROL = T.let(T.unsafe(nil), String)
+Rack::ETag::ETAG_STRING = T.let(T.unsafe(nil), String)
+Rack::EXPIRES = T.let(T.unsafe(nil), String)
+
+class Rack::Events
+  def initialize(app, handlers); end
+
+  def call(env); end
+
+  private
+
+  def make_request(env); end
+  def make_response(status, headers, body); end
+  def on_commit(request, response); end
+  def on_error(request, response, e); end
+  def on_finish(request, response); end
+  def on_start(request, response); 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
+
+class Rack::Events::BufferedResponse < ::Rack::Response::Raw
+  def initialize(status, headers, body); end
+
+  def body; end
+  def to_a; end
+end
+
+class Rack::Events::EventedBodyProxy < ::Rack::BodyProxy
+  def initialize(body, request, response, handlers, &block); end
+
+  def each; end
+  def request; end
+  def response; end
+end
+
+Rack::File = Rack::Files
+
+class Rack::Files
+  def initialize(root, headers = T.unsafe(nil), default_mime = T.unsafe(nil)); end
+
+  def call(env); end
+  def get(env); end
+  def root; end
+  def serving(request, path); end
+
+  private
+
+  def fail(status, body, headers = T.unsafe(nil)); end
+  def filesize(path); end
+  def mime_type(path, default_mime); end
+
+  class << self
+    def method_added(name); end
+  end
+end
+
+Rack::Files::ALLOWED_VERBS = T.let(T.unsafe(nil), Array)
+Rack::Files::ALLOW_HEADER = T.let(T.unsafe(nil), String)
+
+class Rack::Files::BaseIterator
+  def initialize(path, ranges, options); end
+
+  def bytesize; end
+  def close; end
+  def each; end
+  def options; end
+  def path; end
+  def ranges; end
+
+  private
+
+  def each_range_part(file, range); end
+  def multipart?; end
+  def multipart_heading(range); end
+end
+
+class Rack::Files::Iterator < ::Rack::Files::BaseIterator
+  def to_path; end
+end
+
+Rack::Files::MULTIPART_BOUNDARY = T.let(T.unsafe(nil), String)
+
+class Rack::ForwardRequest < ::Exception
+  def initialize(url, env = T.unsafe(nil)); end
+
+  def env; end
+  def url; end
+end
+
+Rack::GET = T.let(T.unsafe(nil), String)
+Rack::HEAD = T.let(T.unsafe(nil), String)
+Rack::HTTPS = T.let(T.unsafe(nil), String)
+Rack::HTTP_COOKIE = T.let(T.unsafe(nil), String)
+Rack::HTTP_HOST = T.let(T.unsafe(nil), String)
+Rack::HTTP_PORT = T.let(T.unsafe(nil), String)
+Rack::HTTP_VERSION = T.let(T.unsafe(nil), String)
+
+module Rack::Handler
+  class << self
+    def default; end
+    def get(server); end
+    def pick(server_names); end
+    def register(server, klass); end
+    def try_require(prefix, const_name); end
+  end
+end
+
+class Rack::Handler::CGI
+  class << self
+    def run(app, **options); end
+    def send_body(body); end
+    def send_headers(status, headers); end
+    def serve(app); end
+  end
+end
+
+Rack::Handler::SERVER_NAMES = T.let(T.unsafe(nil), Array)
+
+class Rack::Handler::WEBrick < ::WEBrick::HTTPServlet::AbstractServlet
+  def initialize(server, app); end
+
+  def service(req, res); end
+
+  class << self
+    def run(app, **options); end
+    def shutdown; end
+    def valid_options; end
+  end
+end
+
+class Rack::Head
+  def initialize(app); end
+
+  def call(env); end
+end
+
+Rack::LINK = T.let(T.unsafe(nil), String)
+
+class Rack::Lint
+  include ::Rack::Lint::Assertion
+
+  def initialize(app); end
+
+  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; end
+  def verify_content_length(bytes); end
+end
+
+module Rack::Lint::Assertion
+  def assert(message); end
+end
+
+class Rack::Lint::ErrorWrapper
+  include ::Rack::Lint::Assertion
+
+  def initialize(error); end
+
+  def close(*args); end
+  def flush; end
+  def puts(str); end
+  def write(str); end
+end
+
+class Rack::Lint::HijackWrapper
+  include ::Rack::Lint::Assertion
+  extend ::Forwardable
+
+  def initialize(io); end
+
+  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 read(*args, &block); end
+  def read_nonblock(*args, &block); end
+  def write(*args, &block); end
+  def write_nonblock(*args, &block); end
+end
+
+Rack::Lint::HijackWrapper::REQUIRED_METHODS = T.let(T.unsafe(nil), Array)
+
+class Rack::Lint::InputWrapper
+  include ::Rack::Lint::Assertion
+
+  def initialize(input); end
+
+  def close(*args); end
+  def each(*args); end
+  def gets(*args); end
+  def read(*args); end
+  def rewind(*args); end
+end
+
+class Rack::Lint::LintError < ::RuntimeError; end
+
+class Rack::Lock
+  def initialize(app, mutex = T.unsafe(nil)); end
+
+  def call(env); end
+
+  private
+
+  def unlock; end
+end
+
+class Rack::Logger
+  def initialize(app, level = T.unsafe(nil)); end
+
+  def call(env); end
+end
+
+class Rack::MediaType
+  class << self
+    def params(content_type); end
+    def type(content_type); end
+
+    private
+
+    def strip_doublequotes(str); end
+  end
+end
+
+Rack::MediaType::SPLIT_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+class Rack::MethodOverride
+  def initialize(app); end
+
+  def call(env); end
+  def method_override(env); end
+
+  private
+
+  def allowed_methods; end
+  def method_override_param(req); end
+end
+
+Rack::MethodOverride::ALLOWED_METHODS = T.let(T.unsafe(nil), Array)
+Rack::MethodOverride::HTTP_METHODS = T.let(T.unsafe(nil), Array)
+Rack::MethodOverride::HTTP_METHOD_OVERRIDE_HEADER = T.let(T.unsafe(nil), String)
+Rack::MethodOverride::METHOD_OVERRIDE_PARAM_KEY = T.let(T.unsafe(nil), String)
+
+module Rack::Mime
+  private
+
+  def match?(value, matcher); end
+  def mime_type(ext, fallback = T.unsafe(nil)); end
+
+  class << self
+    def match?(value, matcher); end
+    def mime_type(ext, fallback = T.unsafe(nil)); end
+  end
+end
+
+Rack::Mime::MIME_TYPES = T.let(T.unsafe(nil), Hash)
+
+class Rack::MockRequest
+  def initialize(app); end
+
+  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 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
+
+  class << self
+    def env_for(uri = T.unsafe(nil), opts = T.unsafe(nil)); end
+    def parse_uri_rfc2396(uri); end
+  end
+end
+
+Rack::MockRequest::DEFAULT_ENV = T.let(T.unsafe(nil), Hash)
+
+class Rack::MockRequest::FatalWarner
+  def flush; end
+  def puts(warning); end
+  def string; end
+  def write(warning); end
+end
+
+class Rack::MockRequest::FatalWarning < ::RuntimeError; end
+
+class Rack::MockResponse < ::Rack::Response
+  def initialize(status, headers, body, errors = T.unsafe(nil)); end
+
+  def =~(other); end
+  def body; end
+  def cookie(name); end
+  def cookies; end
+  def empty?; end
+  def errors; end
+  def errors=(_arg0); end
+  def match(other); end
+  def original_headers; end
+
+  private
+
+  def identify_cookie_attributes(cookie_filling); end
+  def parse_cookies_from_header; end
+
+  class << self
+    def [](*_arg0); end
+  end
+end
+
+module Rack::Multipart
+  class << self
+    def build_multipart(params, first = T.unsafe(nil)); end
+    def extract_multipart(req, params = T.unsafe(nil)); end
+    def parse_multipart(env, params = T.unsafe(nil)); end
+  end
+end
+
+Rack::Multipart::ATTRIBUTE = T.let(T.unsafe(nil), Regexp)
+Rack::Multipart::ATTRIBUTE_CHAR = T.let(T.unsafe(nil), Regexp)
+Rack::Multipart::BROKEN_QUOTED = T.let(T.unsafe(nil), Regexp)
+Rack::Multipart::BROKEN_UNQUOTED = T.let(T.unsafe(nil), Regexp)
+Rack::Multipart::CONDISP = T.let(T.unsafe(nil), Regexp)
+Rack::Multipart::DISPPARM = T.let(T.unsafe(nil), Regexp)
+Rack::Multipart::EOL = T.let(T.unsafe(nil), String)
+Rack::Multipart::EXTENDED_INITIAL_NAME = T.let(T.unsafe(nil), Regexp)
+Rack::Multipart::EXTENDED_INITIAL_PARAMETER = T.let(T.unsafe(nil), Regexp)
+Rack::Multipart::EXTENDED_INITIAL_VALUE = T.let(T.unsafe(nil), Regexp)
+Rack::Multipart::EXTENDED_OTHER_NAME = T.let(T.unsafe(nil), Regexp)
+Rack::Multipart::EXTENDED_OTHER_PARAMETER = T.let(T.unsafe(nil), Regexp)
+Rack::Multipart::EXTENDED_OTHER_VALUE = T.let(T.unsafe(nil), Regexp)
+Rack::Multipart::EXTENDED_PARAMETER = T.let(T.unsafe(nil), Regexp)
+
+class Rack::Multipart::Generator
+  def initialize(params, first = T.unsafe(nil)); end
+
+  def dump; end
+
+  private
+
+  def content_for_other(file, name); end
+  def content_for_tempfile(io, file, name); end
+  def flattened_params; end
+  def multipart?; end
+end
+
+Rack::Multipart::MULTIPART = T.let(T.unsafe(nil), Regexp)
+Rack::Multipart::MULTIPART_BOUNDARY = T.let(T.unsafe(nil), String)
+Rack::Multipart::MULTIPART_CONTENT_DISPOSITION = T.let(T.unsafe(nil), Regexp)
+Rack::Multipart::MULTIPART_CONTENT_ID = T.let(T.unsafe(nil), Regexp)
+Rack::Multipart::MULTIPART_CONTENT_TYPE = T.let(T.unsafe(nil), Regexp)
+class Rack::Multipart::MultipartPartLimitError < ::Errno::EMFILE; end
+
+class Rack::Multipart::Parser
+  def initialize(boundary, tempfile, bufsize, query_parser); end
+
+  def on_read(content); end
+  def result; end
+  def state; end
+
+  private
+
+  def consume_boundary; end
+  def full_boundary; end
+  def get_filename(head); end
+  def handle_consume_token; end
+  def handle_empty_content!(content); end
+  def handle_fast_forward; end
+  def handle_mime_body; end
+  def handle_mime_head; end
+  def run_parser; end
+  def tag_multipart_encoding(filename, content_type, name, body); end
+
+  class << self
+    def parse(io, content_length, content_type, tmpfile, bufsize, qp); end
+    def parse_boundary(content_type); end
+  end
+end
+
+Rack::Multipart::Parser::BOUNDARY_REGEX = T.let(T.unsafe(nil), Regexp)
+Rack::Multipart::Parser::BUFSIZE = T.let(T.unsafe(nil), Integer)
+
+class Rack::Multipart::Parser::BoundedIO
+  def initialize(io, content_length); end
+
+  def read(size, outbuf = T.unsafe(nil)); end
+  def rewind; end
+end
+
+Rack::Multipart::Parser::CHARSET = T.let(T.unsafe(nil), String)
+
+class Rack::Multipart::Parser::Collector
+  include ::Enumerable
+
+  def initialize(tempfile); end
+
+  def each; 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
+
+  private
+
+  def check_open_files; end
+end
+
+class Rack::Multipart::Parser::Collector::BufferPart < ::Rack::Multipart::Parser::Collector::MimePart
+  def close; end
+  def file?; end
+end
+
+class Rack::Multipart::Parser::Collector::MimePart < ::Struct
+  def get_data; end
+end
+
+class Rack::Multipart::Parser::Collector::TempfilePart < ::Rack::Multipart::Parser::Collector::MimePart
+  def close; end
+  def file?; end
+end
+
+Rack::Multipart::Parser::EMPTY = T.let(T.unsafe(nil), Rack::Multipart::Parser::MultipartInfo)
+
+class Rack::Multipart::Parser::MultipartInfo < ::Struct
+  def params; end
+  def params=(_); end
+  def tmp_files; end
+  def tmp_files=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+Rack::Multipart::Parser::TEMPFILE_FACTORY = T.let(T.unsafe(nil), Proc)
+Rack::Multipart::Parser::TEXT_PLAIN = T.let(T.unsafe(nil), String)
+Rack::Multipart::REGULAR_PARAMETER = T.let(T.unsafe(nil), Regexp)
+Rack::Multipart::REGULAR_PARAMETER_NAME = T.let(T.unsafe(nil), Regexp)
+Rack::Multipart::RFC2183 = T.let(T.unsafe(nil), Regexp)
+Rack::Multipart::SECTION = T.let(T.unsafe(nil), Regexp)
+Rack::Multipart::TOKEN = T.let(T.unsafe(nil), Regexp)
+
+class Rack::Multipart::UploadedFile
+  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 content_type; end
+  def content_type=(_arg0); 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
+
+Rack::Multipart::VALUE = T.let(T.unsafe(nil), Regexp)
+
+class Rack::NullLogger
+  def initialize(app); end
+
+  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 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
+
+Rack::OPTIONS = T.let(T.unsafe(nil), String)
+Rack::PATCH = T.let(T.unsafe(nil), String)
+Rack::PATH_INFO = T.let(T.unsafe(nil), String)
+Rack::POST = T.let(T.unsafe(nil), String)
+Rack::PUT = T.let(T.unsafe(nil), String)
+Rack::QUERY_STRING = T.let(T.unsafe(nil), String)
+
 class Rack::QueryParser
   def initialize(params_class, key_space_limit, param_depth_limit); end
 
@@ -31,14 +859,9 @@ class Rack::QueryParser
 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::InvalidParameterError < ::ArgumentError; end
+class Rack::QueryParser::ParameterTypeError < ::TypeError; end
 
 class Rack::QueryParser::Params
   def initialize(limit); end
@@ -50,8 +873,617 @@ class Rack::QueryParser::Params
   def to_params_hash; end
 end
 
-module Rack::Utils
+Rack::RACK_ERRORS = T.let(T.unsafe(nil), String)
+Rack::RACK_HIJACK = T.let(T.unsafe(nil), String)
+Rack::RACK_HIJACK_IO = T.let(T.unsafe(nil), String)
+Rack::RACK_INPUT = T.let(T.unsafe(nil), String)
+Rack::RACK_IS_HIJACK = T.let(T.unsafe(nil), String)
+Rack::RACK_LOGGER = T.let(T.unsafe(nil), String)
+Rack::RACK_METHODOVERRIDE_ORIGINAL_METHOD = T.let(T.unsafe(nil), String)
+Rack::RACK_MULTIPART_BUFFER_SIZE = T.let(T.unsafe(nil), String)
+Rack::RACK_MULTIPART_TEMPFILE_FACTORY = T.let(T.unsafe(nil), String)
+Rack::RACK_MULTIPROCESS = T.let(T.unsafe(nil), String)
+Rack::RACK_MULTITHREAD = T.let(T.unsafe(nil), String)
+Rack::RACK_RECURSIVE_INCLUDE = T.let(T.unsafe(nil), String)
+Rack::RACK_REQUEST_COOKIE_HASH = T.let(T.unsafe(nil), String)
+Rack::RACK_REQUEST_COOKIE_STRING = T.let(T.unsafe(nil), String)
+Rack::RACK_REQUEST_FORM_HASH = T.let(T.unsafe(nil), String)
+Rack::RACK_REQUEST_FORM_INPUT = T.let(T.unsafe(nil), String)
+Rack::RACK_REQUEST_FORM_VARS = T.let(T.unsafe(nil), String)
+Rack::RACK_REQUEST_QUERY_HASH = T.let(T.unsafe(nil), String)
+Rack::RACK_REQUEST_QUERY_STRING = T.let(T.unsafe(nil), String)
+Rack::RACK_RUNONCE = T.let(T.unsafe(nil), String)
+Rack::RACK_SESSION = T.let(T.unsafe(nil), String)
+Rack::RACK_SESSION_OPTIONS = T.let(T.unsafe(nil), String)
+Rack::RACK_SESSION_UNPACKED_COOKIE_DATA = T.let(T.unsafe(nil), String)
+Rack::RACK_SHOWSTATUS_DETAIL = T.let(T.unsafe(nil), String)
+Rack::RACK_TEMPFILES = T.let(T.unsafe(nil), String)
+Rack::RACK_URL_SCHEME = T.let(T.unsafe(nil), String)
+Rack::RACK_VERSION = T.let(T.unsafe(nil), String)
+Rack::RELEASE = T.let(T.unsafe(nil), String)
+Rack::REQUEST_METHOD = T.let(T.unsafe(nil), String)
+Rack::REQUEST_PATH = T.let(T.unsafe(nil), String)
 
+class Rack::Recursive
+  def initialize(app); end
+
+  def _call(env); end
+  def call(env); end
+  def include(env, path); end
+end
+
+class Rack::Reloader
+  def initialize(app, cooldown = T.unsafe(nil), backend = T.unsafe(nil)); end
+
+  def call(env); 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
+
+class Rack::Request
+  include ::Rack::Request::Env
+  include ::Rack::Request::Helpers
+
+  def initialize(env); end
+
+  def delete_param(k); end
+  def params; end
+  def update_param(k, v); end
+
+  class << self
+    def ip_filter; end
+    def ip_filter=(_arg0); end
+  end
+end
+
+Rack::Request::ALLOWED_SCHEMES = T.let(T.unsafe(nil), Array)
+
+module Rack::Request::Env
+  def initialize(env); end
+
+  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 set_header(name, v); end
+
+  private
+
+  def initialize_copy(other); end
+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
+
+  private
+
+  def allowed_scheme(header); end
+  def default_session; end
+  def extract_proto_header(header); end
+  def forwarded_scheme; end
+  def parse_http_accept_header(header); end
+  def parse_multipart; end
+  def parse_query(qs, d = T.unsafe(nil)); end
+  def query_parser; end
+  def reject_trusted_ip_addresses(ip_addresses); end
+  def split_authority(authority); end
+  def split_header(value); end
+  def wrap_ipv6(host); end
+end
+
+Rack::Request::Helpers::AUTHORITY = T.let(T.unsafe(nil), Regexp)
+Rack::Request::Helpers::DEFAULT_PORTS = T.let(T.unsafe(nil), Hash)
+Rack::Request::Helpers::FORM_DATA_MEDIA_TYPES = T.let(T.unsafe(nil), Array)
+Rack::Request::Helpers::HTTP_X_FORWARDED_FOR = T.let(T.unsafe(nil), String)
+Rack::Request::Helpers::HTTP_X_FORWARDED_HOST = T.let(T.unsafe(nil), String)
+Rack::Request::Helpers::HTTP_X_FORWARDED_PORT = T.let(T.unsafe(nil), String)
+Rack::Request::Helpers::HTTP_X_FORWARDED_PROTO = T.let(T.unsafe(nil), String)
+Rack::Request::Helpers::HTTP_X_FORWARDED_SCHEME = T.let(T.unsafe(nil), String)
+Rack::Request::Helpers::HTTP_X_FORWARDED_SSL = T.let(T.unsafe(nil), String)
+Rack::Request::Helpers::PARSEABLE_DATA_MEDIA_TYPES = T.let(T.unsafe(nil), Array)
+Rack::Request::SCHEME_WHITELIST = T.let(T.unsafe(nil), Array)
+
+class Rack::Response
+  include ::Rack::Response::Helpers
+
+  def initialize(body = T.unsafe(nil), status = T.unsafe(nil), headers = T.unsafe(nil)); end
+
+  def [](key); end
+  def []=(key, v); end
+  def body; end
+  def body=(_arg0); 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 length; end
+  def length=(_arg0); end
+  def redirect(target, status = T.unsafe(nil)); end
+  def set_header(key, v); end
+  def status; end
+  def status=(_arg0); end
+  def to_a(&block); end
+  def write(chunk); end
+
+  class << self
+    def [](status, headers, body); end
+  end
+end
+
+Rack::Response::CHUNKED = T.let(T.unsafe(nil), String)
+
+module Rack::Response::Helpers
+  def accepted?; end
+  def add_header(key, v); end
+  def bad_request?; 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
+
+  protected
+
+  def append(chunk); end
+  def buffered_body!; end
+end
+
+class Rack::Response::Raw
+  include ::Rack::Response::Helpers
+
+  def initialize(status, headers); end
+
+  def delete_header(key); end
+  def get_header(key); end
+  def has_header?(key); end
+  def headers; end
+  def set_header(key, v); end
+  def status; end
+  def status=(_arg0); end
+end
+
+Rack::Response::STATUS_WITH_NO_ENTITY_BODY = T.let(T.unsafe(nil), Hash)
+
+class Rack::RewindableInput
+  def initialize(io); end
+
+  def close; end
+  def each(&block); end
+  def gets; end
+  def read(*args); end
+  def rewind; end
+
+  private
+
+  def filesystem_has_posix_semantics?; end
+  def make_rewindable; end
+end
+
+class Rack::Runtime
+  def initialize(app, name = T.unsafe(nil)); end
+
+  def call(env); end
+end
+
+Rack::Runtime::FORMAT_STRING = T.let(T.unsafe(nil), String)
+Rack::Runtime::HEADER_NAME = T.let(T.unsafe(nil), String)
+Rack::SCRIPT_NAME = T.let(T.unsafe(nil), String)
+Rack::SERVER_NAME = T.let(T.unsafe(nil), String)
+Rack::SERVER_PORT = T.let(T.unsafe(nil), String)
+Rack::SERVER_PROTOCOL = T.let(T.unsafe(nil), String)
+Rack::SET_COOKIE = T.let(T.unsafe(nil), String)
+
+class Rack::Sendfile
+  def initialize(app, variation = T.unsafe(nil), mappings = T.unsafe(nil)); end
+
+  def call(env); end
+
+  private
+
+  def map_accel_path(env, path); end
+  def variation(env); end
+end
+
+class Rack::Server
+  def initialize(options = T.unsafe(nil)); end
+
+  def app; end
+  def default_options; end
+  def middleware; end
+  def options; end
+  def options=(_arg0); end
+  def server; end
+  def start(&block); end
+
+  private
+
+  def build_app(app); end
+  def build_app_and_options_from_config; end
+  def build_app_from_string; end
+  def check_pid!; end
+  def daemonize_app; end
+  def handle_profiling(heapfile, profile_mode, filename); end
+  def make_profile_name(filename); end
+  def opt_parser; end
+  def parse_options(args); end
+  def pidfile_process_status; end
+  def wrapped_app; end
+  def write_pid; end
+
+  class << self
+    def default_middleware_by_environment; end
+    def logging_middleware; end
+    def middleware; end
+    def start(options = T.unsafe(nil)); end
+  end
+end
+
+class Rack::Server::Options
+  def handler_opts(options); end
+  def parse!(args); end
+end
+
+module Rack::Session; end
+module Rack::Session::Abstract; end
+
+class Rack::Session::Abstract::ID < ::Rack::Session::Abstract::Persisted
+  def delete_session(req, sid, options); end
+  def find_session(req, sid); end
+  def write_session(req, sid, session, options); end
+
+  class << self
+    def inherited(klass); end
+  end
+end
+
+class Rack::Session::Abstract::Persisted
+  def initialize(app, options = T.unsafe(nil)); end
+
+  def call(env); end
+  def commit_session(req, res); end
+  def context(env, app = T.unsafe(nil)); end
+  def default_options; end
+  def key; end
+  def sid_secure; end
+
+  private
+
+  def commit_session?(req, session, options); end
+  def cookie_value(data); end
+  def current_session_id(req); end
+  def delete_session(req, sid, options); end
+  def extract_session_id(request); end
+  def find_session(env, sid); end
+  def force_options?(options); end
+  def forced_session_update?(session, options); end
+  def generate_sid(secure = T.unsafe(nil)); end
+  def initialize_sid; end
+  def load_session(req); end
+  def loaded_session?(session); end
+  def make_request(env); end
+  def prepare_session(req); end
+  def security_matches?(request, options); end
+  def session_class; end
+  def session_exists?(req); end
+  def set_cookie(request, res, cookie); end
+  def write_session(req, sid, session, options); end
+end
+
+Rack::Session::Abstract::Persisted::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+
+class Rack::Session::Abstract::PersistedSecure < ::Rack::Session::Abstract::Persisted
+  def extract_session_id(*_arg0); end
+  def generate_sid(*_arg0); end
+
+  private
+
+  def cookie_value(data); end
+  def session_class; end
+end
+
+class Rack::Session::Abstract::PersistedSecure::SecureSessionHash < ::Rack::Session::Abstract::SessionHash
+  def [](key); end
+end
+
+class Rack::Session::Abstract::SessionHash
+  include ::Enumerable
+
+  def initialize(store, req); end
+
+  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=(_arg0); end
+  def include?(key); end
+  def inspect; 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
+
+  private
+
+  def load!; end
+  def load_for_read!; end
+  def load_for_write!; end
+  def stringify_keys(other); end
+
+  class << self
+    def find(req); end
+    def set(req, session); end
+    def set_options(req, options); end
+  end
+end
+
+Rack::Session::Abstract::SessionHash::Unspecified = T.let(T.unsafe(nil), Object)
+
+class Rack::Session::Cookie < ::Rack::Session::Abstract::PersistedSecure
+  def initialize(app, options = T.unsafe(nil)); end
+
+  def coder; end
+
+  private
+
+  def delete_session(req, session_id, options); end
+  def digest_match?(data, digest); end
+  def extract_session_id(request); end
+  def find_session(req, sid); end
+  def generate_hmac(data, secret); end
+  def persistent_session_id!(data, sid = T.unsafe(nil)); end
+  def secure?(options); end
+  def unpacked_cookie_data(request); end
+  def write_session(req, session_id, session, options); end
+end
+
+class Rack::Session::Cookie::Base64
+  def decode(str); end
+  def encode(str); end
+end
+
+class Rack::Session::Cookie::Base64::JSON < ::Rack::Session::Cookie::Base64
+  def decode(str); end
+  def encode(obj); end
+end
+
+class Rack::Session::Cookie::Base64::Marshal < ::Rack::Session::Cookie::Base64
+  def decode(str); end
+  def encode(str); end
+end
+
+class Rack::Session::Cookie::Base64::ZipJSON < ::Rack::Session::Cookie::Base64
+  def decode(str); end
+  def encode(obj); end
+end
+
+class Rack::Session::Cookie::Identity
+  def decode(str); end
+  def encode(str); end
+end
+
+class Rack::Session::Cookie::SessionId
+  def initialize(session_id, cookie_value); end
+
+  def cookie_value; end
+end
+
+class Rack::Session::Pool < ::Rack::Session::Abstract::PersistedSecure
+  def initialize(app, options = T.unsafe(nil)); end
+
+  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
+
+  private
+
+  def get_session_with_fallback(sid); end
+end
+
+Rack::Session::Pool::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+
+class Rack::Session::SessionId
+  def initialize(public_id); end
+
+  def cookie_value; end
+  def empty?; end
+  def inspect; end
+  def private_id; end
+  def public_id; end
+  def to_s; end
+
+  private
+
+  def hash_sid(sid); end
+end
+
+Rack::Session::SessionId::ID_VERSION = T.let(T.unsafe(nil), Integer)
+
+class Rack::ShowExceptions
+  def initialize(app); end
+
+  def call(env); end
+  def dump_exception(exception); end
+  def h(obj); end
+  def prefers_plaintext?(env); end
+  def pretty(env, exception); end
+  def template; end
+
+  private
+
+  def accepts_html?(env); end
+end
+
+Rack::ShowExceptions::CONTEXT = T.let(T.unsafe(nil), Integer)
+Rack::ShowExceptions::TEMPLATE = T.let(T.unsafe(nil), ERB)
+
+class Rack::ShowStatus
+  def initialize(app); end
+
+  def call(env); end
+  def h(obj); end
+end
+
+Rack::ShowStatus::TEMPLATE = T.let(T.unsafe(nil), String)
+
+class Rack::Static
+  def initialize(app, options = T.unsafe(nil)); end
+
+  def add_index_root?(path); end
+  def applicable_rules(path); end
+  def call(env); end
+  def can_serve(path); end
+  def overwrite_file_path(path); end
+  def route_file(path); end
+end
+
+Rack::TRACE = T.let(T.unsafe(nil), String)
+Rack::TRANSFER_ENCODING = T.let(T.unsafe(nil), String)
+
+class Rack::TempfileReaper
+  def initialize(app); end
+
+  def call(env); end
+end
+
+Rack::UNLINK = T.let(T.unsafe(nil), String)
+
+class Rack::URLMap
+  def initialize(map = T.unsafe(nil)); end
+
+  def call(env); end
+  def remap(map); end
+
+  private
+
+  def casecmp?(v1, v2); end
+end
+
+module Rack::Utils
   private
 
   def add_cookie_to_header(header, key, value); end
@@ -136,11 +1568,8 @@ class Rack::Utils::Context
 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
@@ -174,15 +1603,16 @@ class Rack::Utils::HeaderHash < ::Hash
 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)
+Rack::VERSION = T.let(T.unsafe(nil), Array)
+
+class WEBrick::HTTPResponse
+  def rack; end
+  def rack=(_arg0); end
+  def setup_header; end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/rainbow@3.0.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rainbow@3.0.0.rbi
index 68324353c2..2f4615dcbb 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rainbow@3.0.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rainbow@3.0.0.rbi
@@ -1,6 +1,6 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `rainbow` gem.
-# Please instead update this file by running `tapioca generate --exclude json`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
@@ -59,7 +59,7 @@ class Rainbow::Color::RGB < ::Rainbow::Color::Indexed
 end
 
 class Rainbow::Color::X11Named < ::Rainbow::Color::RGB
-  include(::Rainbow::X11ColorNames)
+  include ::Rainbow::X11ColorNames
 
   def initialize(ground, name); end
 
@@ -145,11 +145,9 @@ class Rainbow::Wrapper
   def initialize(enabled = T.unsafe(nil)); end
 
   def enabled; end
-  def enabled=(_); end
+  def enabled=(_arg0); end
   def wrap(string); end
 end
 
-module Rainbow::X11ColorNames
-end
-
+module Rainbow::X11ColorNames; end
 Rainbow::X11ColorNames::NAMES = T.let(T.unsafe(nil), Hash)
diff --git a/Library/Homebrew/sorbet/rbi/gems/rdiscount@2.2.0.2.rbi b/Library/Homebrew/sorbet/rbi/gems/rdiscount@2.2.0.2.rbi
index c6bb522c19..9be6193b29 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rdiscount@2.2.0.2.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rdiscount@2.2.0.2.rbi
@@ -1,7 +1,47 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `rdiscount` gem.
-# Please instead update this file by running `tapioca sync --exclude json`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
+Markdown = RDiscount
 
+class RDiscount
+  def initialize(text, *extensions); end
+
+  def autolink; end
+  def autolink=(_arg0); end
+  def filter_html; end
+  def filter_html=(_arg0); end
+  def filter_styles; end
+  def filter_styles=(_arg0); end
+  def fold_lines; end
+  def fold_lines=(_arg0); end
+  def footnotes; end
+  def footnotes=(_arg0); end
+  def generate_toc; end
+  def generate_toc=(_arg0); end
+  def no_image; end
+  def no_image=(_arg0); end
+  def no_links; end
+  def no_links=(_arg0); end
+  def no_pseudo_protocols; end
+  def no_pseudo_protocols=(_arg0); end
+  def no_strikethrough; end
+  def no_strikethrough=(_arg0); end
+  def no_superscript; end
+  def no_superscript=(_arg0); end
+  def no_tables; end
+  def no_tables=(_arg0); end
+  def safelink; end
+  def safelink=(_arg0); end
+  def smart; end
+  def smart=(_arg0); end
+  def strict; end
+  def strict=(_arg0); end
+  def text; end
+  def to_html(*_arg0); end
+  def toc_content(*_arg0); end
+end
+
+RDiscount::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/regexp_parser@2.1.1.rbi b/Library/Homebrew/sorbet/rbi/gems/regexp_parser@2.1.1.rbi
index 2fa7ded968..53f258c9cd 100644
--- a/Library/Homebrew/sorbet/rbi/gems/regexp_parser@2.1.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/regexp_parser@2.1.1.rbi
@@ -1,11 +1,10 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `regexp_parser` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-module Regexp::Expression
-end
+module Regexp::Expression; end
 
 class Regexp::Expression::Alternation < ::Regexp::Expression::SequenceOperation
   def alternatives; end
@@ -13,72 +12,37 @@ class Regexp::Expression::Alternation < ::Regexp::Expression::SequenceOperation
 end
 
 Regexp::Expression::Alternation::OPERAND = Regexp::Expression::Alternative
-
-class Regexp::Expression::Alternative < ::Regexp::Expression::Sequence
-end
-
-module Regexp::Expression::Anchor
-end
-
+class Regexp::Expression::Alternative < ::Regexp::Expression::Sequence; end
+module Regexp::Expression::Anchor; end
 Regexp::Expression::Anchor::BOL = Regexp::Expression::Anchor::BeginningOfLine
-
 Regexp::Expression::Anchor::BOS = Regexp::Expression::Anchor::BeginningOfString
 
 class Regexp::Expression::Anchor::Base < ::Regexp::Expression::Base
   def match_length; end
 end
 
-class Regexp::Expression::Anchor::BeginningOfLine < ::Regexp::Expression::Anchor::Base
-end
-
-class Regexp::Expression::Anchor::BeginningOfString < ::Regexp::Expression::Anchor::Base
-end
-
+class Regexp::Expression::Anchor::BeginningOfLine < ::Regexp::Expression::Anchor::Base; end
+class Regexp::Expression::Anchor::BeginningOfString < ::Regexp::Expression::Anchor::Base; end
 Regexp::Expression::Anchor::EOL = Regexp::Expression::Anchor::EndOfLine
-
 Regexp::Expression::Anchor::EOS = Regexp::Expression::Anchor::EndOfString
-
 Regexp::Expression::Anchor::EOSobEOL = Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine
-
-class Regexp::Expression::Anchor::EndOfLine < ::Regexp::Expression::Anchor::Base
-end
-
-class Regexp::Expression::Anchor::EndOfString < ::Regexp::Expression::Anchor::Base
-end
-
-class Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine < ::Regexp::Expression::Anchor::Base
-end
-
-class Regexp::Expression::Anchor::MatchStart < ::Regexp::Expression::Anchor::Base
-end
-
-class Regexp::Expression::Anchor::NonWordBoundary < ::Regexp::Expression::Anchor::Base
-end
-
-class Regexp::Expression::Anchor::WordBoundary < ::Regexp::Expression::Anchor::Base
-end
-
-module Regexp::Expression::Assertion
-end
+class Regexp::Expression::Anchor::EndOfLine < ::Regexp::Expression::Anchor::Base; end
+class Regexp::Expression::Anchor::EndOfString < ::Regexp::Expression::Anchor::Base; end
+class Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine < ::Regexp::Expression::Anchor::Base; end
+class Regexp::Expression::Anchor::MatchStart < ::Regexp::Expression::Anchor::Base; end
+class Regexp::Expression::Anchor::NonWordBoundary < ::Regexp::Expression::Anchor::Base; end
+class Regexp::Expression::Anchor::WordBoundary < ::Regexp::Expression::Anchor::Base; end
+module Regexp::Expression::Assertion; end
 
 class Regexp::Expression::Assertion::Base < ::Regexp::Expression::Group::Base
   def match_length; end
 end
 
-class Regexp::Expression::Assertion::Lookahead < ::Regexp::Expression::Assertion::Base
-end
-
-class Regexp::Expression::Assertion::Lookbehind < ::Regexp::Expression::Assertion::Base
-end
-
-class Regexp::Expression::Assertion::NegativeLookahead < ::Regexp::Expression::Assertion::Base
-end
-
-class Regexp::Expression::Assertion::NegativeLookbehind < ::Regexp::Expression::Assertion::Base
-end
-
-module Regexp::Expression::Backreference
-end
+class Regexp::Expression::Assertion::Lookahead < ::Regexp::Expression::Assertion::Base; end
+class Regexp::Expression::Assertion::Lookbehind < ::Regexp::Expression::Assertion::Base; end
+class Regexp::Expression::Assertion::NegativeLookahead < ::Regexp::Expression::Assertion::Base; end
+class Regexp::Expression::Assertion::NegativeLookbehind < ::Regexp::Expression::Assertion::Base; end
+module Regexp::Expression::Backreference; end
 
 class Regexp::Expression::Backreference::Base < ::Regexp::Expression::Base
   def match_length; end
@@ -97,8 +61,7 @@ class Regexp::Expression::Backreference::Name < ::Regexp::Expression::Backrefere
   def reference; end
 end
 
-class Regexp::Expression::Backreference::NameCall < ::Regexp::Expression::Backreference::Name
-end
+class Regexp::Expression::Backreference::NameCall < ::Regexp::Expression::Backreference::Name; end
 
 class Regexp::Expression::Backreference::NameRecursionLevel < ::Regexp::Expression::Backreference::Name
   def initialize(token, options = T.unsafe(nil)); end
@@ -113,11 +76,8 @@ class Regexp::Expression::Backreference::Number < ::Regexp::Expression::Backrefe
   def reference; end
 end
 
-class Regexp::Expression::Backreference::NumberCall < ::Regexp::Expression::Backreference::Number
-end
-
-class Regexp::Expression::Backreference::NumberCallRelative < ::Regexp::Expression::Backreference::NumberRelative
-end
+class Regexp::Expression::Backreference::NumberCall < ::Regexp::Expression::Backreference::Number; end
+class Regexp::Expression::Backreference::NumberCallRelative < ::Regexp::Expression::Backreference::NumberRelative; end
 
 class Regexp::Expression::Backreference::NumberRecursionLevel < ::Regexp::Expression::Backreference::Number
   def initialize(token, options = T.unsafe(nil)); end
@@ -132,7 +92,7 @@ class Regexp::Expression::Backreference::NumberRelative < ::Regexp::Expression::
 end
 
 class Regexp::Expression::Base
-  include(::RuboCop::Ext::RegexpParser::Expression::Base)
+  include ::RuboCop::Ext::RegexpParser::Expression::Base
 
   def initialize(token, options = T.unsafe(nil)); end
 
@@ -206,7 +166,7 @@ class Regexp::Expression::Base
 end
 
 class Regexp::Expression::CharacterSet < ::Regexp::Expression::Subexpression
-  include(::RuboCop::Ext::RegexpParser::Expression::CharacterSet)
+  include ::RuboCop::Ext::RegexpParser::Expression::CharacterSet
 
   def initialize(token, options = T.unsafe(nil)); end
 
@@ -242,54 +202,26 @@ class Regexp::Expression::CharacterSet::Range < ::Regexp::Expression::Subexpress
   def ts; end
 end
 
-module Regexp::Expression::CharacterType
-end
-
-class Regexp::Expression::CharacterType::Any < ::Regexp::Expression::CharacterType::Base
-end
+module Regexp::Expression::CharacterType; end
+class Regexp::Expression::CharacterType::Any < ::Regexp::Expression::CharacterType::Base; end
 
 class Regexp::Expression::CharacterType::Base < ::Regexp::Expression::Base
   def match_length; end
 end
 
-class Regexp::Expression::CharacterType::Digit < ::Regexp::Expression::CharacterType::Base
-end
-
-class Regexp::Expression::CharacterType::ExtendedGrapheme < ::Regexp::Expression::CharacterType::Base
-end
-
-class Regexp::Expression::CharacterType::Hex < ::Regexp::Expression::CharacterType::Base
-end
-
-class Regexp::Expression::CharacterType::Linebreak < ::Regexp::Expression::CharacterType::Base
-end
-
-class Regexp::Expression::CharacterType::NonDigit < ::Regexp::Expression::CharacterType::Base
-end
-
-class Regexp::Expression::CharacterType::NonHex < ::Regexp::Expression::CharacterType::Base
-end
-
-class Regexp::Expression::CharacterType::NonSpace < ::Regexp::Expression::CharacterType::Base
-end
-
-class Regexp::Expression::CharacterType::NonWord < ::Regexp::Expression::CharacterType::Base
-end
-
-class Regexp::Expression::CharacterType::Space < ::Regexp::Expression::CharacterType::Base
-end
-
-class Regexp::Expression::CharacterType::Word < ::Regexp::Expression::CharacterType::Base
-end
-
-class Regexp::Expression::Comment < ::Regexp::Expression::FreeSpace
-end
-
-module Regexp::Expression::Conditional
-end
-
-class Regexp::Expression::Conditional::Branch < ::Regexp::Expression::Sequence
-end
+class Regexp::Expression::CharacterType::Digit < ::Regexp::Expression::CharacterType::Base; end
+class Regexp::Expression::CharacterType::ExtendedGrapheme < ::Regexp::Expression::CharacterType::Base; end
+class Regexp::Expression::CharacterType::Hex < ::Regexp::Expression::CharacterType::Base; end
+class Regexp::Expression::CharacterType::Linebreak < ::Regexp::Expression::CharacterType::Base; end
+class Regexp::Expression::CharacterType::NonDigit < ::Regexp::Expression::CharacterType::Base; end
+class Regexp::Expression::CharacterType::NonHex < ::Regexp::Expression::CharacterType::Base; end
+class Regexp::Expression::CharacterType::NonSpace < ::Regexp::Expression::CharacterType::Base; end
+class Regexp::Expression::CharacterType::NonWord < ::Regexp::Expression::CharacterType::Base; end
+class Regexp::Expression::CharacterType::Space < ::Regexp::Expression::CharacterType::Base; end
+class Regexp::Expression::CharacterType::Word < ::Regexp::Expression::CharacterType::Base; end
+class Regexp::Expression::Comment < ::Regexp::Expression::FreeSpace; end
+module Regexp::Expression::Conditional; end
+class Regexp::Expression::Conditional::Branch < ::Regexp::Expression::Sequence; end
 
 class Regexp::Expression::Conditional::Condition < ::Regexp::Expression::Base
   def match_length; end
@@ -324,8 +256,7 @@ class Regexp::Expression::Conditional::TooManyBranches < ::Regexp::Parser::Error
   def initialize; end
 end
 
-module Regexp::Expression::EscapeSequence
-end
+module Regexp::Expression::EscapeSequence; end
 
 class Regexp::Expression::EscapeSequence::AbstractMetaControlSequence < ::Regexp::Expression::EscapeSequence::Base
   def char; end
@@ -336,11 +267,8 @@ class Regexp::Expression::EscapeSequence::AbstractMetaControlSequence < ::Regexp
   def meta_char_to_codepoint(meta_char); end
 end
 
-class Regexp::Expression::EscapeSequence::AsciiEscape < ::Regexp::Expression::EscapeSequence::Base
-end
-
-class Regexp::Expression::EscapeSequence::Backspace < ::Regexp::Expression::EscapeSequence::Base
-end
+class Regexp::Expression::EscapeSequence::AsciiEscape < ::Regexp::Expression::EscapeSequence::Base; end
+class Regexp::Expression::EscapeSequence::Backspace < ::Regexp::Expression::EscapeSequence::Base; end
 
 class Regexp::Expression::EscapeSequence::Base < ::Regexp::Expression::Base
   def char; end
@@ -348,11 +276,8 @@ class Regexp::Expression::EscapeSequence::Base < ::Regexp::Expression::Base
   def match_length; end
 end
 
-class Regexp::Expression::EscapeSequence::Bell < ::Regexp::Expression::EscapeSequence::Base
-end
-
-class Regexp::Expression::EscapeSequence::Codepoint < ::Regexp::Expression::EscapeSequence::Base
-end
+class Regexp::Expression::EscapeSequence::Bell < ::Regexp::Expression::EscapeSequence::Base; end
+class Regexp::Expression::EscapeSequence::Codepoint < ::Regexp::Expression::EscapeSequence::Base; end
 
 class Regexp::Expression::EscapeSequence::CodepointList < ::Regexp::Expression::EscapeSequence::Base
   def char; end
@@ -366,11 +291,8 @@ class Regexp::Expression::EscapeSequence::Control < ::Regexp::Expression::Escape
   def codepoint; end
 end
 
-class Regexp::Expression::EscapeSequence::FormFeed < ::Regexp::Expression::EscapeSequence::Base
-end
-
-class Regexp::Expression::EscapeSequence::Hex < ::Regexp::Expression::EscapeSequence::Base
-end
+class Regexp::Expression::EscapeSequence::FormFeed < ::Regexp::Expression::EscapeSequence::Base; end
+class Regexp::Expression::EscapeSequence::Hex < ::Regexp::Expression::EscapeSequence::Base; end
 
 class Regexp::Expression::EscapeSequence::Literal < ::Regexp::Expression::EscapeSequence::Base
   def char; end
@@ -384,36 +306,28 @@ class Regexp::Expression::EscapeSequence::MetaControl < ::Regexp::Expression::Es
   def codepoint; end
 end
 
-class Regexp::Expression::EscapeSequence::Newline < ::Regexp::Expression::EscapeSequence::Base
-end
+class Regexp::Expression::EscapeSequence::Newline < ::Regexp::Expression::EscapeSequence::Base; end
 
 class Regexp::Expression::EscapeSequence::Octal < ::Regexp::Expression::EscapeSequence::Base
   def char; end
 end
 
-class Regexp::Expression::EscapeSequence::Return < ::Regexp::Expression::EscapeSequence::Base
-end
-
-class Regexp::Expression::EscapeSequence::Tab < ::Regexp::Expression::EscapeSequence::Base
-end
-
-class Regexp::Expression::EscapeSequence::VerticalTab < ::Regexp::Expression::EscapeSequence::Base
-end
+class Regexp::Expression::EscapeSequence::Return < ::Regexp::Expression::EscapeSequence::Base; end
+class Regexp::Expression::EscapeSequence::Tab < ::Regexp::Expression::EscapeSequence::Base; end
+class Regexp::Expression::EscapeSequence::VerticalTab < ::Regexp::Expression::EscapeSequence::Base; end
 
 class Regexp::Expression::FreeSpace < ::Regexp::Expression::Base
   def match_length; end
   def quantify(_token, _text, _min = T.unsafe(nil), _max = T.unsafe(nil), _mode = T.unsafe(nil)); end
 end
 
-module Regexp::Expression::Group
-end
+module Regexp::Expression::Group; end
 
 class Regexp::Expression::Group::Absence < ::Regexp::Expression::Group::Base
   def match_length; end
 end
 
-class Regexp::Expression::Group::Atomic < ::Regexp::Expression::Group::Base
-end
+class Regexp::Expression::Group::Atomic < ::Regexp::Expression::Group::Base; end
 
 class Regexp::Expression::Group::Base < ::Regexp::Expression::Subexpression
   def capturing?; end
@@ -463,8 +377,7 @@ class Regexp::Expression::Group::Passive < ::Regexp::Expression::Group::Base
   def to_s(format = T.unsafe(nil)); end
 end
 
-module Regexp::Expression::Keep
-end
+module Regexp::Expression::Keep; end
 
 class Regexp::Expression::Keep::Mark < ::Regexp::Expression::Base
   def match_length; end
@@ -537,7 +450,7 @@ class Regexp::Expression::SequenceOperation < ::Regexp::Expression::Subexpressio
 end
 
 class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
-  include(::Enumerable)
+  include ::Enumerable
 
   def initialize(token, options = T.unsafe(nil)); end
 
@@ -572,26 +485,13 @@ class Regexp::Expression::Subexpression < ::Regexp::Expression::Base
   def initialize_copy(orig); end
 end
 
-module Regexp::Expression::UnicodeProperty
-end
-
-class Regexp::Expression::UnicodeProperty::Age < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Alnum < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Alpha < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Any < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Ascii < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Assigned < ::Regexp::Expression::UnicodeProperty::Base
-end
+module Regexp::Expression::UnicodeProperty; end
+class Regexp::Expression::UnicodeProperty::Age < ::Regexp::Expression::UnicodeProperty::Base; end
+class Regexp::Expression::UnicodeProperty::Alnum < ::Regexp::Expression::UnicodeProperty::Base; end
+class Regexp::Expression::UnicodeProperty::Alpha < ::Regexp::Expression::UnicodeProperty::Base; end
+class Regexp::Expression::UnicodeProperty::Any < ::Regexp::Expression::UnicodeProperty::Base; end
+class Regexp::Expression::UnicodeProperty::Ascii < ::Regexp::Expression::UnicodeProperty::Base; end
+class Regexp::Expression::UnicodeProperty::Assigned < ::Regexp::Expression::UnicodeProperty::Base; end
 
 class Regexp::Expression::UnicodeProperty::Base < ::Regexp::Expression::Base
   def match_length; end
@@ -600,215 +500,76 @@ class Regexp::Expression::UnicodeProperty::Base < ::Regexp::Expression::Base
   def shortcut; end
 end
 
-class Regexp::Expression::UnicodeProperty::Blank < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Block < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Cntrl < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-module Regexp::Expression::UnicodeProperty::Codepoint
-end
-
-class Regexp::Expression::UnicodeProperty::Codepoint::Any < ::Regexp::Expression::UnicodeProperty::Codepoint::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Codepoint::Base < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Codepoint::Control < ::Regexp::Expression::UnicodeProperty::Codepoint::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Codepoint::Format < ::Regexp::Expression::UnicodeProperty::Codepoint::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Codepoint::PrivateUse < ::Regexp::Expression::UnicodeProperty::Codepoint::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Codepoint::Surrogate < ::Regexp::Expression::UnicodeProperty::Codepoint::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Codepoint::Unassigned < ::Regexp::Expression::UnicodeProperty::Codepoint::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Derived < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Digit < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Emoji < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Graph < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-module Regexp::Expression::UnicodeProperty::Letter
-end
-
-class Regexp::Expression::UnicodeProperty::Letter::Any < ::Regexp::Expression::UnicodeProperty::Letter::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Letter::Base < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Letter::Cased < ::Regexp::Expression::UnicodeProperty::Letter::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Letter::Lowercase < ::Regexp::Expression::UnicodeProperty::Letter::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Letter::Modifier < ::Regexp::Expression::UnicodeProperty::Letter::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Letter::Other < ::Regexp::Expression::UnicodeProperty::Letter::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Letter::Titlecase < ::Regexp::Expression::UnicodeProperty::Letter::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Letter::Uppercase < ::Regexp::Expression::UnicodeProperty::Letter::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Lower < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-module Regexp::Expression::UnicodeProperty::Mark
-end
-
-class Regexp::Expression::UnicodeProperty::Mark::Any < ::Regexp::Expression::UnicodeProperty::Mark::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Mark::Base < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Mark::Combining < ::Regexp::Expression::UnicodeProperty::Mark::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Mark::Enclosing < ::Regexp::Expression::UnicodeProperty::Mark::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Mark::Nonspacing < ::Regexp::Expression::UnicodeProperty::Mark::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Mark::Spacing < ::Regexp::Expression::UnicodeProperty::Mark::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Newline < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-module Regexp::Expression::UnicodeProperty::Number
-end
-
-class Regexp::Expression::UnicodeProperty::Number::Any < ::Regexp::Expression::UnicodeProperty::Number::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Number::Base < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Number::Decimal < ::Regexp::Expression::UnicodeProperty::Number::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Number::Letter < ::Regexp::Expression::UnicodeProperty::Number::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Number::Other < ::Regexp::Expression::UnicodeProperty::Number::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Print < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Punct < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-module Regexp::Expression::UnicodeProperty::Punctuation
-end
-
-class Regexp::Expression::UnicodeProperty::Punctuation::Any < ::Regexp::Expression::UnicodeProperty::Punctuation::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Punctuation::Base < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Punctuation::Close < ::Regexp::Expression::UnicodeProperty::Punctuation::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Punctuation::Connector < ::Regexp::Expression::UnicodeProperty::Punctuation::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Punctuation::Dash < ::Regexp::Expression::UnicodeProperty::Punctuation::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Punctuation::Final < ::Regexp::Expression::UnicodeProperty::Punctuation::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Punctuation::Initial < ::Regexp::Expression::UnicodeProperty::Punctuation::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Punctuation::Open < ::Regexp::Expression::UnicodeProperty::Punctuation::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Punctuation::Other < ::Regexp::Expression::UnicodeProperty::Punctuation::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Script < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-module Regexp::Expression::UnicodeProperty::Separator
-end
-
-class Regexp::Expression::UnicodeProperty::Separator::Any < ::Regexp::Expression::UnicodeProperty::Separator::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Separator::Base < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Separator::Line < ::Regexp::Expression::UnicodeProperty::Separator::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Separator::Paragraph < ::Regexp::Expression::UnicodeProperty::Separator::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Separator::Space < ::Regexp::Expression::UnicodeProperty::Separator::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Space < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-module Regexp::Expression::UnicodeProperty::Symbol
-end
-
-class Regexp::Expression::UnicodeProperty::Symbol::Any < ::Regexp::Expression::UnicodeProperty::Symbol::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Symbol::Base < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Symbol::Currency < ::Regexp::Expression::UnicodeProperty::Symbol::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Symbol::Math < ::Regexp::Expression::UnicodeProperty::Symbol::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Symbol::Modifier < ::Regexp::Expression::UnicodeProperty::Symbol::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Symbol::Other < ::Regexp::Expression::UnicodeProperty::Symbol::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Upper < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Word < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-class Regexp::Expression::UnicodeProperty::XPosixPunct < ::Regexp::Expression::UnicodeProperty::Base
-end
-
-class Regexp::Expression::UnicodeProperty::Xdigit < ::Regexp::Expression::UnicodeProperty::Base
-end
+class Regexp::Expression::UnicodeProperty::Blank < ::Regexp::Expression::UnicodeProperty::Base; end
+class Regexp::Expression::UnicodeProperty::Block < ::Regexp::Expression::UnicodeProperty::Base; end
+class Regexp::Expression::UnicodeProperty::Cntrl < ::Regexp::Expression::UnicodeProperty::Base; end
+module Regexp::Expression::UnicodeProperty::Codepoint; end
+class Regexp::Expression::UnicodeProperty::Codepoint::Any < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
+class Regexp::Expression::UnicodeProperty::Codepoint::Base < ::Regexp::Expression::UnicodeProperty::Base; end
+class Regexp::Expression::UnicodeProperty::Codepoint::Control < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
+class Regexp::Expression::UnicodeProperty::Codepoint::Format < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
+class Regexp::Expression::UnicodeProperty::Codepoint::PrivateUse < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
+class Regexp::Expression::UnicodeProperty::Codepoint::Surrogate < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
+class Regexp::Expression::UnicodeProperty::Codepoint::Unassigned < ::Regexp::Expression::UnicodeProperty::Codepoint::Base; end
+class Regexp::Expression::UnicodeProperty::Derived < ::Regexp::Expression::UnicodeProperty::Base; end
+class Regexp::Expression::UnicodeProperty::Digit < ::Regexp::Expression::UnicodeProperty::Base; end
+class Regexp::Expression::UnicodeProperty::Emoji < ::Regexp::Expression::UnicodeProperty::Base; end
+class Regexp::Expression::UnicodeProperty::Graph < ::Regexp::Expression::UnicodeProperty::Base; end
+module Regexp::Expression::UnicodeProperty::Letter; end
+class Regexp::Expression::UnicodeProperty::Letter::Any < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
+class Regexp::Expression::UnicodeProperty::Letter::Base < ::Regexp::Expression::UnicodeProperty::Base; end
+class Regexp::Expression::UnicodeProperty::Letter::Cased < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
+class Regexp::Expression::UnicodeProperty::Letter::Lowercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
+class Regexp::Expression::UnicodeProperty::Letter::Modifier < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
+class Regexp::Expression::UnicodeProperty::Letter::Other < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
+class Regexp::Expression::UnicodeProperty::Letter::Titlecase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
+class Regexp::Expression::UnicodeProperty::Letter::Uppercase < ::Regexp::Expression::UnicodeProperty::Letter::Base; end
+class Regexp::Expression::UnicodeProperty::Lower < ::Regexp::Expression::UnicodeProperty::Base; end
+module Regexp::Expression::UnicodeProperty::Mark; end
+class Regexp::Expression::UnicodeProperty::Mark::Any < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
+class Regexp::Expression::UnicodeProperty::Mark::Base < ::Regexp::Expression::UnicodeProperty::Base; end
+class Regexp::Expression::UnicodeProperty::Mark::Combining < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
+class Regexp::Expression::UnicodeProperty::Mark::Enclosing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
+class Regexp::Expression::UnicodeProperty::Mark::Nonspacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
+class Regexp::Expression::UnicodeProperty::Mark::Spacing < ::Regexp::Expression::UnicodeProperty::Mark::Base; end
+class Regexp::Expression::UnicodeProperty::Newline < ::Regexp::Expression::UnicodeProperty::Base; end
+module Regexp::Expression::UnicodeProperty::Number; end
+class Regexp::Expression::UnicodeProperty::Number::Any < ::Regexp::Expression::UnicodeProperty::Number::Base; end
+class Regexp::Expression::UnicodeProperty::Number::Base < ::Regexp::Expression::UnicodeProperty::Base; end
+class Regexp::Expression::UnicodeProperty::Number::Decimal < ::Regexp::Expression::UnicodeProperty::Number::Base; end
+class Regexp::Expression::UnicodeProperty::Number::Letter < ::Regexp::Expression::UnicodeProperty::Number::Base; end
+class Regexp::Expression::UnicodeProperty::Number::Other < ::Regexp::Expression::UnicodeProperty::Number::Base; end
+class Regexp::Expression::UnicodeProperty::Print < ::Regexp::Expression::UnicodeProperty::Base; end
+class Regexp::Expression::UnicodeProperty::Punct < ::Regexp::Expression::UnicodeProperty::Base; end
+module Regexp::Expression::UnicodeProperty::Punctuation; end
+class Regexp::Expression::UnicodeProperty::Punctuation::Any < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+class Regexp::Expression::UnicodeProperty::Punctuation::Base < ::Regexp::Expression::UnicodeProperty::Base; end
+class Regexp::Expression::UnicodeProperty::Punctuation::Close < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+class Regexp::Expression::UnicodeProperty::Punctuation::Connector < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+class Regexp::Expression::UnicodeProperty::Punctuation::Dash < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+class Regexp::Expression::UnicodeProperty::Punctuation::Final < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+class Regexp::Expression::UnicodeProperty::Punctuation::Initial < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+class Regexp::Expression::UnicodeProperty::Punctuation::Open < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+class Regexp::Expression::UnicodeProperty::Punctuation::Other < ::Regexp::Expression::UnicodeProperty::Punctuation::Base; end
+class Regexp::Expression::UnicodeProperty::Script < ::Regexp::Expression::UnicodeProperty::Base; end
+module Regexp::Expression::UnicodeProperty::Separator; end
+class Regexp::Expression::UnicodeProperty::Separator::Any < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
+class Regexp::Expression::UnicodeProperty::Separator::Base < ::Regexp::Expression::UnicodeProperty::Base; end
+class Regexp::Expression::UnicodeProperty::Separator::Line < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
+class Regexp::Expression::UnicodeProperty::Separator::Paragraph < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
+class Regexp::Expression::UnicodeProperty::Separator::Space < ::Regexp::Expression::UnicodeProperty::Separator::Base; end
+class Regexp::Expression::UnicodeProperty::Space < ::Regexp::Expression::UnicodeProperty::Base; end
+module Regexp::Expression::UnicodeProperty::Symbol; end
+class Regexp::Expression::UnicodeProperty::Symbol::Any < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
+class Regexp::Expression::UnicodeProperty::Symbol::Base < ::Regexp::Expression::UnicodeProperty::Base; end
+class Regexp::Expression::UnicodeProperty::Symbol::Currency < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
+class Regexp::Expression::UnicodeProperty::Symbol::Math < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
+class Regexp::Expression::UnicodeProperty::Symbol::Modifier < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
+class Regexp::Expression::UnicodeProperty::Symbol::Other < ::Regexp::Expression::UnicodeProperty::Symbol::Base; end
+class Regexp::Expression::UnicodeProperty::Upper < ::Regexp::Expression::UnicodeProperty::Base; end
+class Regexp::Expression::UnicodeProperty::Word < ::Regexp::Expression::UnicodeProperty::Base; end
+class Regexp::Expression::UnicodeProperty::XPosixPunct < ::Regexp::Expression::UnicodeProperty::Base; end
+class Regexp::Expression::UnicodeProperty::Xdigit < ::Regexp::Expression::UnicodeProperty::Base; end
 
 class Regexp::Expression::WhiteSpace < ::Regexp::Expression::FreeSpace
   def merge(exp); end
@@ -842,11 +603,10 @@ class Regexp::Lexer
 end
 
 Regexp::Lexer::CLOSING_TOKENS = T.let(T.unsafe(nil), Array)
-
 Regexp::Lexer::OPENING_TOKENS = T.let(T.unsafe(nil), Array)
 
 class Regexp::MatchLength
-  include(::Enumerable)
+  include ::Enumerable
 
   def initialize(exp, opts = T.unsafe(nil)); end
 
@@ -882,8 +642,8 @@ class Regexp::MatchLength
 end
 
 class Regexp::Parser
-  include(::Regexp::Expression)
-  include(::Regexp::Expression::UnicodeProperty)
+  include ::Regexp::Expression
+  include ::Regexp::Expression::UnicodeProperty
 
   def parse(input, syntax = T.unsafe(nil), options: T.unsafe(nil), &block); end
 
@@ -948,15 +708,9 @@ class Regexp::Parser
 end
 
 Regexp::Parser::ENC_FLAGS = T.let(T.unsafe(nil), Array)
-
-class Regexp::Parser::Error < ::StandardError
-end
-
+class Regexp::Parser::Error < ::StandardError; end
 Regexp::Parser::MOD_FLAGS = T.let(T.unsafe(nil), Array)
-
-class Regexp::Parser::ParserError < ::Regexp::Parser::Error
-end
-
+class Regexp::Parser::ParserError < ::Regexp::Parser::Error; end
 Regexp::Parser::UPTokens = Regexp::Syntax::Token::UnicodeProperty
 
 class Regexp::Parser::UnknownTokenError < ::Regexp::Parser::ParserError
@@ -1030,8 +784,7 @@ class Regexp::Scanner::PrematureEndError < ::Regexp::Scanner::ScannerError
   def initialize(where = T.unsafe(nil)); end
 end
 
-class Regexp::Scanner::ScannerError < ::Regexp::Parser::Error
-end
+class Regexp::Scanner::ScannerError < ::Regexp::Parser::Error; end
 
 class Regexp::Scanner::UnknownUnicodePropertyError < ::Regexp::Scanner::ValidationError
   def initialize(name); end
@@ -1042,7 +795,6 @@ class Regexp::Scanner::ValidationError < ::Regexp::Parser::Error
 end
 
 module Regexp::Syntax
-
   private
 
   def comparable_version(name); end
@@ -1078,7 +830,7 @@ class Regexp::Syntax::Any < ::Regexp::Syntax::Base
 end
 
 class Regexp::Syntax::Base
-  include(::Regexp::Syntax::Token)
+  include ::Regexp::Syntax::Token
 
   def initialize; end
 
@@ -1107,341 +859,164 @@ class Regexp::Syntax::NotImplementedError < ::Regexp::Syntax::SyntaxError
   def initialize(syntax, type, token); end
 end
 
-class Regexp::Syntax::SyntaxError < ::Regexp::Parser::Error
-end
-
-module Regexp::Syntax::Token
-end
-
+class Regexp::Syntax::SyntaxError < ::Regexp::Parser::Error; end
+module Regexp::Syntax::Token; end
 Regexp::Syntax::Token::All = T.let(T.unsafe(nil), Array)
-
-module Regexp::Syntax::Token::Anchor
-end
-
+module Regexp::Syntax::Token::Anchor; end
 Regexp::Syntax::Token::Anchor::All = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Anchor::Basic = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Anchor::Extended = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Anchor::MatchStart = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Anchor::String = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Anchor::Type = T.let(T.unsafe(nil), Symbol)
-
-module Regexp::Syntax::Token::Assertion
-end
-
+module Regexp::Syntax::Token::Assertion; end
 Regexp::Syntax::Token::Assertion::All = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Assertion::Lookahead = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Assertion::Lookbehind = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Assertion::Type = T.let(T.unsafe(nil), Symbol)
-
-module Regexp::Syntax::Token::Backreference
-end
-
+module Regexp::Syntax::Token::Backreference; end
 Regexp::Syntax::Token::Backreference::All = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Backreference::Name = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Backreference::Number = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Backreference::RecursionLevel = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Backreference::Type = T.let(T.unsafe(nil), Symbol)
-
-module Regexp::Syntax::Token::CharacterSet
-end
-
+module Regexp::Syntax::Token::CharacterSet; end
 Regexp::Syntax::Token::CharacterSet::All = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::CharacterSet::Basic = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::CharacterSet::Extended = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::CharacterSet::Type = T.let(T.unsafe(nil), Symbol)
-
-module Regexp::Syntax::Token::CharacterType
-end
-
+module Regexp::Syntax::Token::CharacterType; end
 Regexp::Syntax::Token::CharacterType::All = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::CharacterType::Basic = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::CharacterType::Clustered = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::CharacterType::Extended = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::CharacterType::Hex = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::CharacterType::Type = T.let(T.unsafe(nil), Symbol)
-
-module Regexp::Syntax::Token::Conditional
-end
-
+module Regexp::Syntax::Token::Conditional; end
 Regexp::Syntax::Token::Conditional::All = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Conditional::Condition = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Conditional::Delimiters = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Conditional::Separator = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Conditional::Type = T.let(T.unsafe(nil), Symbol)
-
-module Regexp::Syntax::Token::Escape
-end
-
+module Regexp::Syntax::Token::Escape; end
 Regexp::Syntax::Token::Escape::ASCII = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Escape::All = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Escape::Basic = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Escape::Control = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Escape::Hex = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Escape::Meta = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Escape::Octal = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Escape::Type = T.let(T.unsafe(nil), Symbol)
-
 Regexp::Syntax::Token::Escape::Unicode = T.let(T.unsafe(nil), Array)
-
-module Regexp::Syntax::Token::FreeSpace
-end
-
+module Regexp::Syntax::Token::FreeSpace; end
 Regexp::Syntax::Token::FreeSpace::All = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::FreeSpace::Type = T.let(T.unsafe(nil), Symbol)
-
-module Regexp::Syntax::Token::Group
-end
-
+module Regexp::Syntax::Token::Group; end
 Regexp::Syntax::Token::Group::All = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Group::Atomic = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Group::Basic = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Group::Comment = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Group::Extended = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Group::Named = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Group::Passive = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Group::Type = T.let(T.unsafe(nil), Symbol)
-
 Regexp::Syntax::Token::Group::V1_8_6 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Group::V2_4_1 = T.let(T.unsafe(nil), Array)
-
-module Regexp::Syntax::Token::Keep
-end
-
+module Regexp::Syntax::Token::Keep; end
 Regexp::Syntax::Token::Keep::All = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Keep::Mark = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Keep::Type = T.let(T.unsafe(nil), Symbol)
-
-module Regexp::Syntax::Token::Literal
-end
-
+module Regexp::Syntax::Token::Literal; end
 Regexp::Syntax::Token::Literal::All = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Literal::Type = T.let(T.unsafe(nil), Symbol)
-
 Regexp::Syntax::Token::Map = T.let(T.unsafe(nil), Hash)
-
-module Regexp::Syntax::Token::Meta
-end
-
+module Regexp::Syntax::Token::Meta; end
 Regexp::Syntax::Token::Meta::All = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Meta::Basic = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Meta::Extended = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Meta::Type = T.let(T.unsafe(nil), Symbol)
-
-module Regexp::Syntax::Token::PosixClass
-end
-
+module Regexp::Syntax::Token::PosixClass; end
 Regexp::Syntax::Token::PosixClass::All = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::PosixClass::Extensions = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::PosixClass::NonType = T.let(T.unsafe(nil), Symbol)
-
 Regexp::Syntax::Token::PosixClass::Standard = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::PosixClass::Type = T.let(T.unsafe(nil), Symbol)
-
-module Regexp::Syntax::Token::Quantifier
-end
-
+module Regexp::Syntax::Token::Quantifier; end
 Regexp::Syntax::Token::Quantifier::All = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Quantifier::Greedy = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Quantifier::Interval = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Quantifier::IntervalAll = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Quantifier::IntervalPossessive = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Quantifier::IntervalReluctant = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Quantifier::Possessive = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Quantifier::Reluctant = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Quantifier::Type = T.let(T.unsafe(nil), Symbol)
-
-module Regexp::Syntax::Token::SubexpressionCall
-end
-
+module Regexp::Syntax::Token::SubexpressionCall; end
 Regexp::Syntax::Token::SubexpressionCall::All = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::SubexpressionCall::Name = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::SubexpressionCall::Number = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::Types = T.let(T.unsafe(nil), Array)
-
-module Regexp::Syntax::Token::UnicodeProperty
-end
-
+module Regexp::Syntax::Token::UnicodeProperty; end
 Regexp::Syntax::Token::UnicodeProperty::Age = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Age_V1_9_3 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Age_V2_0_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Age_V2_2_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Age_V2_3_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Age_V2_4_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Age_V2_5_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_2 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Age_V2_6_3 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::All = T.let(T.unsafe(nil), Array)
-
-module Regexp::Syntax::Token::UnicodeProperty::Category
-end
-
+module Regexp::Syntax::Token::UnicodeProperty::Category; end
 Regexp::Syntax::Token::UnicodeProperty::Category::All = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Category::Codepoint = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Category::Letter = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Category::Mark = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Category::Number = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Category::Punctuation = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Category::Separator = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Category::Symbol = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::CharType_V1_9_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::CharType_V2_5_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Derived = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Derived_V1_9_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Derived_V2_0_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Derived_V2_4_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Derived_V2_5_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Emoji = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Emoji_V2_5_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::NonType = T.let(T.unsafe(nil), Symbol)
-
 Regexp::Syntax::Token::UnicodeProperty::POSIX = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Script = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Script_V1_9_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Script_V1_9_3 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Script_V2_0_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Script_V2_2_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Script_V2_3_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Script_V2_4_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Script_V2_5_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Script_V2_6_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Script_V2_6_2 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::Type = T.let(T.unsafe(nil), Symbol)
-
 Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V1_9_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_0_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_2_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_3_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_4_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_5_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_6_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::UnicodeBlock_V2_6_2 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::V1_9_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::V1_9_3 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::V2_0_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::V2_2_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::V2_3_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::V2_4_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::V2_5_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::V2_6_0 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::V2_6_2 = T.let(T.unsafe(nil), Array)
-
 Regexp::Syntax::Token::UnicodeProperty::V2_6_3 = T.let(T.unsafe(nil), Array)
 
 class Regexp::Syntax::UnknownSyntaxNameError < ::Regexp::Syntax::SyntaxError
@@ -1452,8 +1027,7 @@ class Regexp::Syntax::V1_8_6 < ::Regexp::Syntax::Base
   def initialize; end
 end
 
-class Regexp::Syntax::V1_9 < ::Regexp::Syntax::V1_9_3
-end
+class Regexp::Syntax::V1_9 < ::Regexp::Syntax::V1_9_3; end
 
 class Regexp::Syntax::V1_9_1 < ::Regexp::Syntax::V1_8_6
   def initialize; end
@@ -1467,25 +1041,20 @@ class Regexp::Syntax::V2_0_0 < ::Regexp::Syntax::V1_9
   def initialize; end
 end
 
-class Regexp::Syntax::V2_1 < ::Regexp::Syntax::V2_0_0
-end
-
-class Regexp::Syntax::V2_2 < ::Regexp::Syntax::V2_2_0
-end
+class Regexp::Syntax::V2_1 < ::Regexp::Syntax::V2_0_0; end
+class Regexp::Syntax::V2_2 < ::Regexp::Syntax::V2_2_0; end
 
 class Regexp::Syntax::V2_2_0 < ::Regexp::Syntax::V2_1
   def initialize; end
 end
 
-class Regexp::Syntax::V2_3 < ::Regexp::Syntax::V2_3_0
-end
+class Regexp::Syntax::V2_3 < ::Regexp::Syntax::V2_3_0; end
 
 class Regexp::Syntax::V2_3_0 < ::Regexp::Syntax::V2_2
   def initialize; end
 end
 
-class Regexp::Syntax::V2_4 < ::Regexp::Syntax::V2_4_1
-end
+class Regexp::Syntax::V2_4 < ::Regexp::Syntax::V2_4_1; end
 
 class Regexp::Syntax::V2_4_0 < ::Regexp::Syntax::V2_3
   def initialize; end
@@ -1495,8 +1064,7 @@ class Regexp::Syntax::V2_4_1 < ::Regexp::Syntax::V2_4_0
   def initialize; end
 end
 
-class Regexp::Syntax::V2_5 < ::Regexp::Syntax::V2_5_0
-end
+class Regexp::Syntax::V2_5 < ::Regexp::Syntax::V2_5_0; end
 
 class Regexp::Syntax::V2_5_0 < ::Regexp::Syntax::V2_4
   def initialize; end
@@ -1515,11 +1083,8 @@ class Regexp::Syntax::V2_6_3 < ::Regexp::Syntax::V2_6_2
 end
 
 Regexp::Syntax::VERSION_CONST_REGEXP = T.let(T.unsafe(nil), Regexp)
-
 Regexp::Syntax::VERSION_FORMAT = T.let(T.unsafe(nil), String)
-
 Regexp::Syntax::VERSION_REGEXP = T.let(T.unsafe(nil), Regexp)
-
 Regexp::TOKEN_KEYS = T.let(T.unsafe(nil), Array)
 
 class Regexp::Token < ::Struct
diff --git a/Library/Homebrew/sorbet/rbi/gems/rexml@3.2.5.rbi b/Library/Homebrew/sorbet/rbi/gems/rexml@3.2.5.rbi
index ce0829c114..4ed17d0eec 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rexml@3.2.5.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rexml@3.2.5.rbi
@@ -5,7 +5,7 @@
 # typed: true
 
 class REXML::AttlistDecl < ::REXML::Child
-  include(::Enumerable)
+  include ::Enumerable
 
   def initialize(source); end
 
@@ -18,9 +18,9 @@ class REXML::AttlistDecl < ::REXML::Child
 end
 
 class REXML::Attribute
-  include(::REXML::Node)
-  include(::REXML::XMLTokens)
-  include(::REXML::Namespace)
+  include ::REXML::Node
+  include ::REXML::XMLTokens
+  include ::REXML::Namespace
 
   def initialize(first, second = T.unsafe(nil), parent = T.unsafe(nil)); end
 
@@ -73,7 +73,7 @@ class REXML::CData < ::REXML::Text
 end
 
 class REXML::Child
-  include(::REXML::Node)
+  include ::REXML::Node
 
   def initialize(parent = T.unsafe(nil)); end
 
@@ -90,7 +90,7 @@ class REXML::Child
 end
 
 class REXML::Comment < ::REXML::Child
-  include(::Comparable)
+  include ::Comparable
 
   def initialize(first, second = T.unsafe(nil)); end
 
@@ -104,8 +104,7 @@ class REXML::Comment < ::REXML::Child
   def write(output, indent = T.unsafe(nil), transitive = T.unsafe(nil), ie_hack = T.unsafe(nil)); end
 end
 
-module REXML::DClonable
-end
+module REXML::DClonable; end
 
 class REXML::Declaration < ::REXML::Child
   def initialize(src); end
@@ -115,7 +114,7 @@ class REXML::Declaration < ::REXML::Child
 end
 
 class REXML::DocType < ::REXML::Parent
-  include(::REXML::XMLTokens)
+  include ::REXML::XMLTokens
 
   def initialize(first, parent = T.unsafe(nil)); end
 
@@ -172,8 +171,8 @@ class REXML::Document < ::REXML::Element
 end
 
 class REXML::Element < ::REXML::Parent
-  include(::REXML::XMLTokens)
-  include(::REXML::Namespace)
+  include ::REXML::XMLTokens
+  include ::REXML::Namespace
 
   def initialize(arg = T.unsafe(nil), parent = T.unsafe(nil), context = T.unsafe(nil)); end
 
@@ -228,8 +227,12 @@ class REXML::Element < ::REXML::Parent
   def each_with_something(test, max = T.unsafe(nil), name = T.unsafe(nil)); end
 end
 
+class REXML::ElementDecl < ::REXML::Declaration
+  def initialize(src); end
+end
+
 class REXML::Elements
-  include(::Enumerable)
+  include ::Enumerable
 
   def initialize(parent); end
 
@@ -265,7 +268,7 @@ module REXML::Encoding
 end
 
 class REXML::Entity < ::REXML::Child
-  include(::REXML::XMLTokens)
+  include ::REXML::XMLTokens
 
   def initialize(stream, value = T.unsafe(nil), parent = T.unsafe(nil), reference = T.unsafe(nil)); end
 
@@ -373,7 +376,7 @@ class REXML::NotationDecl < ::REXML::Child
 end
 
 class REXML::Output
-  include(::REXML::Encoding)
+  include ::REXML::Encoding
 
   def initialize(real_IO, encd = T.unsafe(nil)); end
 
@@ -383,7 +386,7 @@ class REXML::Output
 end
 
 class REXML::Parent < ::REXML::Child
-  include(::Enumerable)
+  include ::Enumerable
 
   def initialize(parent = T.unsafe(nil)); end
 
@@ -454,13 +457,9 @@ class REXML::Parsers::BaseParser
 end
 
 REXML::Parsers::BaseParser::EXTERNAL_ID_PUBLIC = T.let(T.unsafe(nil), Regexp)
-
 REXML::Parsers::BaseParser::EXTERNAL_ID_SYSTEM = T.let(T.unsafe(nil), Regexp)
-
 REXML::Parsers::BaseParser::PUBLIC_ID = T.let(T.unsafe(nil), Regexp)
-
 REXML::Parsers::BaseParser::QNAME = T.let(T.unsafe(nil), Regexp)
-
 REXML::Parsers::BaseParser::QNAME_STR = T.let(T.unsafe(nil), String)
 
 class REXML::Parsers::StreamParser
@@ -478,7 +477,7 @@ class REXML::Parsers::TreeParser
 end
 
 class REXML::Parsers::XPathParser
-  include(::REXML::XMLTokens)
+  include ::REXML::XMLTokens
 
   def abbreviate(path); end
   def expand(path); end
@@ -510,7 +509,6 @@ class REXML::Parsers::XPathParser
 end
 
 REXML::Parsers::XPathParser::LOCAL_NAME_WILDCARD = T.let(T.unsafe(nil), Regexp)
-
 REXML::Parsers::XPathParser::PREFIX_WILDCARD = T.let(T.unsafe(nil), Regexp)
 
 class REXML::ReferenceWriter
@@ -520,7 +518,7 @@ class REXML::ReferenceWriter
 end
 
 class REXML::Source
-  include(::REXML::Encoding)
+  include ::REXML::Encoding
 
   def initialize(arg, encoding = T.unsafe(nil)); end
 
@@ -545,7 +543,7 @@ class REXML::Source
 end
 
 class REXML::Text < ::REXML::Child
-  include(::Comparable)
+  include ::Comparable
 
   def initialize(arg, respect_whitespace = T.unsafe(nil), parent = T.unsafe(nil), raw = T.unsafe(nil), entity_filter = T.unsafe(nil), illegal = T.unsafe(nil)); end
 
@@ -581,8 +579,16 @@ class REXML::Text < ::REXML::Child
   end
 end
 
+class REXML::UndefinedNamespaceException < ::REXML::ParseException
+  def initialize(prefix, source, parser); end
+end
+
+class REXML::Validation::ValidationException < ::RuntimeError
+  def initialize(msg); end
+end
+
 class REXML::XMLDecl < ::REXML::Child
-  include(::REXML::Encoding)
+  include ::REXML::Encoding
 
   def initialize(version = T.unsafe(nil), encoding = T.unsafe(nil), standalone = T.unsafe(nil)); end
 
@@ -622,7 +628,7 @@ class REXML::XPathNode
 end
 
 class REXML::XPathParser
-  include(::REXML::XMLTokens)
+  include ::REXML::XMLTokens
 
   def initialize(strict: T.unsafe(nil)); end
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi b/Library/Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi
index cac8c5328c..0df33b43b4 100644
--- a/Library/Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi
@@ -1,7 +1,194 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `ronn` gem.
-# Please instead update this file by running `tapioca generate --exclude json`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
+module Ronn
+  class << self
+    def new(filename, attributes = T.unsafe(nil), &block); end
+    def release?; end
+    def revision; end
+    def version; end
+  end
+end
 
+class Ronn::Document
+  include ::Ronn::Utils
+
+  def initialize(path = T.unsafe(nil), attributes = T.unsafe(nil), &block); end
+
+  def basename(type = T.unsafe(nil)); end
+  def convert(format); end
+  def data; end
+  def date; end
+  def date=(_arg0); end
+  def html; end
+  def index; end
+  def index=(_arg0); end
+  def manual; end
+  def manual=(_arg0); end
+  def markdown; end
+  def name; end
+  def name=(_arg0); end
+  def name?; end
+  def organization; end
+  def organization=(_arg0); end
+  def path; end
+  def path_for(type = T.unsafe(nil)); end
+  def path_name; end
+  def path_section; end
+  def reference_name; end
+  def section; end
+  def section=(_arg0); end
+  def section?; end
+  def section_heads; end
+  def sniff; end
+  def styles; end
+  def styles=(styles); end
+  def tagline; end
+  def tagline=(_arg0); end
+  def title; end
+  def title?; end
+  def to_h; end
+  def to_html; end
+  def to_html_fragment(wrap_class = T.unsafe(nil)); end
+  def to_json; end
+  def to_markdown; end
+  def to_roff; end
+  def to_yaml; end
+  def toc; end
+
+  protected
+
+  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 input_html; end
+  def markdown_filter_angle_quotes(markdown); end
+  def markdown_filter_heading_anchors(markdown); end
+  def markdown_filter_link_index(markdown); end
+  def preprocess!; end
+  def process_html!; end
+  def process_markdown!; end
+  def strip_heading(html); end
+end
+
+class Ronn::Index
+  include ::Enumerable
+
+  def initialize(path, &bk); end
+
+  def <<(path); end
+  def [](name); end
+  def add_manual(manual); end
+  def each(&bk); end
+  def empty?; end
+  def exist?; end
+  def first; end
+  def last; end
+  def manual(path); end
+  def manuals; end
+  def path; end
+  def read!(data); end
+  def reference(name, path); end
+  def references; end
+  def relative_to_index(path); end
+  def size; end
+  def to_a; end
+  def to_h; end
+  def to_text; end
+
+  class << self
+    def [](path); end
+    def index_path_for_file(file); end
+  end
+end
+
+Ronn::REV = T.let(T.unsafe(nil), String)
+
+class Ronn::Reference
+  def initialize(index, name, location); end
+
+  def location; end
+  def manual?; end
+  def name; end
+  def path; end
+  def relative?; end
+  def remote?; end
+  def ronn?; end
+  def url; end
+end
+
+class Ronn::RoffFilter
+  include ::Ronn::Utils
+
+  def initialize(html, name, section, tagline, manual = T.unsafe(nil), version = T.unsafe(nil), date = T.unsafe(nil)); end
+
+  def to_s; end
+
+  protected
+
+  def block_filter(node); end
+  def comment(text); end
+  def escape(text); end
+  def inline_filter(node); end
+  def macro(name, value = T.unsafe(nil)); end
+  def normalize_whitespace!(node); end
+  def previous(node); end
+  def quote(text); end
+  def remove_extraneous_elements!(doc); end
+  def title_heading(name, section, tagline, manual, version, date); end
+  def warn(text, *args); end
+  def write(text); end
+  def writeln(text); end
+end
+
+Ronn::RoffFilter::HTML_ROFF_ENTITIES = T.let(T.unsafe(nil), Hash)
+
+class Ronn::Template < ::Mustache
+  def initialize(document, style_path = T.unsafe(nil)); end
+
+  def custom_title?; end
+  def date; end
+  def generator; end
+  def inline_stylesheet(path, media = T.unsafe(nil)); end
+  def manual; end
+  def missing_styles; end
+  def name; end
+  def name_and_section?; end
+  def organization; end
+  def page_name; end
+  def remote_stylesheet(name, media = T.unsafe(nil)); end
+  def render(template = T.unsafe(nil)); end
+  def section; end
+  def section_heads; end
+  def style_files; end
+  def style_path; end
+  def style_path=(_arg0); end
+  def styles; end
+  def stylesheet(path, media = T.unsafe(nil)); end
+  def stylesheet_tags; end
+  def stylesheets; end
+  def tagline; end
+  def tagline?; end
+  def title; end
+  def wrap_class_name; end
+end
+
+module Ronn::Utils
+  def block_element?(name); end
+  def child_of?(node, tag); end
+  def empty_element?(name); end
+  def html_element?(name); end
+  def inline_element?(name); end
+end
+
+Ronn::Utils::HTML = T.let(T.unsafe(nil), Set)
+Ronn::Utils::HTML_BLOCK = T.let(T.unsafe(nil), Set)
+Ronn::Utils::HTML_EMPTY = T.let(T.unsafe(nil), Set)
+Ronn::Utils::HTML_INLINE = T.let(T.unsafe(nil), Set)
+Ronn::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-core@3.10.1.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-core@3.10.1.rbi
index 121f3a8343..c8a56a560f 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-core@3.10.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rspec-core@3.10.1.rbi
@@ -1,8 +1,2507 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `rspec-core` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module RSpec
+  extend ::RSpec::Support::Warnings
+  extend ::RSpec::Core::Warnings
+
+  class << self
+    def clear_examples; end
+    def configuration; end
+    def configuration=(_arg0); end
+    def configure; end
+    def const_missing(name); end
+    def context(*args, &example_group_block); end
+    def current_example; end
+    def current_example=(example); end
+    def describe(*args, &example_group_block); end
+    def example_group(*args, &example_group_block); end
+    def fcontext(*args, &example_group_block); end
+    def fdescribe(*args, &example_group_block); end
+    def reset; end
+    def shared_context(name, *args, &block); end
+    def shared_examples(name, *args, &block); end
+    def shared_examples_for(name, *args, &block); end
+    def world; end
+    def world=(_arg0); end
+    def xcontext(*args, &example_group_block); end
+    def xdescribe(*args, &example_group_block); end
+  end
+end
+
+module RSpec::Core
+  class << self
+    def path_to_executable; end
+  end
+end
+
+class RSpec::Core::AnonymousExampleGroup < ::RSpec::Core::ExampleGroup
+  class << self
+    def metadata; end
+  end
+end
+
+class RSpec::Core::BacktraceFormatter
+  def initialize; end
+
+  def backtrace_line(line); end
+  def exclude?(line); end
+  def exclusion_patterns; end
+  def exclusion_patterns=(_arg0); end
+  def filter_gem(gem_name); end
+  def format_backtrace(backtrace, options = T.unsafe(nil)); end
+  def full_backtrace=(_arg0); end
+  def full_backtrace?; end
+  def inclusion_patterns; end
+  def inclusion_patterns=(_arg0); end
+
+  private
+
+  def matches?(patterns, line); end
+end
+
+module RSpec::Core::Bisect; end
+
+class RSpec::Core::Bisect::BisectFailedError < ::StandardError
+  class << self
+    def for_failed_spec_run(spec_output); end
+  end
+end
+
+class RSpec::Core::Bisect::Channel
+  def initialize; end
+
+  def close; end
+  def receive; end
+  def send(message); end
+end
+
+class RSpec::Core::Bisect::ExampleSetDescriptor < ::Struct
+  def all_example_ids; end
+  def all_example_ids=(_); end
+  def failed_example_ids; end
+  def failed_example_ids=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class RSpec::Core::Bisect::Notifier
+  def initialize(formatter); end
+
+  def publish(event, *args); end
+end
+
+class RSpec::Core::Configuration
+  include ::RSpec::Core::Hooks
+  include ::RSpec::Core::Configuration::Readers
+
+  def initialize; end
+
+  def add_formatter(formatter, output = T.unsafe(nil)); end
+  def add_setting(name, opts = T.unsafe(nil)); end
+  def after(scope = T.unsafe(nil), *meta, &block); end
+  def alias_example_group_to(new_name, *args); end
+  def alias_example_to(name, *args); end
+  def alias_it_behaves_like_to(new_name, report_label = T.unsafe(nil)); end
+  def alias_it_should_behave_like_to(new_name, report_label = T.unsafe(nil)); end
+  def append_after(scope = T.unsafe(nil), *meta, &block); end
+  def append_before(scope = T.unsafe(nil), *meta, &block); end
+  def apply_derived_metadata_to(metadata); end
+  def around(scope = T.unsafe(nil), *meta, &block); end
+  def backtrace_exclusion_patterns; end
+  def backtrace_exclusion_patterns=(patterns); end
+  def backtrace_formatter; end
+  def backtrace_inclusion_patterns; end
+  def backtrace_inclusion_patterns=(patterns); end
+  def before(scope = T.unsafe(nil), *meta, &block); end
+  def bisect_runner; end
+  def bisect_runner=(value); end
+  def bisect_runner_class; end
+  def color; end
+  def color=(_arg0); end
+  def color_enabled?(output = T.unsafe(nil)); end
+  def color_mode; end
+  def color_mode=(_arg0); end
+  def configure_example(example, example_hooks); end
+  def configure_expectation_framework; end
+  def configure_group(group); end
+  def configure_mock_framework; end
+  def default_color; end
+  def default_color=(_arg0); end
+  def default_color?; end
+  def default_formatter; end
+  def default_formatter=(value); end
+  def default_path; end
+  def default_path=(path); end
+  def default_path?; end
+  def define_derived_metadata(*filters, &block); end
+  def deprecation_stream; end
+  def deprecation_stream=(value); end
+  def detail_color; end
+  def detail_color=(_arg0); end
+  def detail_color?; end
+  def disable_monkey_patching; end
+  def disable_monkey_patching!; end
+  def disable_monkey_patching=(_arg0); end
+  def drb; end
+  def drb=(_arg0); end
+  def drb?; end
+  def drb_port; end
+  def drb_port=(_arg0); end
+  def drb_port?; end
+  def dry_run; end
+  def dry_run=(_arg0); end
+  def dry_run?; end
+  def error_exit_code; end
+  def error_exit_code=(_arg0); end
+  def error_exit_code?; end
+  def error_stream; end
+  def error_stream=(_arg0); end
+  def error_stream?; end
+  def example_status_persistence_file_path; end
+  def example_status_persistence_file_path=(value); end
+  def exclude_pattern; end
+  def exclude_pattern=(value); end
+  def exclusion_filter; end
+  def exclusion_filter=(filter); end
+  def expect_with(*frameworks); end
+  def expectation_framework=(framework); end
+  def expectation_frameworks; end
+  def expose_current_running_example_as(method_name); end
+  def expose_dsl_globally=(value); end
+  def expose_dsl_globally?; end
+  def extend(mod, *filters); end
+  def fail_fast; end
+  def fail_fast=(value); end
+  def fail_if_no_examples; end
+  def fail_if_no_examples=(_arg0); end
+  def fail_if_no_examples?; end
+  def failure_color; end
+  def failure_color=(_arg0); end
+  def failure_color?; end
+  def failure_exit_code; end
+  def failure_exit_code=(_arg0); end
+  def failure_exit_code?; end
+  def files_or_directories_to_run=(*files); end
+  def files_to_run; end
+  def files_to_run=(_arg0); end
+  def filter; end
+  def filter=(filter); end
+  def filter_gems_from_backtrace(*gem_names); end
+  def filter_manager; end
+  def filter_manager=(_arg0); end
+  def filter_run(*args); end
+  def filter_run_excluding(*args); end
+  def filter_run_including(*args); end
+  def filter_run_when_matching(*args); end
+  def fixed_color; end
+  def fixed_color=(_arg0); end
+  def fixed_color?; end
+  def force(hash); end
+  def format_docstrings(&block); end
+  def format_docstrings_block; end
+  def formatter=(formatter, output = T.unsafe(nil)); end
+  def formatter_loader; end
+  def formatters; end
+  def full_backtrace=(true_or_false); end
+  def full_backtrace?; end
+  def full_description; end
+  def full_description=(description); end
+  def hooks; end
+  def in_project_source_dir_regex; end
+  def include(mod, *filters); end
+  def include_context(shared_group_name, *filters); end
+  def inclusion_filter; end
+  def inclusion_filter=(filter); end
+  def last_run_statuses; end
+  def libs; end
+  def libs=(libs); end
+  def load_spec_files; end
+  def loaded_spec_files; end
+  def max_displayed_failure_line_count; end
+  def max_displayed_failure_line_count=(_arg0); end
+  def max_displayed_failure_line_count?; end
+  def mock_framework; end
+  def mock_framework=(framework); end
+  def mock_with(framework); end
+  def on_example_group_definition(&block); end
+  def on_example_group_definition_callbacks; end
+  def only_failures; end
+  def only_failures?; end
+  def only_failures_but_not_configured?; end
+  def order=(*args, &block); end
+  def ordering_manager; end
+  def ordering_registry(*args, &block); end
+  def output_stream; end
+  def output_stream=(value); end
+  def pattern; end
+  def pattern=(value); end
+  def pending_color; end
+  def pending_color=(_arg0); end
+  def pending_color?; end
+  def prepend(mod, *filters); end
+  def prepend_after(scope = T.unsafe(nil), *meta, &block); end
+  def prepend_before(scope = T.unsafe(nil), *meta, &block); end
+  def profile_examples; end
+  def profile_examples=(_arg0); end
+  def profile_examples?; end
+  def project_source_dirs; end
+  def project_source_dirs=(_arg0); end
+  def project_source_dirs?; end
+  def raise_errors_for_deprecations!; end
+  def raise_on_warning=(value); end
+  def register_ordering(*args, &block); end
+  def reporter; end
+  def requires; end
+  def requires=(paths); end
+  def reset; end
+  def reset_filters; end
+  def reset_reporter; end
+  def run_all_when_everything_filtered; end
+  def run_all_when_everything_filtered=(_arg0); end
+  def run_all_when_everything_filtered?; end
+  def seed(*args, &block); end
+  def seed=(*args, &block); end
+  def seed_used?(*args, &block); end
+  def shared_context_metadata_behavior; end
+  def shared_context_metadata_behavior=(value); end
+  def silence_filter_announcements; end
+  def silence_filter_announcements=(_arg0); end
+  def silence_filter_announcements?; end
+  def spec_files_with_failures; end
+  def start_time; end
+  def start_time=(_arg0); end
+  def start_time?; end
+  def static_config_filter_manager; end
+  def static_config_filter_manager=(_arg0); end
+  def success_color; end
+  def success_color=(_arg0); end
+  def success_color?; end
+  def threadsafe; end
+  def threadsafe=(_arg0); end
+  def threadsafe?; end
+  def treat_symbols_as_metadata_keys_with_true_values=(_value); end
+  def tty; end
+  def tty=(_arg0); end
+  def tty?; end
+  def warnings=(value); end
+  def warnings?; end
+  def when_first_matching_example_defined(*filters); end
+  def with_suite_hooks; end
+  def world; end
+  def world=(_arg0); end
+
+  private
+
+  def absolute_pattern?(pattern); end
+  def add_hook_to_existing_matching_groups(meta, scope, &block); end
+  def assert_no_example_groups_defined(config_option); end
+  def clear_values_derived_from_example_status_persistence_file_path; end
+  def command; end
+  def conditionally_disable_expectations_monkey_patching; end
+  def conditionally_disable_mocks_monkey_patching; end
+  def configure_group_with(group, module_list, application_method); end
+  def define_built_in_hooks; end
+  def define_mixed_in_module(mod, filters, mod_list, config_method, &block); end
+  def extract_location(path); end
+  def file_glob_from(path, pattern); end
+  def gather_directories(path); end
+  def get_files_to_run(paths); end
+  def get_matching_files(path, pattern); end
+  def handle_suite_hook(scope, meta); end
+  def load_file_handling_errors(method, file); end
+  def metadata_applies_to_group?(meta, group); end
+  def on_existing_matching_groups(meta); end
+  def output_to_tty?(output = T.unsafe(nil)); end
+  def output_wrapper; end
+  def paths_to_check(paths); end
+  def pattern_might_load_specs_from_vendored_dirs?; end
+  def rspec_expectations_loaded?; end
+  def rspec_mocks_loaded?; end
+  def run_suite_hooks(hook_description, hooks); end
+  def safe_extend(mod, host); end
+  def safe_include(mod, host); end
+  def safe_prepend(mod, host); end
+  def update_pattern_attr(name, value); end
+  def value_for(key); end
+
+  class << self
+    def add_read_only_setting(name, opts = T.unsafe(nil)); end
+    def add_setting(name, opts = T.unsafe(nil)); end
+    def define_alias(name, alias_name); end
+    def define_predicate(name); end
+    def define_reader(name); end
+    def delegate_to_ordering_manager(*methods); end
+  end
+end
+
+RSpec::Core::Configuration::DEFAULT_FORMATTER = T.let(T.unsafe(nil), Proc)
+
+class RSpec::Core::Configuration::DeprecationReporterBuffer
+  def initialize; end
+
+  def deprecation(*args); end
+  def play_onto(reporter); end
+end
+
+module RSpec::Core::Configuration::ExposeCurrentExample; end
+RSpec::Core::Configuration::FAILED_STATUS = T.let(T.unsafe(nil), String)
+RSpec::Core::Configuration::MOCKING_ADAPTERS = T.let(T.unsafe(nil), Hash)
+class RSpec::Core::Configuration::MustBeConfiguredBeforeExampleGroupsError < ::StandardError; end
+RSpec::Core::Configuration::PASSED_STATUS = T.let(T.unsafe(nil), String)
+RSpec::Core::Configuration::PENDING_STATUS = T.let(T.unsafe(nil), String)
+RSpec::Core::Configuration::RAISE_ERROR_WARNING_NOTIFIER = T.let(T.unsafe(nil), Proc)
+
+module RSpec::Core::Configuration::Readers
+  def clear_lets_on_failure; end
+  def default_color; end
+  def default_path; end
+  def default_retry_count; end
+  def default_sleep_interval; end
+  def deprecation_stream; end
+  def detail_color; end
+  def display_try_failure_messages; end
+  def drb; end
+  def drb_port; end
+  def dry_run; end
+  def error_exit_code; end
+  def error_stream; end
+  def example_status_persistence_file_path; end
+  def exceptions_to_hard_fail; end
+  def exceptions_to_retry; end
+  def exclude_pattern; end
+  def exponential_backoff; end
+  def fail_fast; end
+  def fail_if_no_examples; end
+  def failure_color; end
+  def failure_exit_code; end
+  def fixed_color; end
+  def libs; end
+  def max_displayed_failure_line_count; end
+  def only_failures; end
+  def output_stream; end
+  def pattern; end
+  def pending_color; end
+  def project_source_dirs; end
+  def requires; end
+  def retry_callback; end
+  def retry_count_condition; end
+  def run_all_when_everything_filtered; end
+  def shared_context_metadata_behavior; end
+  def silence_filter_announcements; end
+  def start_time; end
+  def success_color; end
+  def threadsafe; end
+  def tty; end
+  def verbose_retry; end
+  def wait_delay; end
+  def wait_timeout; end
+end
+
+RSpec::Core::Configuration::UNKNOWN_STATUS = T.let(T.unsafe(nil), String)
+RSpec::Core::Configuration::VALID_STATUSES = T.let(T.unsafe(nil), Array)
+
+class RSpec::Core::ConfigurationOptions
+  def initialize(args); end
+
+  def args; end
+  def configure(config); end
+  def configure_filter_manager(filter_manager); end
+  def options; end
+
+  private
+
+  def args_from_options_file(path); end
+  def command_line_options; end
+  def custom_options; end
+  def custom_options_file; end
+  def env_options; end
+  def file_options; end
+  def force?(key); end
+  def global_options; end
+  def global_options_file; end
+  def home_options_file_path; end
+  def load_formatters_into(config); end
+  def local_options; end
+  def local_options_file; end
+  def options_file_as_erb_string(path); end
+  def options_from(path); end
+  def order(keys); end
+  def organize_options; end
+  def parse_args_ignoring_files_or_dirs_to_run(args, source); end
+  def process_options_into(config); end
+  def project_options; end
+  def project_options_file; end
+  def resolve_xdg_config_home; end
+  def xdg_options_file_if_exists; end
+  def xdg_options_file_path; end
+end
+
+RSpec::Core::ConfigurationOptions::OPTIONS_ORDER = T.let(T.unsafe(nil), Array)
+RSpec::Core::ConfigurationOptions::UNFORCED_OPTIONS = T.let(T.unsafe(nil), RSpec::Core::Set)
+RSpec::Core::ConfigurationOptions::UNPROCESSABLE_OPTIONS = T.let(T.unsafe(nil), RSpec::Core::Set)
+
+module RSpec::Core::DSL
+  class << self
+    def change_global_dsl(&changes); end
+    def example_group_aliases; end
+    def expose_example_group_alias(name); end
+    def expose_example_group_alias_globally(method_name); end
+    def expose_globally!; end
+    def exposed_globally?; end
+    def remove_globally!; end
+    def top_level; end
+    def top_level=(_arg0); end
+  end
+end
+
+class RSpec::Core::DeprecationError < ::StandardError; end
+
+class RSpec::Core::DidYouMean
+  def initialize(relative_file_name); end
+
+  def call; end
+  def relative_file_name; end
+
+  private
+
+  def formats(probables); end
+  def red_font(mytext); end
+  def top_and_tail(rspec_format); end
+end
+
+class RSpec::Core::Example
+  def initialize(example_group_class, description, user_metadata, example_block = T.unsafe(nil)); end
+
+  def attempts; end
+  def attempts=(_arg0); end
+  def clear_exception; end
+  def clock; end
+  def clock=(_arg0); end
+  def description; end
+  def display_exception; end
+  def display_exception=(ex); end
+  def duplicate_with(metadata_overrides = T.unsafe(nil)); end
+  def example_group; end
+  def example_group_instance; end
+  def exception; end
+  def execution_result; end
+  def fail_with_exception(reporter, exception); end
+  def file_path; end
+  def full_description; end
+  def id; end
+  def inspect; end
+  def inspect_output; end
+  def instance_exec(*args, &block); end
+  def location; end
+  def location_rerun_argument; end
+  def metadata; end
+  def pending; end
+  def pending?; end
+  def reporter; end
+  def rerun_argument; end
+  def run(example_group_instance, reporter); end
+  def set_aggregate_failures_exception(exception); end
+  def set_exception(exception); end
+  def skip; end
+  def skip_with_exception(reporter, exception); end
+  def skipped?; end
+  def to_s; end
+  def update_inherited_metadata(updates); end
+
+  private
+
+  def assign_generated_description; end
+  def finish(reporter); end
+  def generate_description; end
+  def hooks; end
+  def location_description; end
+  def mocks_need_verification?; end
+  def record_finished(status, reporter); end
+  def run_after_example; end
+  def run_before_example; end
+  def start(reporter); end
+  def verify_mocks; end
+  def with_around_and_singleton_context_hooks; end
+  def with_around_example_hooks; end
+
+  class << self
+    def delegate_to_metadata(key); end
+    def parse_id(id); end
+  end
+end
+
+RSpec::Core::Example::AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt = RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
+
+class RSpec::Core::Example::ExecutionResult
+  include ::RSpec::Core::HashImitatable
+  extend ::RSpec::Core::HashImitatable::ClassMethods
+
+  def ensure_timing_set(clock); end
+  def example_skipped?; end
+  def exception; end
+  def exception=(_arg0); end
+  def finished_at; end
+  def finished_at=(_arg0); end
+  def pending_exception; end
+  def pending_exception=(_arg0); end
+  def pending_fixed; end
+  def pending_fixed=(_arg0); end
+  def pending_fixed?; end
+  def pending_message; end
+  def pending_message=(_arg0); end
+  def record_finished(status, finished_at); end
+  def run_time; end
+  def run_time=(_arg0); end
+  def started_at; end
+  def started_at=(_arg0); end
+  def status; end
+  def status=(_arg0); end
+
+  private
+
+  def calculate_run_time(finished_at); end
+  def get_value(name); end
+  def hash_for_delegation; end
+  def issue_deprecation(_method_name, *_args); end
+  def set_value(name, value); end
+end
+
+class RSpec::Core::Example::Procsy
+  def initialize(example, &block); end
+
+  def <<(*a, &b); end
+  def ===(*a, &b); end
+  def >>(*a, &b); end
+  def [](*a, &b); end
+  def arity(*a, &b); end
+  def attempts; end
+  def binding(*a, &b); end
+  def call(*args, &block); end
+  def clock(*a, &b); end
+  def clock=(*a, &b); end
+  def clone(*a, &b); end
+  def curry(*a, &b); end
+  def description(*a, &b); end
+  def dup(*a, &b); end
+  def duplicate_with(*a, &b); end
+  def example; end
+  def example_group(*a, &b); end
+  def example_group_instance(*a, &b); end
+  def exception(*a, &b); end
+  def executed?; end
+  def execution_result(*a, &b); end
+  def file_path(*a, &b); end
+  def full_description(*a, &b); end
+  def hash(*a, &b); end
+  def id(*a, &b); end
+  def inspect; end
+  def inspect_output(*a, &b); end
+  def lambda?(*a, &b); end
+  def location(*a, &b); end
+  def location_rerun_argument(*a, &b); end
+  def metadata(*a, &b); end
+  def parameters(*a, &b); end
+  def pending(*a, &b); end
+  def pending?(*a, &b); end
+  def reporter(*a, &b); end
+  def rerun_argument(*a, &b); end
+  def run(*args, &block); end
+  def run_with_retry(opts = T.unsafe(nil)); end
+  def skip(*a, &b); end
+  def skipped?(*a, &b); end
+  def source_location(*a, &b); end
+  def to_proc; end
+  def update_inherited_metadata(*a, &b); end
+  def wrap(&block); end
+  def yield(*a, &b); end
+end
+
+class RSpec::Core::ExampleGroup
+  include ::RSpec::Core::MemoizedHelpers
+  include ::RSpec::Core::Pending
+  extend ::RSpec::Core::Hooks
+  extend ::RSpec::Core::MemoizedHelpers::ClassMethods
+  extend ::RSpec::Core::SharedExampleGroup
+
+  def initialize(inspect_output = T.unsafe(nil)); end
+
+  def clear_lets; end
+  def clear_memoized; end
+  def described_class; end
+  def inspect; end
+
+  private
+
+  def method_missing(name, *args); end
+
+  class << self
+    def add_example(example); end
+    def before_context_ivars; end
+    def children; end
+    def context(*args, &example_group_block); end
+    def currently_executing_a_context_hook?; end
+    def declaration_locations; end
+    def define_example_group_method(name, metadata = T.unsafe(nil)); end
+    def define_example_method(name, extra_options = T.unsafe(nil)); end
+    def define_nested_shared_group_method(new_name, report_label = T.unsafe(nil)); end
+    def delegate_to_metadata(*names); end
+    def descendant_filtered_examples; end
+    def descendants; end
+    def describe(*args, &example_group_block); end
+    def described_class; end
+    def description; end
+    def each_instance_variable_for_example(group); end
+    def ensure_example_groups_are_configured; end
+    def example(*all_args, &block); end
+    def example_group(*args, &example_group_block); end
+    def examples; end
+    def fcontext(*args, &example_group_block); end
+    def fdescribe(*args, &example_group_block); end
+    def fexample(*all_args, &block); end
+    def file_path; end
+    def filtered_examples; end
+    def find_and_eval_shared(label, name, inclusion_location, *args, &customization_block); end
+    def fit(*all_args, &block); end
+    def focus(*all_args, &block); end
+    def for_filtered_examples(reporter, &block); end
+    def fspecify(*all_args, &block); end
+    def id; end
+    def idempotently_define_singleton_method(name, &definition); end
+    def include_context(name, *args, &block); end
+    def include_examples(name, *args, &block); end
+    def it(*all_args, &block); end
+    def it_behaves_like(name, *args, &customization_block); end
+    def it_should_behave_like(name, *args, &customization_block); end
+    def location; end
+    def metadata; end
+    def next_runnable_index_for(file); end
+    def ordering_strategy; end
+    def parent_groups; end
+    def pending(*all_args, &block); end
+    def remove_example(example); end
+    def reset_memoized; end
+    def run(reporter = T.unsafe(nil)); end
+    def run_after_context_hooks(example_group_instance); end
+    def run_before_context_hooks(example_group_instance); end
+    def run_examples(reporter); end
+    def set_it_up(description, args, registration_collection, &example_group_block); end
+    def set_ivars(instance, ivars); end
+    def skip(*all_args, &block); end
+    def specify(*all_args, &block); end
+    def store_before_context_ivars(example_group_instance); end
+    def subclass(parent, description, args, registration_collection, &example_group_block); end
+    def superclass_before_context_ivars; end
+    def superclass_metadata; end
+    def top_level?; end
+    def top_level_description; end
+    def traverse_tree_until(&block); end
+    def update_inherited_metadata(updates); end
+    def with_replaced_metadata(meta); end
+    def xcontext(*args, &example_group_block); end
+    def xdescribe(*args, &example_group_block); end
+    def xexample(*all_args, &block); end
+    def xit(*all_args, &block); end
+    def xspecify(*all_args, &block); end
+
+    private
+
+    def method_missing(name, *args); end
+  end
+end
+
+RSpec::Core::ExampleGroup::INSTANCE_VARIABLE_TO_IGNORE = T.let(T.unsafe(nil), Symbol)
+class RSpec::Core::ExampleGroup::WrongScopeError < ::NoMethodError; end
+
+class RSpec::Core::ExampleStatusDumper
+  def initialize(examples); end
+
+  def dump; end
+
+  private
+
+  def column_widths; end
+  def formatted_header_rows; end
+  def formatted_row_from(row_values); end
+  def formatted_value_rows; end
+  def headers; end
+  def rows; end
+
+  class << self
+    def dump(examples); end
+  end
+end
+
+class RSpec::Core::ExampleStatusMerger
+  def initialize(this_run, from_previous_runs); end
+
+  def merge; end
+
+  private
+
+  def delete_previous_examples_that_no_longer_exist; end
+  def example_must_no_longer_exist?(ex_id); end
+  def hash_from(example_list); end
+  def loaded_spec_files; end
+  def sort_value_from(example); end
+  def spec_file_from(ex_id); end
+
+  class << self
+    def merge(this_run, from_previous_runs); end
+  end
+end
+
+class RSpec::Core::ExampleStatusParser
+  def initialize(string); end
+
+  def parse; end
+
+  private
+
+  def headers; end
+  def parse_row(line); end
+  def split_line(line); end
+
+  class << self
+    def parse(string); end
+  end
+end
+
+class RSpec::Core::ExampleStatusPersister
+  def initialize(examples, file_name); end
+
+  def persist; end
+
+  private
+
+  def dump_statuses(unparsed_previous_runs); end
+  def statuses_from_this_run; end
+
+  class << self
+    def load_from(file_name); end
+    def persist(examples, file_name); end
+  end
+end
+
+RSpec::Core::ExclusionRules = RSpec::Core::FilterRules
+
+class RSpec::Core::FilterManager
+  def initialize; end
+
+  def add_ids(rerun_path, scoped_ids); end
+  def add_location(file_path, line_numbers); end
+  def empty?; end
+  def exclude(*args); end
+  def exclude_only(*args); end
+  def exclude_with_low_priority(*args); end
+  def exclusions; end
+  def include(*args); end
+  def include_only(*args); end
+  def include_with_low_priority(*args); end
+  def inclusions; end
+  def prune(examples); end
+
+  private
+
+  def add_path_to_arrays_filter(filter_key, path, values); end
+  def file_scoped_include?(ex_metadata, ids, locations); end
+  def prune_conditionally_filtered_examples(examples); end
+end
+
+class RSpec::Core::FilterRules
+  def initialize(rules = T.unsafe(nil)); end
+
+  def [](key); end
+  def add(updated); end
+  def add_with_low_priority(updated); end
+  def clear; end
+  def delete(key); end
+  def description; end
+  def each_pair(&block); end
+  def empty?; end
+  def fetch(*args, &block); end
+  def include_example?(example); end
+  def opposite; end
+  def opposite=(_arg0); end
+  def rules; end
+  def use_only(updated); end
+
+  class << self
+    def build; end
+  end
+end
+
+RSpec::Core::FilterRules::PROC_HEX_NUMBER = T.let(T.unsafe(nil), Regexp)
+RSpec::Core::FilterRules::PROJECT_DIR = T.let(T.unsafe(nil), String)
+module RSpec::Core::FilterableItemRepository; end
+
+class RSpec::Core::FilterableItemRepository::QueryOptimized < ::RSpec::Core::FilterableItemRepository::UpdateOptimized
+  def initialize(applies_predicate); end
+
+  def append(item, metadata); end
+  def delete(item, metadata); end
+  def items_for(metadata); end
+  def prepend(item, metadata); end
+
+  private
+
+  def applicable_metadata_from(metadata); end
+  def find_items_for(request_meta); end
+  def handle_mutation(metadata); end
+  def proc_keys_from(metadata); end
+  def reconstruct_caches; end
+end
+
+class RSpec::Core::FilterableItemRepository::UpdateOptimized
+  def initialize(applies_predicate); end
+
+  def append(item, metadata); end
+  def delete(item, metadata); end
+  def items_and_filters; end
+  def items_for(request_meta); end
+  def prepend(item, metadata); end
+end
+
+module RSpec::Core::FlatMap
+  private
+
+  def flat_map(array, &block); end
+
+  class << self
+    def flat_map(array, &block); end
+  end
+end
+
+module RSpec::Core::Formatters
+  class << self
+    def register(formatter_class, *notifications); end
+  end
+end
+
+class RSpec::Core::Formatters::BaseBisectFormatter
+  def initialize(expected_failures); end
+
+  def example_failed(notification); end
+  def example_finished(notification); end
+  def start_dump(_notification); end
+
+  class << self
+    def inherited(formatter); end
+  end
+end
+
+class RSpec::Core::Formatters::BaseFormatter
+  def initialize(output); end
+
+  def close(_notification); end
+  def example_group; end
+  def example_group=(_arg0); end
+  def example_group_started(notification); end
+  def output; end
+  def start(notification); end
+
+  private
+
+  def output_supports_sync; end
+  def restore_sync_output; end
+  def start_sync_output; end
+end
+
+class RSpec::Core::Formatters::BaseTextFormatter < ::RSpec::Core::Formatters::BaseFormatter
+  def close(_notification); end
+  def dump_failures(notification); end
+  def dump_pending(notification); end
+  def dump_summary(summary); end
+  def message(notification); end
+  def seed(notification); end
+end
+
+class RSpec::Core::Formatters::BisectDRbFormatter < ::RSpec::Core::Formatters::BaseBisectFormatter
+  def initialize(_output); end
+
+  def notify_results(results); end
+end
+
+module RSpec::Core::Formatters::ConsoleCodes
+  private
+
+  def config_colors_to_methods; end
+  def console_code_for(code_or_symbol); end
+  def wrap(text, code_or_symbol); end
+
+  class << self
+    def config_colors_to_methods; end
+    def console_code_for(code_or_symbol); end
+    def wrap(text, code_or_symbol); end
+  end
+end
+
+RSpec::Core::Formatters::ConsoleCodes::VT100_CODES = T.let(T.unsafe(nil), Hash)
+RSpec::Core::Formatters::ConsoleCodes::VT100_CODE_VALUES = T.let(T.unsafe(nil), Hash)
+
+class RSpec::Core::Formatters::DeprecationFormatter
+  def initialize(deprecation_stream, summary_stream); end
+
+  def count; end
+  def deprecation(notification); end
+  def deprecation_message_for(data); end
+  def deprecation_stream; end
+  def deprecation_summary(_notification); end
+  def output; end
+  def printer; end
+  def summary_stream; end
+end
+
+RSpec::Core::Formatters::DeprecationFormatter::DEPRECATION_STREAM_NOTICE = T.let(T.unsafe(nil), String)
+
+class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter
+  def initialize(deprecation_stream, summary_stream, deprecation_formatter); end
+
+  def deprecation_formatter; end
+  def deprecation_stream; end
+  def deprecation_summary; end
+  def print_deferred_deprecation_warnings; end
+  def print_deprecation_message(data); end
+  def stash_deprecation_message(deprecation_message); end
+  def summary_stream; end
+end
+
+RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter::TOO_MANY_USES_LIMIT = T.let(T.unsafe(nil), Integer)
+
+class RSpec::Core::Formatters::DeprecationFormatter::FileStream
+  def initialize(file); end
+
+  def puts(*args); end
+  def summarize(summary_stream, deprecation_count); end
+end
+
+class RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage < ::Struct
+  def initialize(data); end
+
+  def to_s; end
+  def too_many_warnings_message; end
+  def type; end
+  def type=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class RSpec::Core::Formatters::DeprecationFormatter::ImmediatePrinter
+  def initialize(deprecation_stream, summary_stream, deprecation_formatter); end
+
+  def deprecation_formatter; end
+  def deprecation_stream; end
+  def deprecation_summary; end
+  def print_deprecation_message(data); end
+  def summary_stream; end
+end
+
+RSpec::Core::Formatters::DeprecationFormatter::RAISE_ERROR_CONFIG_NOTICE = T.let(T.unsafe(nil), String)
+
+class RSpec::Core::Formatters::DeprecationFormatter::RaiseErrorStream
+  def puts(message); end
+  def summarize(summary_stream, deprecation_count); end
+end
+
+class RSpec::Core::Formatters::DeprecationFormatter::SpecifiedDeprecationMessage < ::Struct
+  def initialize(data); end
+
+  def to_s; end
+  def too_many_warnings_message; end
+  def type; end
+  def type=(_); end
+
+  private
+
+  def deprecation_type_for(data); end
+  def output_formatted(str); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+RSpec::Core::Formatters::DeprecationFormatter::TOO_MANY_WARNINGS_NOTICE = T.let(T.unsafe(nil), String)
+
+class RSpec::Core::Formatters::DocumentationFormatter < ::RSpec::Core::Formatters::BaseTextFormatter
+  def initialize(output); end
+
+  def example_failed(failure); end
+  def example_group_finished(_notification); end
+  def example_group_started(notification); end
+  def example_passed(passed); end
+  def example_pending(pending); end
+  def example_started(_notification); end
+  def message(notification); end
+
+  private
+
+  def current_indentation(offset = T.unsafe(nil)); end
+  def failure_output(example); end
+  def flush_messages; end
+  def next_failure_index; end
+  def passed_output(example); end
+  def pending_output(example, message); end
+end
+
+class RSpec::Core::Formatters::ExceptionPresenter
+  def initialize(exception, example, options = T.unsafe(nil)); end
+
+  def colorized_formatted_backtrace(colorizer = T.unsafe(nil)); end
+  def colorized_message_lines(colorizer = T.unsafe(nil)); end
+  def description; end
+  def example; end
+  def exception; end
+  def formatted_backtrace(exception = T.unsafe(nil)); end
+  def formatted_cause(exception); end
+  def fully_formatted(failure_number, colorizer = T.unsafe(nil)); end
+  def fully_formatted_lines(failure_number, colorizer); end
+  def message_lines; end
+
+  private
+
+  def add_shared_group_lines(lines, colorizer); end
+  def backtrace_formatter; end
+  def detail_formatter; end
+  def encoded_description(description); end
+  def encoded_string(string); end
+  def encoding_of(string); end
+  def exception_backtrace; end
+  def exception_class_name(exception = T.unsafe(nil)); end
+  def exception_lines; end
+  def exception_message_string(exception); end
+  def extra_detail_formatter; end
+  def extra_failure_lines; end
+  def failure_lines; end
+  def failure_slash_error_lines; end
+  def final_exception(exception, previous = T.unsafe(nil)); end
+  def find_failed_line; end
+  def formatted_message_and_backtrace(colorizer); end
+  def indent_lines(lines, failure_number); end
+  def message_color; end
+  def read_failed_lines; end
+end
+
+class RSpec::Core::Formatters::ExceptionPresenter::Factory
+  def initialize(example); end
+
+  def build; end
+
+  private
+
+  def multiple_exception_summarizer(exception, prior_detail_formatter, color); end
+  def multiple_exceptions_error?(exception); end
+  def options; end
+  def pending_options; end
+  def sub_failure_list_formatter(exception, message_color); end
+  def with_multiple_error_options_as_needed(exception, options); end
+end
+
+class RSpec::Core::Formatters::ExceptionPresenter::Factory::CommonBacktraceTruncater
+  def initialize(parent); end
+
+  def with_truncated_backtrace(child); end
+end
+
+module RSpec::Core::Formatters::ExceptionPresenter::Factory::EmptyBacktraceFormatter
+  class << self
+    def format_backtrace(*_arg0); end
+  end
+end
+
+RSpec::Core::Formatters::ExceptionPresenter::PENDING_DETAIL_FORMATTER = T.let(T.unsafe(nil), Proc)
+
+class RSpec::Core::Formatters::FailureListFormatter < ::RSpec::Core::Formatters::BaseFormatter
+  def dump_profile(_profile); end
+  def example_failed(failure); end
+  def message(_message); end
+end
+
+class RSpec::Core::Formatters::FallbackMessageFormatter
+  def initialize(output); end
+
+  def message(notification); end
+  def output; end
+end
+
+module RSpec::Core::Formatters::Helpers
+  class << self
+    def format_duration(duration); end
+    def format_seconds(float, precision = T.unsafe(nil)); end
+    def organize_ids(ids); end
+    def pluralize(count, string); end
+
+    private
+
+    def strip_trailing_zeroes(string); end
+  end
+end
+
+RSpec::Core::Formatters::Helpers::DEFAULT_PRECISION = T.let(T.unsafe(nil), Integer)
+RSpec::Core::Formatters::Helpers::SUB_SECOND_PRECISION = T.let(T.unsafe(nil), Integer)
+
+class RSpec::Core::Formatters::HtmlFormatter < ::RSpec::Core::Formatters::BaseFormatter
+  def initialize(output); end
+
+  def dump_summary(summary); end
+  def example_failed(failure); end
+  def example_group_started(notification); end
+  def example_passed(passed); end
+  def example_pending(pending); end
+  def example_started(_notification); end
+  def start(notification); end
+  def start_dump(_notification); end
+
+  private
+
+  def example_group_number; end
+  def example_number; end
+  def extra_failure_content(failure); end
+  def percent_done; end
+end
+
+class RSpec::Core::Formatters::HtmlPrinter
+  include ::ERB::Util
+
+  def initialize(output); end
+
+  def flush; end
+  def make_example_group_header_red(group_id); end
+  def make_example_group_header_yellow(group_id); end
+  def make_header_red; end
+  def make_header_yellow; end
+  def move_progress(percent_done); end
+  def print_example_failed(pending_fixed, description, run_time, failure_id, exception, extra_content); end
+  def print_example_group_end; end
+  def print_example_group_start(group_id, description, number_of_parents); end
+  def print_example_passed(description, run_time); end
+  def print_example_pending(description, pending_message); end
+  def print_html_start; end
+  def print_summary(duration, example_count, failure_count, pending_count); end
+
+  private
+
+  def indentation_style(number_of_parents); end
+end
+
+RSpec::Core::Formatters::HtmlPrinter::GLOBAL_SCRIPTS = T.let(T.unsafe(nil), String)
+RSpec::Core::Formatters::HtmlPrinter::GLOBAL_STYLES = T.let(T.unsafe(nil), String)
+RSpec::Core::Formatters::HtmlPrinter::HTML_HEADER = T.let(T.unsafe(nil), String)
+RSpec::Core::Formatters::HtmlPrinter::REPORT_HEADER = T.let(T.unsafe(nil), String)
+
+class RSpec::Core::Formatters::JsonFormatter < ::RSpec::Core::Formatters::BaseFormatter
+  def initialize(output); end
+
+  def close(_notification); end
+  def dump_profile(profile); end
+  def dump_profile_slowest_example_groups(profile); end
+  def dump_profile_slowest_examples(profile); end
+  def dump_summary(summary); end
+  def message(notification); end
+  def output_hash; end
+  def seed(notification); end
+  def stop(notification); end
+
+  private
+
+  def format_example(example); end
+end
+
+class RSpec::Core::Formatters::Loader
+  def initialize(reporter); end
+
+  def add(formatter_to_use, *paths); end
+  def default_formatter; end
+  def default_formatter=(_arg0); end
+  def formatters; end
+  def prepare_default(output_stream, deprecation_stream); end
+  def reporter; end
+  def setup_default(output_stream, deprecation_stream); end
+
+  private
+
+  def built_in_formatter(key); end
+  def custom_formatter(formatter_ref); end
+  def duplicate_formatter_exists?(new_formatter); end
+  def existing_formatter_implements?(notification); end
+  def find_formatter(formatter_to_use); end
+  def notifications_for(formatter_class); end
+  def open_stream(path_or_wrapper); end
+  def path_for(const_ref); end
+  def register(formatter, notifications); end
+  def string_const?(str); end
+  def underscore(camel_cased_word); end
+  def underscore_with_fix_for_non_standard_rspec_naming(string); end
+
+  class << self
+    def formatters; end
+  end
+end
+
+class RSpec::Core::Formatters::ProfileFormatter
+  def initialize(output); end
+
+  def dump_profile(profile); end
+  def output; end
+
+  private
+
+  def bold(text); end
+  def dump_profile_slowest_example_groups(profile); end
+  def dump_profile_slowest_examples(profile); end
+  def format_caller(caller_info); end
+end
+
+class RSpec::Core::Formatters::ProgressFormatter < ::RSpec::Core::Formatters::BaseTextFormatter
+  def example_failed(_notification); end
+  def example_passed(_notification); end
+  def example_pending(_notification); end
+  def start_dump(_notification); end
+end
+
+class RSpec::Core::Formatters::SnippetExtractor
+  def initialize(source, beginning_line_number, max_line_count = T.unsafe(nil)); end
+
+  def beginning_line_number; end
+  def expression_lines; end
+  def max_line_count; end
+  def source; end
+
+  private
+
+  def expression_node; end
+  def expression_outmost_node?(node); end
+  def line_range_of_expression; end
+  def line_range_of_location_nodes_in_expression; end
+  def location_nodes_at_beginning_line; end
+  def unclosed_tokens_in_line_range(line_range); end
+
+  class << self
+    def extract_expression_lines_at(file_path, beginning_line_number, max_line_count = T.unsafe(nil)); end
+    def extract_line_at(file_path, line_number); end
+    def least_indentation_from(lines); end
+    def source_from_file(path); end
+  end
+end
+
+class RSpec::Core::Formatters::SnippetExtractor::NoExpressionAtLineError < ::StandardError; end
+class RSpec::Core::Formatters::SnippetExtractor::NoSuchFileError < ::StandardError; end
+class RSpec::Core::Formatters::SnippetExtractor::NoSuchLineError < ::StandardError; end
+
+class RSpec::Core::Formatters::SyntaxHighlighter
+  def initialize(configuration); end
+
+  def highlight(lines); end
+
+  private
+
+  def color_enabled_implementation; end
+  def implementation; end
+
+  class << self
+    def attempt_to_add_rspec_terms_to_coderay_keywords; end
+  end
+end
+
+module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation
+  class << self
+    def highlight_syntax(lines); end
+  end
+end
+
+RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation::RESET_CODE = T.let(T.unsafe(nil), String)
+
+module RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
+  class << self
+    def highlight_syntax(lines); end
+  end
+end
+
+RSpec::Core::Formatters::SyntaxHighlighter::WindowsImplementation = RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
+
+module RSpec::Core::HashImitatable
+  mixes_in_class_methods ::RSpec::Core::HashImitatable::ClassMethods
+
+  def <(*args, &block); end
+  def <=(*args, &block); end
+  def >(*args, &block); end
+  def >=(*args, &block); end
+  def [](key); end
+  def []=(key, value); end
+  def all?(*args, &block); end
+  def any?(*args, &block); end
+  def assoc(*args, &block); end
+  def chain(*args, &block); end
+  def chunk(*args, &block); end
+  def chunk_while(*args, &block); end
+  def clear(*args, &block); end
+  def collect(*args, &block); end
+  def collect_concat(*args, &block); end
+  def compact(*args, &block); end
+  def compact!(*args, &block); end
+  def compare_by_identity(*args, &block); end
+  def compare_by_identity?(*args, &block); end
+  def count(*args, &block); end
+  def cycle(*args, &block); end
+  def deep_merge(*args, &block); end
+  def deep_merge!(*args, &block); end
+  def default(*args, &block); end
+  def default=(*args, &block); end
+  def default_proc(*args, &block); end
+  def default_proc=(*args, &block); end
+  def delete(*args, &block); end
+  def delete_if(*args, &block); end
+  def detect(*args, &block); end
+  def dig(*args, &block); end
+  def drop(*args, &block); end
+  def drop_while(*args, &block); end
+  def each(*args, &block); end
+  def each_cons(*args, &block); end
+  def each_entry(*args, &block); end
+  def each_key(*args, &block); end
+  def each_pair(*args, &block); end
+  def each_slice(*args, &block); end
+  def each_value(*args, &block); end
+  def each_with_index(*args, &block); end
+  def each_with_object(*args, &block); end
+  def empty?(*args, &block); end
+  def entries(*args, &block); end
+  def except(*args, &block); end
+  def except!(*args, &block); end
+  def extract!(*args, &block); end
+  def fetch(*args, &block); end
+  def fetch_values(*args, &block); end
+  def filter(*args, &block); end
+  def filter!(*args, &block); end
+  def find(*args, &block); end
+  def find_all(*args, &block); end
+  def find_index(*args, &block); end
+  def first(*args, &block); end
+  def flat_map(*args, &block); end
+  def flatten(*args, &block); end
+  def grep(*args, &block); end
+  def grep_v(*args, &block); end
+  def group_by(*args, &block); end
+  def has_key?(*args, &block); end
+  def has_value?(*args, &block); end
+  def include?(*args, &block); end
+  def index(*args, &block); end
+  def inject(*args, &block); end
+  def invert(*args, &block); end
+  def keep_if(*args, &block); end
+  def key(*args, &block); end
+  def key?(*args, &block); end
+  def keys(*args, &block); end
+  def lazy(*args, &block); end
+  def length(*args, &block); end
+  def map(*args, &block); end
+  def max(*args, &block); end
+  def max_by(*args, &block); end
+  def member?(*args, &block); end
+  def merge(*args, &block); end
+  def merge!(*args, &block); end
+  def min(*args, &block); end
+  def min_by(*args, &block); end
+  def minmax(*args, &block); end
+  def minmax_by(*args, &block); end
+  def none?(*args, &block); end
+  def one?(*args, &block); end
+  def partition(*args, &block); end
+  def rassoc(*args, &block); end
+  def reduce(*args, &block); end
+  def rehash(*args, &block); end
+  def reject(*args, &block); end
+  def reject!(*args, &block); end
+  def replace(*args, &block); end
+  def reverse_each(*args, &block); end
+  def save_plist(*args, &block); end
+  def select(*args, &block); end
+  def select!(*args, &block); end
+  def shift(*args, &block); end
+  def size(*args, &block); end
+  def slice(*args, &block); end
+  def slice!(*args, &block); end
+  def slice_after(*args, &block); end
+  def slice_before(*args, &block); end
+  def slice_when(*args, &block); end
+  def sort(*args, &block); end
+  def sort_by(*args, &block); end
+  def store(*args, &block); end
+  def sum(*args, &block); end
+  def take(*args, &block); end
+  def take_while(*args, &block); end
+  def to_a(*args, &block); end
+  def to_h; end
+  def to_hash(*args, &block); end
+  def to_msgpack(*args, &block); end
+  def to_plist(*args, &block); end
+  def to_proc(*args, &block); end
+  def to_set(*args, &block); end
+  def transform_keys(*args, &block); end
+  def transform_keys!(*args, &block); end
+  def transform_values(*args, &block); end
+  def transform_values!(*args, &block); end
+  def uniq(*args, &block); end
+  def update(*args, &block); end
+  def value?(*args, &block); end
+  def values(*args, &block); end
+  def values_at(*args, &block); end
+  def zip(*args, &block); end
+
+  private
+
+  def directly_supports_attribute?(name); end
+  def extra_hash_attributes; end
+  def get_value(name); end
+  def hash_for_delegation; end
+  def issue_deprecation(_method_name, *_args); end
+  def set_value(name, value); end
+
+  class << self
+    def included(klass); end
+  end
+end
+
+module RSpec::Core::HashImitatable::ClassMethods
+  def attr_accessor(*names); end
+  def hash_attribute_names; end
+end
+
+module RSpec::Core::Hooks
+  def after(*args, &block); end
+  def append_after(*args, &block); end
+  def append_before(*args, &block); end
+  def around(*args, &block); end
+  def before(*args, &block); end
+  def hooks; end
+  def prepend_after(*args, &block); end
+  def prepend_before(*args, &block); end
+end
+
+class RSpec::Core::Hooks::AfterContextHook < ::RSpec::Core::Hooks::Hook
+  def run(example); end
+end
+
+class RSpec::Core::Hooks::AfterHook < ::RSpec::Core::Hooks::Hook
+  def run(example); end
+end
+
+class RSpec::Core::Hooks::AroundHook < ::RSpec::Core::Hooks::Hook
+  def execute_with(example, procsy); end
+  def hook_description; end
+end
+
+class RSpec::Core::Hooks::BeforeHook < ::RSpec::Core::Hooks::Hook
+  def run(example); end
+end
+
+class RSpec::Core::Hooks::Hook < ::Struct
+  def block; end
+  def block=(_); end
+  def options; end
+  def options=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class RSpec::Core::Hooks::HookCollections
+  def initialize(owner, filterable_item_repo_class); end
+
+  def register(prepend_or_append, position, *args, &block); end
+  def register_global_singleton_context_hooks(example, globals); end
+  def register_globals(host, globals); end
+  def run(position, scope, example_or_group); end
+
+  protected
+
+  def all_hooks_for(position, scope); end
+  def matching_hooks_for(position, scope, example_or_group); end
+  def processable_hooks_for(position, scope, host); end
+  def run_owned_hooks_for(position, scope, example_or_group); end
+
+  private
+
+  def ensure_hooks_initialized_for(position, scope); end
+  def extract_scope_from(args); end
+  def hooks_for(position, scope); end
+  def known_scope?(scope); end
+  def normalized_scope_for(scope); end
+  def owner_parent_groups; end
+  def process(host, parent_groups, globals, position, scope); end
+  def run_around_example_hooks_for(example); end
+  def run_example_hooks_for(example, position, each_method); end
+  def scope_and_options_from(*args); end
+end
+
+RSpec::Core::Hooks::HookCollections::EMPTY_HOOK_ARRAY = T.let(T.unsafe(nil), Array)
+RSpec::Core::Hooks::HookCollections::HOOK_TYPES = T.let(T.unsafe(nil), Hash)
+RSpec::Core::Hooks::HookCollections::SCOPES = T.let(T.unsafe(nil), Array)
+RSpec::Core::Hooks::HookCollections::SCOPE_ALIASES = T.let(T.unsafe(nil), Hash)
+
+class RSpec::Core::InclusionRules < ::RSpec::Core::FilterRules
+  def add(*args); end
+  def add_with_low_priority(*args); end
+  def include_example?(example); end
+  def split_file_scoped_rules; end
+  def standalone?; end
+
+  private
+
+  def apply_standalone_filter(updated); end
+  def is_standalone_filter?(rules); end
+  def replace_filters(new_rules); end
+end
+
+module RSpec::Core::Invocations; end
+
+class RSpec::Core::Invocations::Bisect
+  def call(options, err, out); end
+
+  private
+
+  def bisect_formatter_klass_for(argument); end
+end
+
+class RSpec::Core::Invocations::DRbWithFallback
+  def call(options, err, out); end
+end
+
+class RSpec::Core::Invocations::InitializeProject
+  def call(*_args); end
+end
+
+class RSpec::Core::Invocations::PrintHelp < ::Struct
+  def call(_options, _err, out); end
+  def hidden_options; end
+  def hidden_options=(_); end
+  def parser; end
+  def parser=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class RSpec::Core::Invocations::PrintVersion
+  def call(_options, _err, out); end
+end
+
+class RSpec::Core::LegacyExampleGroupHash
+  include ::RSpec::Core::HashImitatable
+  extend ::RSpec::Core::HashImitatable::ClassMethods
+
+  def initialize(metadata); end
+
+  def to_h; end
+
+  private
+
+  def directly_supports_attribute?(name); end
+  def get_value(name); end
+  def set_value(name, value); end
+end
+
+module RSpec::Core::MemoizedHelpers
+  def initialize(*_arg0); end
+
+  def is_expected; end
+  def should(matcher = T.unsafe(nil), message = T.unsafe(nil)); end
+  def should_not(matcher = T.unsafe(nil), message = T.unsafe(nil)); end
+  def subject; end
+
+  private
+
+  def __init_memoized; end
+  def __memoized; end
+
+  class << self
+    def define_helpers_on(example_group); end
+    def get_constant_or_yield(example_group, name); end
+    def module_for(example_group); end
+  end
+end
+
+module RSpec::Core::MemoizedHelpers::ClassMethods
+  def let(name, &block); end
+  def let!(name, &block); end
+  def subject(name = T.unsafe(nil), &block); end
+  def subject!(name = T.unsafe(nil), &block); end
+end
+
+class RSpec::Core::MemoizedHelpers::ContextHookMemoized
+  class << self
+    def fetch_or_store(key, &_block); end
+    def isolate_for_context_hook(example_group_instance); end
+  end
+end
+
+class RSpec::Core::MemoizedHelpers::ContextHookMemoized::After < ::RSpec::Core::MemoizedHelpers::ContextHookMemoized
+  class << self
+    def article; end
+    def hook_expression; end
+    def hook_intention; end
+  end
+end
+
+class RSpec::Core::MemoizedHelpers::ContextHookMemoized::Before < ::RSpec::Core::MemoizedHelpers::ContextHookMemoized
+  class << self
+    def article; end
+    def hook_expression; end
+    def hook_intention; end
+  end
+end
+
+class RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized
+  def initialize; end
+
+  def fetch_or_store(key); end
+end
+
+class RSpec::Core::MemoizedHelpers::ThreadsafeMemoized
+  def initialize; end
+
+  def fetch_or_store(key); end
+end
+
+module RSpec::Core::Metadata
+  class << self
+    def ascend(metadata); end
+    def ascending(metadata); end
+    def build_hash_from(args, warn_about_example_group_filtering = T.unsafe(nil)); end
+    def deep_hash_dup(object); end
+    def id_from(metadata); end
+    def location_tuple_from(metadata); end
+    def relative_path(line); end
+    def relative_path_regex; end
+  end
+end
+
+class RSpec::Core::Metadata::ExampleGroupHash < ::RSpec::Core::Metadata::HashPopulator
+  private
+
+  def described_class; end
+  def full_description; end
+
+  class << self
+    def backwards_compatibility_default_proc(&example_group_selector); end
+    def create(parent_group_metadata, user_metadata, example_group_index, *args, &block); end
+    def hash_with_backwards_compatibility_default_proc; end
+  end
+end
+
+class RSpec::Core::Metadata::ExampleHash < ::RSpec::Core::Metadata::HashPopulator
+  private
+
+  def described_class; end
+  def full_description; end
+
+  class << self
+    def create(group_metadata, user_metadata, index_provider, description, block); end
+  end
+end
+
+class RSpec::Core::Metadata::HashPopulator
+  def initialize(metadata, user_metadata, index_provider, description_args, block); end
+
+  def block; end
+  def description_args; end
+  def metadata; end
+  def populate; end
+  def user_metadata; end
+
+  private
+
+  def build_description_from(parent_description = T.unsafe(nil), my_description = T.unsafe(nil)); end
+  def build_scoped_id_for(file_path); end
+  def description_separator(parent_part, child_part); end
+  def ensure_valid_user_keys; end
+  def file_path_and_line_number_from(backtrace); end
+  def populate_location_attributes; end
+end
+
+RSpec::Core::Metadata::RESERVED_KEYS = T.let(T.unsafe(nil), Array)
+
+module RSpec::Core::MetadataFilter
+  class << self
+    def apply?(predicate, filters, metadata); end
+    def filter_applies?(key, filter_value, metadata); end
+    def silence_metadata_example_group_deprecations; end
+
+    private
+
+    def filter_applies_to_any_value?(key, value, metadata); end
+    def filters_apply?(key, value, metadata); end
+    def id_filter_applies?(rerun_paths_to_scoped_ids, metadata); end
+    def location_filter_applies?(locations, metadata); end
+    def proc_filter_applies?(key, proc, metadata); end
+  end
+end
+
+class RSpec::Core::MultipleExceptionError < ::StandardError
+  include ::RSpec::Core::MultipleExceptionError::InterfaceTag
+
+  def initialize(*exceptions); end
+
+  def aggregation_block_label; end
+  def aggregation_metadata; end
+  def all_exceptions; end
+  def exception_count_description; end
+  def failures; end
+  def message; end
+  def other_errors; end
+  def summary; end
+end
+
+module RSpec::Core::MultipleExceptionError::InterfaceTag
+  def add(exception); end
+
+  class << self
+    def for(ex); end
+  end
+end
+
+module RSpec::Core::Notifications; end
+
+class RSpec::Core::Notifications::CustomNotification < ::Struct
+  class << self
+    def for(options = T.unsafe(nil)); end
+  end
+end
+
+class RSpec::Core::Notifications::DeprecationNotification < ::Struct
+  def call_site; end
+  def call_site=(_); end
+  def deprecated; end
+  def deprecated=(_); end
+  def message; end
+  def message=(_); end
+  def replacement; end
+  def replacement=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def from_hash(data); end
+    def inspect; end
+    def members; end
+
+    private
+
+    def new(*_arg0); end
+  end
+end
+
+class RSpec::Core::Notifications::ExampleNotification < ::Struct
+  def example; end
+  def example=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def for(example); end
+    def inspect; end
+    def members; end
+
+    private
+
+    def new(*_arg0); end
+  end
+end
+
+class RSpec::Core::Notifications::ExamplesNotification
+  def initialize(reporter); end
+
+  def examples; end
+  def failed_examples; end
+  def failure_notifications; end
+  def fully_formatted_failed_examples(colorizer = T.unsafe(nil)); end
+  def fully_formatted_pending_examples(colorizer = T.unsafe(nil)); end
+  def notifications; end
+  def pending_examples; end
+  def pending_notifications; end
+
+  private
+
+  def format_examples(examples); end
+end
+
+class RSpec::Core::Notifications::FailedExampleNotification < ::RSpec::Core::Notifications::ExampleNotification
+  def initialize(example, exception_presenter = T.unsafe(nil)); end
+
+  def colorized_formatted_backtrace(colorizer = T.unsafe(nil)); end
+  def colorized_message_lines(colorizer = T.unsafe(nil)); end
+  def description; end
+  def exception; end
+  def formatted_backtrace; end
+  def fully_formatted(failure_number, colorizer = T.unsafe(nil)); end
+  def fully_formatted_lines(failure_number, colorizer = T.unsafe(nil)); end
+  def message_lines; end
+end
+
+class RSpec::Core::Notifications::GroupNotification < ::Struct
+  def group; end
+  def group=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class RSpec::Core::Notifications::MessageNotification < ::Struct
+  def message; end
+  def message=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+module RSpec::Core::Notifications::NullColorizer
+  private
+
+  def wrap(line, _code_or_symbol); end
+
+  class << self
+    def wrap(line, _code_or_symbol); end
+  end
+end
+
+class RSpec::Core::Notifications::NullNotification; end
+class RSpec::Core::Notifications::PendingExampleFailedAsExpectedNotification < ::RSpec::Core::Notifications::FailedExampleNotification; end
+class RSpec::Core::Notifications::PendingExampleFixedNotification < ::RSpec::Core::Notifications::FailedExampleNotification; end
+
+class RSpec::Core::Notifications::ProfileNotification
+  def initialize(duration, examples, number_of_examples, example_groups); end
+
+  def duration; end
+  def examples; end
+  def number_of_examples; end
+  def percentage; end
+  def slow_duration; end
+  def slowest_examples; end
+  def slowest_groups; end
+
+  private
+
+  def calculate_slowest_groups; end
+end
+
+class RSpec::Core::Notifications::SeedNotification < ::Struct
+  def fully_formatted; end
+  def seed; end
+  def seed=(_); end
+  def seed_used?; end
+  def used=(_); end
+
+  private
+
+  def used; end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class RSpec::Core::Notifications::SkippedExampleNotification < ::RSpec::Core::Notifications::ExampleNotification
+  def fully_formatted(pending_number, colorizer = T.unsafe(nil)); end
+end
+
+class RSpec::Core::Notifications::StartNotification < ::Struct
+  def count; end
+  def count=(_); end
+  def load_time; end
+  def load_time=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class RSpec::Core::Notifications::SummaryNotification < ::Struct
+  include ::RSpec::Core::ShellEscape
+
+  def colorized_rerun_commands(colorizer = T.unsafe(nil)); end
+  def colorized_totals_line(colorizer = T.unsafe(nil)); end
+  def duration; end
+  def duration=(_); end
+  def errors_outside_of_examples_count; end
+  def errors_outside_of_examples_count=(_); end
+  def example_count; end
+  def examples; end
+  def examples=(_); end
+  def failed_examples; end
+  def failed_examples=(_); end
+  def failure_count; end
+  def formatted_duration; end
+  def formatted_load_time; end
+  def fully_formatted(colorizer = T.unsafe(nil)); end
+  def load_time; end
+  def load_time=(_); end
+  def pending_count; end
+  def pending_examples; end
+  def pending_examples=(_); end
+  def totals_line; end
+
+  private
+
+  def duplicate_rerun_locations; end
+  def rerun_argument_for(example); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class RSpec::Core::NullReporter
+  class << self
+    private
+
+    def method_missing(*_arg0); end
+  end
+end
+
+module RSpec::Core::Ordering; end
+
+class RSpec::Core::Ordering::ConfigurationManager
+  def initialize; end
+
+  def force(hash); end
+  def order=(type); end
+  def ordering_registry; end
+  def register_ordering(name, strategy = T.unsafe(nil)); end
+  def seed; end
+  def seed=(seed); end
+  def seed_used?; end
+end
+
+class RSpec::Core::Ordering::Custom
+  def initialize(callable); end
+
+  def order(list); end
+end
+
+class RSpec::Core::Ordering::Identity
+  def order(items); end
+end
+
+class RSpec::Core::Ordering::Random
+  def initialize(configuration); end
+
+  def order(items); end
+  def used?; end
+
+  private
+
+  def jenkins_hash_digest(string); end
+end
+
+RSpec::Core::Ordering::Random::MAX_32_BIT = T.let(T.unsafe(nil), Integer)
+
+class RSpec::Core::Ordering::Registry
+  def initialize(configuration); end
+
+  def fetch(name, &fallback); end
+  def register(sym, strategy); end
+  def used_random_seed?; end
+end
+
+class RSpec::Core::OutputWrapper
+  def initialize(output); end
+
+  def <<(*args, &block); end
+  def advise(*args, &block); end
+  def autoclose=(*args, &block); end
+  def autoclose?(*args, &block); end
+  def beep(*args, &block); end
+  def binmode(*args, &block); end
+  def binmode?(*args, &block); end
+  def bytes(*args, &block); end
+  def chars(*args, &block); end
+  def close(*args, &block); end
+  def close_on_exec=(*args, &block); end
+  def close_on_exec?(*args, &block); end
+  def close_read(*args, &block); end
+  def close_write(*args, &block); end
+  def closed?(*args, &block); end
+  def codepoints(*args, &block); end
+  def cooked(*args, &block); end
+  def cooked!(*args, &block); end
+  def cursor(*args, &block); end
+  def cursor=(*args, &block); end
+  def each(*args, &block); end
+  def each_byte(*args, &block); end
+  def each_char(*args, &block); end
+  def each_codepoint(*args, &block); end
+  def each_line(*args, &block); end
+  def echo=(*args, &block); end
+  def echo?(*args, &block); end
+  def eof(*args, &block); end
+  def eof?(*args, &block); end
+  def external_encoding(*args, &block); end
+  def fcntl(*args, &block); end
+  def fdatasync(*args, &block); end
+  def fileno(*args, &block); end
+  def flush(*args, &block); end
+  def fsync(*args, &block); end
+  def getbyte(*args, &block); end
+  def getc(*args, &block); end
+  def getch(*args, &block); end
+  def getpass(*args, &block); end
+  def gets(*args, &block); end
+  def goto(*args, &block); end
+  def iflush(*args, &block); end
+  def inspect(*args, &block); end
+  def internal_encoding(*args, &block); end
+  def ioctl(*args, &block); end
+  def ioflush(*args, &block); end
+  def isatty(*args, &block); end
+  def lineno(*args, &block); end
+  def lineno=(*args, &block); end
+  def lines(*args, &block); end
+  def method_missing(name, *args, &block); end
+  def noecho(*args, &block); end
+  def nonblock(*args, &block); end
+  def nonblock=(*args, &block); end
+  def nonblock?(*args, &block); end
+  def nread(*args, &block); end
+  def oflush(*args, &block); end
+  def output; end
+  def output=(_arg0); end
+  def pathconf(*args, &block); end
+  def pid(*args, &block); end
+  def pos(*args, &block); end
+  def pos=(*args, &block); end
+  def pread(*args, &block); end
+  def pressed?(*args, &block); end
+  def print(*args, &block); end
+  def printf(*args, &block); end
+  def putc(*args, &block); end
+  def puts(*args, &block); end
+  def pwrite(*args, &block); end
+  def raw(*args, &block); end
+  def raw!(*args, &block); end
+  def read(*args, &block); end
+  def read_nonblock(*args, &block); end
+  def readbyte(*args, &block); end
+  def readchar(*args, &block); end
+  def readline(*args, &block); end
+  def readlines(*args, &block); end
+  def readpartial(*args, &block); end
+  def ready?(*args, &block); end
+  def reopen(*args, &block); end
+  def respond_to?(name, priv = T.unsafe(nil)); end
+  def rewind(*args, &block); end
+  def seek(*args, &block); end
+  def set_encoding(*args, &block); end
+  def stat(*args, &block); end
+  def sync(*args, &block); end
+  def sync=(*args, &block); end
+  def sysread(*args, &block); end
+  def sysseek(*args, &block); end
+  def syswrite(*args, &block); end
+  def tell(*args, &block); end
+  def to_i(*args, &block); end
+  def to_io(*args, &block); end
+  def tty?(*args, &block); end
+  def ungetbyte(*args, &block); end
+  def ungetc(*args, &block); end
+  def wait(*args, &block); end
+  def wait_readable(*args, &block); end
+  def wait_writable(*args, &block); end
+  def winsize(*args, &block); end
+  def winsize=(*args, &block); end
+  def write(*args, &block); end
+  def write_nonblock(*args, &block); end
+end
+
+class RSpec::Core::Parser
+  def initialize(original_args); end
+
+  def original_args; end
+  def parse(source = T.unsafe(nil)); end
+
+  private
+
+  def add_tag_filter(options, filter_type, tag_name, value = T.unsafe(nil)); end
+  def configure_only_failures(options); end
+  def parser(options); end
+  def set_fail_fast(options, value); end
+
+  class << self
+    def parse(args, source = T.unsafe(nil)); end
+  end
+end
+
+module RSpec::Core::Pending
+  def pending(message = T.unsafe(nil)); end
+  def skip(message = T.unsafe(nil)); end
+
+  class << self
+    def mark_fixed!(example); end
+    def mark_pending!(example, message_or_bool); end
+    def mark_skipped!(example, message_or_bool); end
+  end
+end
+
+RSpec::Core::Pending::NOT_YET_IMPLEMENTED = T.let(T.unsafe(nil), String)
+RSpec::Core::Pending::NO_REASON_GIVEN = T.let(T.unsafe(nil), String)
+class RSpec::Core::Pending::PendingExampleFixedError < ::StandardError; end
+
+class RSpec::Core::Pending::SkipDeclaredInExample < ::StandardError
+  def initialize(argument); end
+
+  def argument; end
+end
+
+class RSpec::Core::Profiler
+  def initialize; end
+
+  def example_group_finished(notification); end
+  def example_group_started(notification); end
+  def example_groups; end
+  def example_started(notification); end
+end
+
+RSpec::Core::Profiler::NOTIFICATIONS = T.let(T.unsafe(nil), Array)
+
+class RSpec::Core::Reporter
+  def initialize(configuration); end
+
+  def abort_with(msg, exit_status); end
+  def close_after; end
+  def deprecation(hash); end
+  def example_failed(example); end
+  def example_finished(example); end
+  def example_group_finished(group); end
+  def example_group_started(group); end
+  def example_passed(example); end
+  def example_pending(example); end
+  def example_started(example); end
+  def examples; end
+  def exit_early(exit_code); end
+  def fail_fast_limit_met?; end
+  def failed_examples; end
+  def finish; end
+  def message(message); end
+  def notify(event, notification); end
+  def notify_non_example_exception(exception, context_description); end
+  def pending_examples; end
+  def prepare_default(loader, output_stream, deprecation_stream); end
+  def publish(event, options = T.unsafe(nil)); end
+  def register_listener(listener, *notifications); end
+  def registered_listeners(notification); end
+  def report(expected_example_count); end
+  def start(expected_example_count, time = T.unsafe(nil)); end
+  def stop; end
+
+  private
+
+  def close; end
+  def ensure_listeners_ready; end
+  def mute_profile_output?; end
+  def seed_used?; end
+end
+
+RSpec::Core::Reporter::RSPEC_NOTIFICATIONS = T.let(T.unsafe(nil), RSpec::Core::Set)
+
+module RSpec::Core::RubyProject
+  private
+
+  def add_dir_to_load_path(dir); end
+  def add_to_load_path(*dirs); end
+  def ascend_until; end
+  def determine_root; end
+  def find_first_parent_containing(dir); end
+  def root; end
+
+  class << self
+    def add_dir_to_load_path(dir); end
+    def add_to_load_path(*dirs); end
+    def ascend_until; end
+    def determine_root; end
+    def find_first_parent_containing(dir); end
+    def root; end
+  end
+end
+
+class RSpec::Core::Runner
+  def initialize(options, configuration = T.unsafe(nil), world = T.unsafe(nil)); end
+
+  def configuration; end
+  def configure(err, out); end
+  def exit_code(examples_passed = T.unsafe(nil)); end
+  def options; end
+  def run(err, out); end
+  def run_specs(example_groups); end
+  def setup(err, out); end
+  def world; end
+
+  private
+
+  def persist_example_statuses; end
+
+  class << self
+    def autorun; end
+    def autorun_disabled?; end
+    def disable_autorun!; end
+    def handle_interrupt; end
+    def installed_at_exit?; end
+    def invoke; end
+    def perform_at_exit; end
+    def run(args, err = T.unsafe(nil), out = T.unsafe(nil)); end
+    def running_in_drb?; end
+    def trap_interrupt; end
+  end
+end
+
+class RSpec::Core::Set
+  include ::Enumerable
+
+  def initialize(array = T.unsafe(nil)); end
+
+  def <<(key); end
+  def clear; end
+  def delete(key); end
+  def each(&block); end
+  def empty?; end
+  def include?(key); end
+  def merge(values); end
+end
+
+module RSpec::Core::SharedContext
+  include ::RSpec::Its
+
+  def __shared_context_recordings; end
+  def after(*args, &block); end
+  def append_after(*args, &block); end
+  def append_before(*args, &block); end
+  def around(*args, &block); end
+  def before(*args, &block); end
+  def context(*args, &block); end
+  def describe(*args, &block); end
+  def hooks(*args, &block); end
+  def included(group); end
+  def let(*args, &block); end
+  def let!(*args, &block); end
+  def prepend_after(*args, &block); end
+  def prepend_before(*args, &block); end
+  def subject(*args, &block); end
+  def subject!(*args, &block); end
+
+  class << self
+    def record(methods); end
+  end
+end
+
+class RSpec::Core::SharedContext::Recording < ::Struct
+  def args; end
+  def args=(_); end
+  def block; end
+  def block=(_); end
+  def method_name; end
+  def method_name=(_); end
+  def playback_onto(group); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+module RSpec::Core::SharedExampleGroup
+  def shared_context(name, *args, &block); end
+  def shared_examples(name, *args, &block); end
+  def shared_examples_for(name, *args, &block); end
+end
+
+class RSpec::Core::SharedExampleGroup::Registry
+  def add(context, name, *metadata_args, &block); end
+  def find(lookup_contexts, name); end
+
+  private
+
+  def ensure_block_has_source_location(_block); end
+  def formatted_location(block); end
+  def legacy_add(context, name, *metadata_args, &block); end
+  def shared_example_groups; end
+  def valid_name?(candidate); end
+  def warn_if_key_taken(context, key, new_block); end
+end
+
+module RSpec::Core::SharedExampleGroup::TopLevelDSL
+  class << self
+    def definitions; end
+    def expose_globally!; end
+    def exposed_globally?; end
+    def remove_globally!; end
+  end
+end
+
+class RSpec::Core::SharedExampleGroupInclusionStackFrame
+  def initialize(shared_group_name, inclusion_location); end
+
+  def description; end
+  def formatted_inclusion_location; end
+  def inclusion_location; end
+  def shared_group_name; end
+
+  class << self
+    def current_backtrace; end
+    def shared_example_group_inclusions; end
+    def with_frame(name, location); end
+  end
+end
+
+class RSpec::Core::SharedExampleGroupModule < ::Module
+  def initialize(description, definition, metadata); end
+
+  def definition; end
+  def include_in(klass, inclusion_line, args, customization_block); end
+  def included(klass); end
+  def inspect; end
+  def to_s; end
+end
+
+module RSpec::Core::ShellEscape
+  private
+
+  def conditionally_quote(id); end
+  def escape(shell_command); end
+  def quote(argument); end
+  def shell_allows_unquoted_ids?; end
+
+  class << self
+    def conditionally_quote(id); end
+    def escape(shell_command); end
+    def quote(argument); end
+    def shell_allows_unquoted_ids?; end
+  end
+end
+
+RSpec::Core::ShellEscape::SHELLS_ALLOWING_UNQUOTED_IDS = T.let(T.unsafe(nil), Array)
+
+class RSpec::Core::SuiteHookContext < ::RSpec::Core::Example
+  def initialize(hook_description, reporter); end
+
+  def set_exception(exception); end
+end
+
+class RSpec::Core::Time
+  class << self
+    def now; end
+  end
+end
+
+module RSpec::Core::Version; end
+RSpec::Core::Version::STRING = T.let(T.unsafe(nil), String)
+
+module RSpec::Core::Warnings
+  def deprecate(deprecated, data = T.unsafe(nil)); end
+  def warn_deprecation(message, opts = T.unsafe(nil)); end
+  def warn_with(message, options = T.unsafe(nil)); end
+end
+
+class RSpec::Core::World
+  def initialize(configuration = T.unsafe(nil)); end
+
+  def all_example_groups; end
+  def all_examples; end
+  def announce_exclusion_filter(announcements); end
+  def announce_filters; end
+  def announce_inclusion_filter(announcements); end
+  def everything_filtered_message; end
+  def example_count(groups = T.unsafe(nil)); end
+  def example_group_counts_by_spec_file; end
+  def example_groups; end
+  def exclusion_filter; end
+  def filter_manager; end
+  def filtered_examples; end
+  def inclusion_filter; end
+  def non_example_failure; end
+  def non_example_failure=(_arg0); end
+  def num_example_groups_defined_in(file); end
+  def ordered_example_groups; end
+  def preceding_declaration_line(absolute_file_name, filter_line); end
+  def prepare_example_filtering; end
+  def record(example_group); end
+  def registered_example_group_files; end
+  def report_filter_message(message); end
+  def reporter; end
+  def reset; end
+  def shared_example_group_registry; end
+  def source_from_file(path); end
+  def syntax_highlighter; end
+  def traverse_example_group_trees_until(&block); end
+  def wants_to_quit; end
+  def wants_to_quit=(_arg0); end
+
+  private
+
+  def descending_declaration_line_numbers_by_file; end
+  def fail_if_config_and_cli_options_invalid; end
+end
+
+module RSpec::Core::World::Null
+  class << self
+    def all_example_groups; end
+    def example_groups; end
+    def non_example_failure; end
+    def non_example_failure=(_); end
+    def registered_example_group_files; end
+    def traverse_example_group_trees_until; end
+  end
+end
+
+module RSpec::ExampleGroups
+  extend ::RSpec::Support::RecursiveConstMethods
+
+  class << self
+    def assign_const(group); end
+    def base_name_for(group); end
+    def constant_scope_for(group); end
+    def disambiguate(name, const_scope); end
+    def remove_all_constants; end
+  end
+end
+
+RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
+RSpec::SharedContext = RSpec::Core::SharedContext
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-expectations@3.10.1.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-expectations@3.10.1.rbi
index 27d22b5379..0bd1746814 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-expectations@3.10.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rspec-expectations@3.10.1.rbi
@@ -1,8 +1,1605 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `rspec-expectations` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module RSpec
+  extend ::RSpec::Support::Warnings
+  extend ::RSpec::Core::Warnings
+
+  class << self
+    def clear_examples; end
+    def configuration; end
+    def configuration=(_arg0); end
+    def configure; end
+    def const_missing(name); end
+    def context(*args, &example_group_block); end
+    def current_example; end
+    def current_example=(example); end
+    def describe(*args, &example_group_block); end
+    def example_group(*args, &example_group_block); end
+    def fcontext(*args, &example_group_block); end
+    def fdescribe(*args, &example_group_block); end
+    def reset; end
+    def shared_context(name, *args, &block); end
+    def shared_examples(name, *args, &block); end
+    def shared_examples_for(name, *args, &block); end
+    def world; end
+    def world=(_arg0); end
+    def xcontext(*args, &example_group_block); end
+    def xdescribe(*args, &example_group_block); end
+  end
+end
+
+module RSpec::Expectations
+  class << self
+    def configuration; end
+    def differ; end
+    def fail_with(message, expected = T.unsafe(nil), actual = T.unsafe(nil)); end
+  end
+end
+
+class RSpec::Expectations::BlockExpectationTarget < ::RSpec::Expectations::ExpectationTarget
+  def not_to(matcher, message = T.unsafe(nil), &block); end
+  def to(matcher, message = T.unsafe(nil), &block); end
+  def to_not(matcher, message = T.unsafe(nil), &block); end
+
+  private
+
+  def enforce_block_expectation(matcher); end
+  def supports_block_expectations?(matcher); end
+end
+
+class RSpec::Expectations::BlockSnippetExtractor
+  def initialize(proc, method_name); end
+
+  def body_content_lines; end
+  def method_name; end
+  def proc; end
+
+  private
+
+  def beginning_line_number; end
+  def block_token_extractor; end
+  def file_path; end
+  def raw_body_lines; end
+  def raw_body_snippet; end
+  def source; end
+  def source_location; end
+
+  class << self
+    def try_extracting_single_line_body_of(proc, method_name); end
+  end
+end
+
+class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError < ::RSpec::Expectations::BlockSnippetExtractor::Error; end
+
+class RSpec::Expectations::BlockSnippetExtractor::BlockLocator < ::Struct
+  def beginning_line_number; end
+  def beginning_line_number=(_); end
+  def body_content_locations; end
+  def method_call_location; end
+  def method_name; end
+  def method_name=(_); end
+  def source; end
+  def source=(_); end
+
+  private
+
+  def block_body_node; end
+  def block_wrapper_node; end
+  def candidate_block_wrapper_nodes; end
+  def candidate_method_ident_nodes; end
+  def method_ident_node; end
+  def method_ident_node?(node); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor < ::Struct
+  def initialize(*_arg0); end
+
+  def beginning_line_number; end
+  def beginning_line_number=(_); end
+  def body_tokens; end
+  def method_name; end
+  def method_name=(_); end
+  def source; end
+  def source=(_); end
+  def state; end
+
+  private
+
+  def after_beginning_of_args_state(token); end
+  def after_beginning_of_body_state(token); end
+  def after_method_call_state(token); end
+  def after_opener_state(token); end
+  def block_locator; end
+  def correct_block?(body_tokens); end
+  def finalize_pending_tokens!; end
+  def finish!; end
+  def finish_or_find_next_block_if_incorrect!; end
+  def handle_closer_token(token); end
+  def handle_opener_token(token); end
+  def initial_state(token); end
+  def invoke_state_handler(token); end
+  def opener_token?(token); end
+  def opener_token_stack; end
+  def parse!; end
+  def pending_tokens; end
+  def pipe_token?(token); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class RSpec::Expectations::BlockSnippetExtractor::Error < ::StandardError; end
+class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError < ::RSpec::Expectations::BlockSnippetExtractor::Error; end
+
+class RSpec::Expectations::Configuration
+  def initialize; end
+
+  def add_should_and_should_not_to(*modules); end
+  def backtrace_formatter; end
+  def backtrace_formatter=(_arg0); end
+  def color?; end
+  def false_positives_handler; end
+  def include_chain_clauses_in_custom_matcher_descriptions=(_arg0); end
+  def include_chain_clauses_in_custom_matcher_descriptions?; end
+  def max_formatted_output_length=(length); end
+  def on_potential_false_positives; end
+  def on_potential_false_positives=(behavior); end
+  def reset_syntaxes_to_default; end
+  def strict_predicate_matchers; end
+  def strict_predicate_matchers=(flag); end
+  def strict_predicate_matchers?; end
+  def syntax; end
+  def syntax=(values); end
+  def warn_about_potential_false_positives=(boolean); end
+  def warn_about_potential_false_positives?; end
+end
+
+RSpec::Expectations::Configuration::FALSE_POSITIVE_BEHAVIOURS = T.let(T.unsafe(nil), Hash)
+
+module RSpec::Expectations::Configuration::NullBacktraceFormatter
+  class << self
+    def format_backtrace(backtrace); end
+  end
+end
+
+module RSpec::Expectations::ExpectationHelper
+  class << self
+    def check_message(msg); end
+    def handle_failure(matcher, message, failure_message_method); end
+    def modern_matcher_from(matcher); end
+    def with_matcher(handler, matcher, message); end
+  end
+end
+
+class RSpec::Expectations::ExpectationNotMetError < ::Exception; end
+
+class RSpec::Expectations::ExpectationTarget
+  include ::RSpec::Expectations::ExpectationTarget::InstanceMethods
+
+  def initialize(value); end
+
+  def target; end
+
+  class << self
+    def for(value, block); end
+  end
+end
+
+module RSpec::Expectations::ExpectationTarget::InstanceMethods
+  def not_to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
+  def to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
+  def to_not(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
+
+  private
+
+  def prevent_operator_matchers(verb); end
+end
+
+module RSpec::Expectations::ExpectationTarget::UndefinedValue; end
+
+class RSpec::Expectations::FailureAggregator
+  def initialize(block_label, metadata); end
+
+  def aggregate; end
+  def block_label; end
+  def call(failure, options); end
+  def failures; end
+  def metadata; end
+  def other_errors; end
+
+  private
+
+  def assign_backtrace(failure); end
+  def notify_aggregated_failures; end
+end
+
+RSpec::Expectations::LegacyMacherAdapter = RSpec::Expectations::LegacyMatcherAdapter
+
+class RSpec::Expectations::LegacyMatcherAdapter < ::RSpec::Matchers::MatcherDelegator
+  def initialize(matcher); end
+
+  class << self
+    def wrap(matcher); end
+  end
+end
+
+class RSpec::Expectations::LegacyMatcherAdapter::RSpec1 < ::RSpec::Expectations::LegacyMatcherAdapter
+  def failure_message; end
+  def failure_message_when_negated; end
+
+  class << self
+    def interface_matches?(matcher); end
+  end
+end
+
+class RSpec::Expectations::LegacyMatcherAdapter::RSpec2 < ::RSpec::Expectations::LegacyMatcherAdapter
+  def failure_message; end
+  def failure_message_when_negated; end
+
+  class << self
+    def interface_matches?(matcher); end
+  end
+end
+
+class RSpec::Expectations::MultipleExpectationsNotMetError < ::RSpec::Expectations::ExpectationNotMetError
+  def initialize(failure_aggregator); end
+
+  def aggregation_block_label; end
+  def aggregation_metadata; end
+  def all_exceptions; end
+  def exception_count_description; end
+  def failures; end
+  def message; end
+  def other_errors; end
+  def summary; end
+
+  private
+
+  def backtrace_line(line); end
+  def block_description; end
+  def enumerated(exceptions, index_offset); end
+  def enumerated_errors; end
+  def enumerated_failures; end
+  def exclusion_patterns; end
+  def format_backtrace(backtrace); end
+  def indentation; end
+  def indented(failure_message, index); end
+  def index_label(index); end
+  def longest_index_label_width; end
+  def pluralize(noun, count); end
+  def width_of_label(index); end
+end
+
+class RSpec::Expectations::NegativeExpectationHandler
+  class << self
+    def does_not_match?(matcher, actual, &block); end
+    def handle_matcher(actual, initial_matcher, custom_message = T.unsafe(nil), &block); end
+    def opposite_should_method; end
+    def should_method; end
+    def verb; end
+  end
+end
+
+class RSpec::Expectations::PositiveExpectationHandler
+  class << self
+    def handle_matcher(actual, initial_matcher, custom_message = T.unsafe(nil), &block); end
+    def opposite_should_method; end
+    def should_method; end
+    def verb; end
+  end
+end
+
+module RSpec::Expectations::Syntax
+  private
+
+  def default_should_host; end
+  def disable_expect(syntax_host = T.unsafe(nil)); end
+  def disable_should(syntax_host = T.unsafe(nil)); end
+  def enable_expect(syntax_host = T.unsafe(nil)); end
+  def enable_should(syntax_host = T.unsafe(nil)); end
+  def expect_enabled?(syntax_host = T.unsafe(nil)); end
+  def should_enabled?(syntax_host = T.unsafe(nil)); end
+  def warn_about_should!; end
+  def warn_about_should_unless_configured(method_name); end
+
+  class << self
+    def default_should_host; end
+    def disable_expect(syntax_host = T.unsafe(nil)); end
+    def disable_should(syntax_host = T.unsafe(nil)); end
+    def enable_expect(syntax_host = T.unsafe(nil)); end
+    def enable_should(syntax_host = T.unsafe(nil)); end
+    def expect_enabled?(syntax_host = T.unsafe(nil)); end
+    def should_enabled?(syntax_host = T.unsafe(nil)); end
+    def warn_about_should!; end
+    def warn_about_should_unless_configured(method_name); end
+  end
+end
+
+module RSpec::Expectations::Version; end
+RSpec::Expectations::Version::STRING = T.let(T.unsafe(nil), String)
+RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
+
+module RSpec::Matchers
+  extend ::RSpec::Matchers::DSL
+
+  def a_block_changing(*args, &block); end
+  def a_block_outputting(*args, &block); end
+  def a_block_raising(*args, &block); end
+  def a_block_throwing(*args, &block); end
+  def a_block_yielding_control(*args, &block); end
+  def a_block_yielding_successive_args(*args, &block); end
+  def a_block_yielding_with_args(*args, &block); end
+  def a_block_yielding_with_no_args(*args, &block); end
+  def a_collection_containing_exactly(*args, &block); end
+  def a_collection_ending_with(*args, &block); end
+  def a_collection_including(*args, &block); end
+  def a_collection_starting_with(*args, &block); end
+  def a_falsey_value(*args, &block); end
+  def a_falsy_value(*args, &block); end
+  def a_hash_including(*args, &block); end
+  def a_kind_of(*args, &block); end
+  def a_nil_value(*args, &block); end
+  def a_range_covering(*args, &block); end
+  def a_string_ending_with(*args, &block); end
+  def a_string_including(*args, &block); end
+  def a_string_matching(*args, &block); end
+  def a_string_starting_with(*args, &block); end
+  def a_truthy_value(*args, &block); end
+  def a_value(*args, &block); end
+  def a_value_between(*args, &block); end
+  def a_value_within(*args, &block); end
+  def aggregate_failures(label = T.unsafe(nil), metadata = T.unsafe(nil), &block); end
+  def all(expected); end
+  def an_instance_of(*args, &block); end
+  def an_object_eq_to(*args, &block); end
+  def an_object_eql_to(*args, &block); end
+  def an_object_equal_to(*args, &block); end
+  def an_object_existing(*args, &block); end
+  def an_object_having_attributes(*args, &block); end
+  def an_object_matching(*args, &block); end
+  def an_object_responding_to(*args, &block); end
+  def an_object_satisfying(*args, &block); end
+  def be(*args); end
+  def be_a(klass); end
+  def be_a_kind_of(expected); end
+  def be_an(klass); end
+  def be_an_instance_of(expected); end
+  def be_between(min, max); end
+  def be_falsey; end
+  def be_falsy(*args, &block); end
+  def be_instance_of(expected); end
+  def be_kind_of(expected); end
+  def be_nil; end
+  def be_truthy; end
+  def be_within(delta); end
+  def change(receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end
+  def changing(*args, &block); end
+  def contain_exactly(*items); end
+  def containing_exactly(*args, &block); end
+  def cover(*values); end
+  def covering(*args, &block); end
+  def end_with(*expected); end
+  def ending_with(*args, &block); end
+  def eq(expected); end
+  def eq_to(*args, &block); end
+  def eql(expected); end
+  def eql_to(*args, &block); end
+  def equal(expected); end
+  def equal_to(*args, &block); end
+  def exist(*args); end
+  def existing(*args, &block); end
+  def expect(value = T.unsafe(nil), &block); end
+  def have_attributes(expected); end
+  def having_attributes(*args, &block); end
+  def include(*expected); end
+  def including(*args, &block); end
+  def match(expected); end
+  def match_array(items); end
+  def match_regex(*args, &block); end
+  def matching(*args, &block); end
+  def output(expected = T.unsafe(nil)); end
+  def raise_error(error = T.unsafe(nil), message = T.unsafe(nil), &block); end
+  def raise_exception(error = T.unsafe(nil), message = T.unsafe(nil), &block); end
+  def raising(*args, &block); end
+  def respond_to(*names); end
+  def responding_to(*args, &block); end
+  def satisfy(description = T.unsafe(nil), &block); end
+  def satisfying(*args, &block); end
+  def start_with(*expected); end
+  def starting_with(*args, &block); end
+  def throw_symbol(expected_symbol = T.unsafe(nil), expected_arg = T.unsafe(nil)); end
+  def throwing(*args, &block); end
+  def within(*args, &block); end
+  def yield_control; end
+  def yield_successive_args(*args); end
+  def yield_with_args(*args); end
+  def yield_with_no_args; end
+  def yielding_control(*args, &block); end
+  def yielding_successive_args(*args, &block); end
+  def yielding_with_args(*args, &block); end
+  def yielding_with_no_args(*args, &block); end
+
+  private
+
+  def method_missing(method, *args, &block); end
+  def respond_to_missing?(method, *_arg1); end
+
+  class << self
+    def alias_matcher(*args, &block); end
+    def clear_generated_description; end
+    def configuration; end
+    def generated_description; end
+    def is_a_describable_matcher?(obj); end
+    def is_a_matcher?(obj); end
+    def last_description; end
+    def last_expectation_handler; end
+    def last_expectation_handler=(_arg0); end
+    def last_matcher; end
+    def last_matcher=(_arg0); end
+  end
+end
+
+class RSpec::Matchers::AliasedMatcher < ::RSpec::Matchers::MatcherDelegator
+  def initialize(base_matcher, description_block); end
+
+  def description; end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def method_missing(*_arg0); end
+end
+
+class RSpec::Matchers::AliasedMatcherWithOperatorSupport < ::RSpec::Matchers::AliasedMatcher; end
+
+class RSpec::Matchers::AliasedNegatedMatcher < ::RSpec::Matchers::AliasedMatcher
+  def does_not_match?(*args, &block); end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def matches?(*args, &block); end
+
+  private
+
+  def optimal_failure_message(same, inverted); end
+end
+
+RSpec::Matchers::AliasedNegatedMatcher::DefaultFailureMessages = RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
+RSpec::Matchers::BE_PREDICATE_REGEX = T.let(T.unsafe(nil), Regexp)
+module RSpec::Matchers::BuiltIn; end
+
+class RSpec::Matchers::BuiltIn::All < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def initialize(matcher); end
+
+  def description; end
+  def does_not_match?(_actual); end
+  def failed_objects; end
+  def failure_message; end
+  def matcher; end
+
+  private
+
+  def add_new_line_if_needed(message); end
+  def failure_message_for_item(index, failure_message); end
+  def indent_multiline_message(message); end
+  def index_failed_objects; end
+  def initialize_copy(other); end
+  def iterable?; end
+  def match(_expected, _actual); end
+end
+
+class RSpec::Matchers::BuiltIn::BaseMatcher
+  include ::RSpec::Matchers::Composable
+  include ::RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
+  include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
+
+  def initialize(expected = T.unsafe(nil)); end
+
+  def actual; end
+  def actual_formatted; end
+  def description; end
+  def diffable?; end
+  def expected; end
+  def expected_formatted; end
+  def expects_call_stack_jump?; end
+  def match_unless_raises(*exceptions); end
+  def matcher_name; end
+  def matcher_name=(_arg0); end
+  def matches?(actual); end
+  def present_ivars; end
+  def rescued_exception; end
+  def supports_block_expectations?; end
+
+  private
+
+  def assert_ivars(*expected_ivars); end
+
+  class << self
+    def matcher_name; end
+
+    private
+
+    def underscore(camel_cased_word); end
+  end
+end
+
+module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
+  def failure_message; end
+  def failure_message_when_negated; end
+
+  class << self
+    def has_default_failure_messages?(matcher); end
+  end
+end
+
+module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
+  private
+
+  def improve_hash_formatting(inspect_string); end
+
+  class << self
+    def improve_hash_formatting(inspect_string); end
+  end
+end
+
+RSpec::Matchers::BuiltIn::BaseMatcher::UNDEFINED = T.let(T.unsafe(nil), Object)
+
+class RSpec::Matchers::BuiltIn::Be < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  include ::RSpec::Matchers::BuiltIn::BeHelpers
+
+  def initialize(*args); end
+
+  def <(operand); end
+  def <=(operand); end
+  def ==(operand); end
+  def ===(operand); end
+  def =~(operand); end
+  def >(operand); end
+  def >=(operand); end
+  def failure_message; end
+  def failure_message_when_negated; end
+
+  private
+
+  def match(_, actual); end
+end
+
+class RSpec::Matchers::BuiltIn::BeAKindOf < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  private
+
+  def match(expected, actual); end
+end
+
+class RSpec::Matchers::BuiltIn::BeAnInstanceOf < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def description; end
+
+  private
+
+  def match(expected, actual); end
+end
+
+class RSpec::Matchers::BuiltIn::BeBetween < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def initialize(min, max); end
+
+  def description; end
+  def exclusive; end
+  def failure_message; end
+  def inclusive; end
+  def matches?(actual); end
+
+  private
+
+  def comparable?; end
+  def compare; end
+  def not_comparable_clause; end
+end
+
+class RSpec::Matchers::BuiltIn::BeComparedTo < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  include ::RSpec::Matchers::BuiltIn::BeHelpers
+
+  def initialize(operand, operator); end
+
+  def description; end
+  def does_not_match?(actual); end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def matches?(actual); end
+
+  private
+
+  def perform_match(actual); end
+end
+
+class RSpec::Matchers::BuiltIn::BeFalsey < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def failure_message; end
+  def failure_message_when_negated; end
+
+  private
+
+  def match(_, actual); end
+end
+
+module RSpec::Matchers::BuiltIn::BeHelpers
+  private
+
+  def args_to_s; end
+  def args_to_sentence; end
+  def expected_to_sentence; end
+  def inspected_args; end
+  def parenthesize(string); end
+end
+
+class RSpec::Matchers::BuiltIn::BeNil < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def failure_message; end
+  def failure_message_when_negated; end
+
+  private
+
+  def match(_, actual); end
+end
+
+class RSpec::Matchers::BuiltIn::BePredicate < ::RSpec::Matchers::BuiltIn::DynamicPredicate
+  private
+
+  def failure_to_respond_explanation; end
+  def predicate; end
+  def predicate_accessible?; end
+  def predicate_method_name; end
+  def present_tense_predicate; end
+end
+
+RSpec::Matchers::BuiltIn::BePredicate::REGEX = T.let(T.unsafe(nil), Regexp)
+
+class RSpec::Matchers::BuiltIn::BeTruthy < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def failure_message; end
+  def failure_message_when_negated; end
+
+  private
+
+  def match(_, actual); end
+end
+
+class RSpec::Matchers::BuiltIn::BeWithin < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def initialize(delta); end
+
+  def description; end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def matches?(actual); end
+  def of(expected); end
+  def percent_of(expected); end
+
+  private
+
+  def needs_expected; end
+  def not_numeric_clause; end
+  def numeric?; end
+end
+
+module RSpec::Matchers::BuiltIn::CaptureStderr
+  class << self
+    def capture(block); end
+    def name; end
+  end
+end
+
+module RSpec::Matchers::BuiltIn::CaptureStdout
+  class << self
+    def capture(block); end
+    def name; end
+  end
+end
+
+class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile < ::Struct
+  def capture(block); end
+end
+
+class RSpec::Matchers::BuiltIn::Change < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def initialize(receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end
+
+  def by(expected_delta); end
+  def by_at_least(minimum); end
+  def by_at_most(maximum); end
+  def description; end
+  def does_not_match?(event_proc); end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def from(value); end
+  def matches?(event_proc); end
+  def supports_block_expectations?; end
+  def to(value); end
+
+  private
+
+  def change_details; end
+  def negative_failure_reason; end
+  def perform_change(event_proc); end
+  def positive_failure_reason; end
+  def raise_block_syntax_error; end
+end
+
+class RSpec::Matchers::BuiltIn::ChangeDetails
+  def initialize(matcher_name, receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end
+
+  def actual_after; end
+  def actual_delta; end
+  def changed?; end
+  def perform_change(event_proc); end
+  def value_representation; end
+
+  private
+
+  def evaluate_value_proc; end
+  def extract_value_block_snippet; end
+  def message_notation(receiver, message); end
+end
+
+class RSpec::Matchers::BuiltIn::ChangeFromValue < ::RSpec::Matchers::BuiltIn::SpecificValuesChange
+  def initialize(change_details, expected_before); end
+
+  def does_not_match?(event_proc); end
+  def failure_message_when_negated; end
+  def to(value); end
+
+  private
+
+  def change_description; end
+end
+
+class RSpec::Matchers::BuiltIn::ChangeRelatively < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def initialize(change_details, expected_delta, relativity, &comparer); end
+
+  def description; end
+  def does_not_match?(_event_proc); end
+  def failure_message; end
+  def matches?(event_proc); end
+  def supports_block_expectations?; end
+
+  private
+
+  def failure_reason; end
+end
+
+class RSpec::Matchers::BuiltIn::ChangeToValue < ::RSpec::Matchers::BuiltIn::SpecificValuesChange
+  def initialize(change_details, expected_after); end
+
+  def does_not_match?(_event_proc); end
+  def from(value); end
+
+  private
+
+  def change_description; end
+end
+
+class RSpec::Matchers::BuiltIn::Compound < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def initialize(matcher_1, matcher_2); end
+
+  def description; end
+  def diffable?; end
+  def does_not_match?(_actual); end
+  def evaluator; end
+  def expected; end
+  def expects_call_stack_jump?; end
+  def matcher_1; end
+  def matcher_2; end
+  def supports_block_expectations?; end
+
+  protected
+
+  def diffable_matcher_list; end
+
+  private
+
+  def compound_failure_message; end
+  def diffable_matcher_list_for(matcher); end
+  def indent_multiline_message(message); end
+  def initialize_copy(other); end
+  def match(_expected, actual); end
+  def matcher_1_matches?; end
+  def matcher_2_matches?; end
+  def matcher_is_diffable?(matcher); end
+  def matcher_supports_block_expectations?(matcher); end
+end
+
+class RSpec::Matchers::BuiltIn::Compound::And < ::RSpec::Matchers::BuiltIn::Compound
+  def failure_message; end
+
+  private
+
+  def conjunction; end
+  def match(*_arg0); end
+end
+
+class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator
+  def initialize(actual, matcher_1, matcher_2); end
+
+  def matcher_matches?(matcher); end
+
+  private
+
+  def inner_matcher_block(outer_args); end
+  def order_block_matchers; end
+
+  class << self
+    def matcher_expects_call_stack_jump?(matcher); end
+  end
+end
+
+class RSpec::Matchers::BuiltIn::Compound::Or < ::RSpec::Matchers::BuiltIn::Compound
+  def failure_message; end
+
+  private
+
+  def conjunction; end
+  def match(*_arg0); end
+end
+
+class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator
+  def initialize(actual, *_arg1); end
+
+  def matcher_matches?(matcher); end
+end
+
+class RSpec::Matchers::BuiltIn::ContainExactly < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def description; end
+  def failure_message; end
+  def failure_message_when_negated; end
+
+  private
+
+  def actual_collection_line; end
+  def best_solution; end
+  def convert_actual_to_an_array; end
+  def describe_collection(collection, surface_descriptions = T.unsafe(nil)); end
+  def expected_collection_line; end
+  def extra_elements_line; end
+  def extra_items; end
+  def generate_failure_message; end
+  def match(_expected, _actual); end
+  def match_when_sorted?; end
+  def message_line(prefix, collection, surface_descriptions = T.unsafe(nil)); end
+  def missing_elements_line; end
+  def missing_items; end
+  def pairings_maximizer; end
+  def safe_sort(array); end
+  def to_a_disallowed?(object); end
+end
+
+class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer
+  def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes); end
+
+  def actual_to_expected_matched_indexes; end
+  def expected_to_actual_matched_indexes; end
+  def find_best_solution; end
+  def solution; end
+
+  private
+
+  def apply_pairing_to(indeterminates, original_matches, other_list_index); end
+  def best_solution_for_pairing(expected_index, actual_index); end
+  def categorize_indexes(indexes_to_categorize, other_indexes); end
+  def reciprocal_single_match?(matches, index, other_list); end
+end
+
+class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution
+  class << self
+    def worse_than?(_other); end
+  end
+end
+
+class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution < ::Struct
+  def +(derived_candidate_solution); end
+  def candidate?; end
+  def ideal?; end
+  def indeterminate_actual_indexes; end
+  def indeterminate_actual_indexes=(_); end
+  def indeterminate_expected_indexes; end
+  def indeterminate_expected_indexes=(_); end
+  def unmatched_actual_indexes; end
+  def unmatched_actual_indexes=(_); end
+  def unmatched_expected_indexes; end
+  def unmatched_expected_indexes=(_); end
+  def unmatched_item_count; end
+  def worse_than?(other); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+module RSpec::Matchers::BuiltIn::CountExpectation
+  def at_least(number); end
+  def at_most(number); end
+  def exactly(number); end
+  def once; end
+  def thrice; end
+  def times; end
+  def twice; end
+
+  protected
+
+  def count_expectation_type; end
+  def expected_count; end
+
+  private
+
+  def count_constraint_to_number(n); end
+  def count_expectation_description; end
+  def count_failure_reason(action); end
+  def cover?(count, number); end
+  def expected_count_matches?(actual_count); end
+  def has_expected_count?; end
+  def human_readable_count(count); end
+  def human_readable_expectation_type; end
+  def raise_impossible_count_expectation(count); end
+  def raise_unsupported_count_expectation; end
+  def set_expected_count(relativity, n); end
+  def unsupported_count_expectation?(relativity); end
+end
+
+class RSpec::Matchers::BuiltIn::Cover < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def initialize(*expected); end
+
+  def does_not_match?(range); end
+  def matches?(range); end
+end
+
+class RSpec::Matchers::BuiltIn::DynamicPredicate < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  include ::RSpec::Matchers::BuiltIn::BeHelpers
+
+  def initialize(method_name, *args, &block); end
+
+  def description; end
+  def does_not_match?(actual, &block); end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def matches?(actual, &block); end
+
+  private
+
+  def expectation_of(value); end
+  def failure_message_expecting(value); end
+  def failure_to_respond_explanation; end
+  def method_description; end
+  def predicate_accessible?; end
+  def predicate_matches?(value = T.unsafe(nil)); end
+  def predicate_method_name; end
+  def predicate_result; end
+  def private_predicate?; end
+  def root; end
+  def validity_message; end
+end
+
+class RSpec::Matchers::BuiltIn::EndWith < ::RSpec::Matchers::BuiltIn::StartOrEndWith
+  private
+
+  def element_matches?; end
+  def subset_matches?; end
+end
+
+class RSpec::Matchers::BuiltIn::Eq < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def description; end
+  def diffable?; end
+  def failure_message; end
+  def failure_message_when_negated; end
+
+  private
+
+  def match(expected, actual); end
+end
+
+class RSpec::Matchers::BuiltIn::Eql < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def diffable?; end
+  def failure_message; end
+  def failure_message_when_negated; end
+
+  private
+
+  def match(expected, actual); end
+end
+
+class RSpec::Matchers::BuiltIn::Equal < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def diffable?; end
+  def failure_message; end
+  def failure_message_when_negated; end
+
+  private
+
+  def actual_inspected; end
+  def detailed_failure_message; end
+  def expected_is_a_literal_singleton?; end
+  def inspect_object(o); end
+  def match(expected, actual); end
+  def simple_failure_message; end
+end
+
+RSpec::Matchers::BuiltIn::Equal::LITERAL_SINGLETONS = T.let(T.unsafe(nil), Array)
+
+class RSpec::Matchers::BuiltIn::Exist < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def initialize(*expected); end
+
+  def does_not_match?(actual); end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def matches?(actual); end
+end
+
+class RSpec::Matchers::BuiltIn::Exist::ExistenceTest < ::Struct
+  def actual_exists?; end
+  def valid_test?; end
+  def validity_message; end
+
+  private
+
+  def deprecated(predicate, actual); end
+  def existence_values; end
+  def predicates; end
+  def uniq_truthy_values; end
+end
+
+class RSpec::Matchers::BuiltIn::Has < ::RSpec::Matchers::BuiltIn::DynamicPredicate
+  private
+
+  def predicate; end
+end
+
+RSpec::Matchers::BuiltIn::Has::REGEX = T.let(T.unsafe(nil), Regexp)
+
+class RSpec::Matchers::BuiltIn::HaveAttributes < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def initialize(expected); end
+
+  def actual; end
+  def description; end
+  def diffable?; end
+  def does_not_match?(actual); end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def matches?(actual); end
+  def respond_to_failed; end
+
+  private
+
+  def actual_has_attribute?(attribute_key, attribute_value); end
+  def cache_all_values; end
+  def formatted_values; end
+  def perform_match(predicate); end
+  def respond_to_attributes?; end
+  def respond_to_failure_message_or; end
+  def respond_to_matcher; end
+end
+
+class RSpec::Matchers::BuiltIn::Include < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  include ::RSpec::Matchers::BuiltIn::CountExpectation
+
+  def initialize(*expecteds); end
+
+  def description; end
+  def diffable?; end
+  def does_not_match?(actual); end
+  def expected; end
+  def expecteds; end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def matches?(actual); end
+
+  private
+
+  def actual_collection_includes?(expected_item); end
+  def actual_hash_has_key?(expected_key); end
+  def actual_hash_includes?(expected_key, expected_value); end
+  def check_actual?(actual); end
+  def check_expected_count?; end
+  def comparing_hash_keys?(expected_item); end
+  def comparing_hash_to_a_subset?(expected_item); end
+  def convert_to_hash?(obj); end
+  def count_enumerable(expected_item); end
+  def count_inclusions; end
+  def diff_would_wrongly_highlight_matched_item?; end
+  def excluded_from_actual; end
+  def format_failure_message(preposition); end
+  def perform_match(&block); end
+  def readable_list_of(items); end
+end
+
+class RSpec::Matchers::BuiltIn::Match < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def initialize(expected); end
+
+  def description; end
+  def diffable?; end
+  def with_captures(*captures); end
+
+  private
+
+  def can_safely_call_match?(expected, actual); end
+  def match(expected, actual); end
+  def match_captures(expected, actual); end
+end
+
+class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher < ::RSpec::Matchers::BuiltIn::OperatorMatcher
+  def __delegate_operator(actual, operator, expected); end
+end
+
+module RSpec::Matchers::BuiltIn::NullCapture
+  class << self
+    def capture(_block); end
+    def name; end
+  end
+end
+
+class RSpec::Matchers::BuiltIn::OperatorMatcher
+  def initialize(actual); end
+
+  def !=(_expected); end
+  def !~(_expected); end
+  def <(expected); end
+  def <=(expected); end
+  def ==(expected); end
+  def ===(expected); end
+  def =~(expected); end
+  def >(expected); end
+  def >=(expected); end
+  def description; end
+  def fail_with_message(message); end
+
+  private
+
+  def eval_match(actual, operator, expected); end
+  def has_non_generic_implementation_of?(op); end
+
+  class << self
+    def get(klass, operator); end
+    def register(klass, operator, matcher); end
+    def registry; end
+    def unregister(klass, operator); end
+    def use_custom_matcher_or_delegate(operator); end
+  end
+end
+
+class RSpec::Matchers::BuiltIn::Output < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def initialize(expected); end
+
+  def description; end
+  def diffable?; end
+  def does_not_match?(block); end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def matches?(block); end
+  def supports_block_expectations?; end
+  def to_stderr; end
+  def to_stderr_from_any_process; end
+  def to_stdout; end
+  def to_stdout_from_any_process; end
+
+  private
+
+  def actual_output_description; end
+  def captured?; end
+  def negative_failure_reason; end
+  def positive_failure_reason; end
+end
+
+class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher < ::RSpec::Matchers::BuiltIn::OperatorMatcher
+  def __delegate_operator(actual, operator, expected); end
+end
+
+class RSpec::Matchers::BuiltIn::RaiseError
+  include ::RSpec::Matchers::Composable
+
+  def initialize(expected_error_or_message, expected_message, &block); end
+
+  def description; end
+  def does_not_match?(given_proc); end
+  def expects_call_stack_jump?; end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def matches?(given_proc, negative_expectation = T.unsafe(nil), &block); end
+  def supports_block_expectations?; end
+  def with_message(expected_message); end
+
+  private
+
+  def block_matches?; end
+  def error_and_message_match?; end
+  def eval_block; end
+  def expectation_matched?; end
+  def expected_error; end
+  def expecting_specific_exception?; end
+  def format_backtrace(backtrace); end
+  def given_error; end
+  def handle_warning(message); end
+  def raise_message_already_set; end
+  def ready_to_eval_block?; end
+  def verify_message; end
+  def warn_about_bare_error!; end
+  def warn_about_bare_error?; end
+  def warn_about_negative_false_positive!(expression); end
+  def warn_about_nil_error!; end
+  def warn_about_nil_error?; end
+  def warn_for_negative_false_positives!; end
+  def warning; end
+end
+
+RSpec::Matchers::BuiltIn::RaiseError::UndefinedValue = T.let(T.unsafe(nil), Object)
+
+class RSpec::Matchers::BuiltIn::ReliableMatchData
+  def initialize(match_data); end
+
+  def captures; end
+  def names; end
+
+  protected
+
+  def match_data; end
+end
+
+class RSpec::Matchers::BuiltIn::RespondTo < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def initialize(*names); end
+
+  def and_any_keywords; end
+  def and_keywords(*keywords); end
+  def and_unlimited_arguments; end
+  def argument; end
+  def arguments; end
+  def description; end
+  def does_not_match?(actual); end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def ignoring_method_signature_failure!; end
+  def matches?(actual); end
+  def with(n); end
+  def with_any_keywords; end
+  def with_keywords(*keywords); end
+  def with_unlimited_arguments; end
+
+  private
+
+  def find_failing_method_names(actual, filter_method); end
+  def matches_arity?(actual, name); end
+  def pp_names; end
+  def with_arity; end
+  def with_arity_string; end
+  def with_keywords_string; end
+end
+
+class RSpec::Matchers::BuiltIn::RespondTo::ArityCheck
+  def initialize(expected_arity, expected_keywords, arbitrary_keywords, unlimited_arguments); end
+
+  def matches?(actual, name); end
+  def method_signature_for(actual, name); end
+  def verifier_for(actual, name); end
+end
+
+class RSpec::Matchers::BuiltIn::Satisfy < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def initialize(description = T.unsafe(nil), &block); end
+
+  def description; end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def matches?(actual, &block); end
+
+  private
+
+  def block_representation; end
+  def extract_block_snippet; end
+end
+
+class RSpec::Matchers::BuiltIn::SpecificValuesChange < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def initialize(change_details, from, to); end
+
+  def description; end
+  def failure_message; end
+  def matches?(event_proc); end
+  def supports_block_expectations?; end
+
+  private
+
+  def after_value_failure; end
+  def before_value_failure; end
+  def did_change_failure; end
+  def did_not_change_failure; end
+  def matches_after?; end
+  def not_given_a_block_failure; end
+  def perform_change(event_proc); end
+end
+
+RSpec::Matchers::BuiltIn::SpecificValuesChange::MATCH_ANYTHING = BasicObject
+RSpec::Matchers::BuiltIn::StartAndEndWith = RSpec::Matchers::BuiltIn::StartOrEndWith
+
+class RSpec::Matchers::BuiltIn::StartOrEndWith < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def initialize(*expected); end
+
+  def description; end
+  def failure_message; end
+
+  private
+
+  def match(_expected, actual); end
+  def subsets_comparable?; end
+end
+
+class RSpec::Matchers::BuiltIn::StartWith < ::RSpec::Matchers::BuiltIn::StartOrEndWith
+  private
+
+  def element_matches?; end
+  def subset_matches?; end
+end
+
+class RSpec::Matchers::BuiltIn::ThrowSymbol
+  include ::RSpec::Matchers::Composable
+
+  def initialize(expected_symbol = T.unsafe(nil), expected_arg = T.unsafe(nil)); end
+
+  def description; end
+  def does_not_match?(given_proc); end
+  def expects_call_stack_jump?; end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def matches?(given_proc); end
+  def supports_block_expectations?; end
+
+  private
+
+  def actual_result; end
+  def caught; end
+  def expected(symbol_desc = T.unsafe(nil)); end
+  def throw_description(symbol, arg); end
+end
+
+class RSpec::Matchers::BuiltIn::YieldControl < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  include ::RSpec::Matchers::BuiltIn::CountExpectation
+
+  def does_not_match?(block); end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def matches?(block); end
+  def supports_block_expectations?; end
+
+  private
+
+  def failure_reason; end
+end
+
+class RSpec::Matchers::BuiltIn::YieldProbe
+  def initialize(block, &callback); end
+
+  def assert_used!; end
+  def assert_valid_expect_block!; end
+  def has_block?; end
+  def num_yields; end
+  def num_yields=(_arg0); end
+  def probe; end
+  def single_yield_args; end
+  def to_proc; end
+  def yielded_args; end
+  def yielded_args=(_arg0); end
+  def yielded_once?(matcher_name); end
+
+  class << self
+    def probe(block, &callback); end
+  end
+end
+
+class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def initialize(*args); end
+
+  def description; end
+  def does_not_match?(block); end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def matches?(block); end
+  def supports_block_expectations?; end
+
+  private
+
+  def expected_arg_description; end
+  def negative_failure_reason; end
+  def positive_failure_reason; end
+end
+
+class RSpec::Matchers::BuiltIn::YieldWithArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def initialize(*args); end
+
+  def description; end
+  def does_not_match?(block); end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def matches?(block); end
+  def supports_block_expectations?; end
+
+  private
+
+  def all_args_match?; end
+  def args_currently_match?; end
+  def expected_arg_description; end
+  def negative_failure_reason; end
+  def positive_failure_reason; end
+end
+
+class RSpec::Matchers::BuiltIn::YieldWithNoArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher
+  def does_not_match?(block); end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def matches?(block); end
+  def supports_block_expectations?; end
+
+  private
+
+  def negative_failure_reason; end
+  def positive_failure_reason; end
+end
+
+module RSpec::Matchers::Composable
+  def &(matcher); end
+  def ===(value); end
+  def and(matcher); end
+  def or(matcher); end
+  def |(matcher); end
+
+  private
+
+  def description_of(object); end
+  def should_enumerate?(item); end
+  def surface_descriptions_in(item); end
+  def unreadable_io?(object); end
+  def values_match?(expected, actual); end
+  def with_matchers_cloned(object); end
+
+  class << self
+    def should_enumerate?(item); end
+    def surface_descriptions_in(item); end
+    def unreadable_io?(object); end
+  end
+end
+
+class RSpec::Matchers::Composable::DescribableItem < ::Struct
+  def inspect; end
+  def item; end
+  def item=(_); end
+  def pretty_print(pp); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+module RSpec::Matchers::DSL
+  def alias_matcher(new_name, old_name, options = T.unsafe(nil), &description_override); end
+  def define(name, &declarations); end
+  def define_negated_matcher(negated_name, base_name, &description_override); end
+  def matcher(name, &declarations); end
+
+  private
+
+  def warn_about_block_args(name, declarations); end
+end
+
+module RSpec::Matchers::DSL::DefaultImplementations
+  include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
+
+  def description; end
+  def diffable?; end
+  def expects_call_stack_jump?; end
+  def supports_block_expectations?; end
+
+  private
+
+  def chained_method_clause_sentences; end
+end
+
+module RSpec::Matchers::DSL::Macros
+  def chain(method_name, *attr_names, &definition); end
+  def description(&definition); end
+  def diffable; end
+  def failure_message(&definition); end
+  def failure_message_when_negated(&definition); end
+  def match(options = T.unsafe(nil), &match_block); end
+  def match_unless_raises(expected_exception = T.unsafe(nil), &match_block); end
+  def match_when_negated(options = T.unsafe(nil), &match_block); end
+  def supports_block_expectations; end
+
+  private
+
+  def assign_attributes(attr_names); end
+  def define_user_override(method_name, user_def, &our_def); end
+end
+
+module RSpec::Matchers::DSL::Macros::Deprecated
+  def failure_message_for_should(&definition); end
+  def failure_message_for_should_not(&definition); end
+  def match_for_should(&definition); end
+  def match_for_should_not(&definition); end
+end
+
+RSpec::Matchers::DSL::Macros::RAISE_NOTIFIER = T.let(T.unsafe(nil), Proc)
+
+class RSpec::Matchers::DSL::Matcher
+  include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
+  include ::RSpec::Matchers::DSL::DefaultImplementations
+  include ::RSpec::Matchers
+  include ::RSpec::Matchers::Composable
+  extend ::RSpec::Matchers::DSL::Macros
+  extend ::RSpec::Matchers::DSL::Macros::Deprecated
+
+  def initialize(name, declarations, matcher_execution_context, *expected, &block_arg); end
+
+  def actual; end
+  def block_arg; end
+  def expected; end
+  def expected_as_array; end
+  def inspect; end
+  def name; end
+  def rescued_exception; end
+
+  private
+
+  def actual_arg_for(block); end
+  def method_missing(method, *args, &block); end
+  def respond_to_missing?(method, include_private = T.unsafe(nil)); end
+end
+
+RSpec::Matchers::DYNAMIC_MATCHER_REGEX = T.let(T.unsafe(nil), Regexp)
+
+module RSpec::Matchers::EnglishPhrasing
+  class << self
+    def list(obj); end
+    def split_words(sym); end
+  end
+end
+
+class RSpec::Matchers::ExpectedsForMultipleDiffs
+  def initialize(expected_list); end
+
+  def message_with_diff(message, differ, actual); end
+
+  private
+
+  def diffs(differ, actual); end
+
+  class << self
+    def for_many_matchers(matchers); end
+    def from(expected); end
+
+    private
+
+    def diff_label_for(matcher); end
+    def truncated(description); end
+  end
+end
+
+RSpec::Matchers::ExpectedsForMultipleDiffs::DEFAULT_DIFF_LABEL = T.let(T.unsafe(nil), String)
+RSpec::Matchers::ExpectedsForMultipleDiffs::DESCRIPTION_MAX_LENGTH = T.let(T.unsafe(nil), Integer)
+RSpec::Matchers::HAS_REGEX = T.let(T.unsafe(nil), Regexp)
+
+class RSpec::Matchers::MatcherDelegator
+  include ::RSpec::Matchers::Composable
+
+  def initialize(base_matcher); end
+
+  def base_matcher; end
+  def method_missing(*args, &block); end
+
+  private
+
+  def initialize_copy(other); end
+  def respond_to_missing?(name, include_all = T.unsafe(nil)); end
+end
+
+RSpec::SharedContext = RSpec::Core::SharedContext
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-github@2.3.1.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-github@2.3.1.rbi
index 4c60a0cefc..6d2dd75b99 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-github@2.3.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rspec-github@2.3.1.rbi
@@ -1,8 +1,60 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `rspec-github` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module RSpec
+  extend ::RSpec::Support::Warnings
+  extend ::RSpec::Core::Warnings
+
+  class << self
+    def clear_examples; end
+    def configuration; end
+    def configuration=(_arg0); end
+    def configure; end
+    def const_missing(name); end
+    def context(*args, &example_group_block); end
+    def current_example; end
+    def current_example=(example); end
+    def describe(*args, &example_group_block); end
+    def example_group(*args, &example_group_block); end
+    def fcontext(*args, &example_group_block); end
+    def fdescribe(*args, &example_group_block); end
+    def reset; end
+    def shared_context(name, *args, &block); end
+    def shared_examples(name, *args, &block); end
+    def shared_examples_for(name, *args, &block); end
+    def world; end
+    def world=(_arg0); end
+    def xcontext(*args, &example_group_block); end
+    def xdescribe(*args, &example_group_block); end
+  end
+end
+
+module RSpec::Github; end
+
+class RSpec::Github::Formatter < ::RSpec::Core::Formatters::BaseFormatter
+  def example_failed(failure); end
+  def example_pending(pending); end
+end
+
+class RSpec::Github::NotificationDecorator
+  def initialize(notification); end
+
+  def annotation; end
+  def line; end
+  def path; end
+
+  private
+
+  def example; end
+  def message; end
+  def raw_path; end
+  def workspace; end
+end
+
+RSpec::Github::NotificationDecorator::ESCAPE_MAP = T.let(T.unsafe(nil), Hash)
+RSpec::Github::VERSION = T.let(T.unsafe(nil), String)
+RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
+RSpec::SharedContext = RSpec::Core::SharedContext
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi
index a0e7530772..1179b74eb7 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi
@@ -1,7 +1,41 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `rspec-its` gem.
-# Please instead update this file by running `tapioca generate --exclude json`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
+module RSpec
+  extend ::RSpec::Support::Warnings
+  extend ::RSpec::Core::Warnings
 
+  class << self
+    def clear_examples; end
+    def configuration; end
+    def configuration=(_arg0); end
+    def configure; end
+    def const_missing(name); end
+    def context(*args, &example_group_block); end
+    def current_example; end
+    def current_example=(example); end
+    def describe(*args, &example_group_block); end
+    def example_group(*args, &example_group_block); end
+    def fcontext(*args, &example_group_block); end
+    def fdescribe(*args, &example_group_block); end
+    def reset; end
+    def shared_context(name, *args, &block); end
+    def shared_examples(name, *args, &block); end
+    def shared_examples_for(name, *args, &block); end
+    def world; end
+    def world=(_arg0); end
+    def xcontext(*args, &example_group_block); end
+    def xdescribe(*args, &example_group_block); end
+  end
+end
+
+module RSpec::Its
+  def its(attribute, *options, &block); end
+end
+
+RSpec::Its::VERSION = T.let(T.unsafe(nil), String)
+RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
+RSpec::SharedContext = RSpec::Core::SharedContext
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-mocks@3.10.2.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-mocks@3.10.2.rbi
index 058c61193e..73f4fde2fa 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-mocks@3.10.2.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rspec-mocks@3.10.2.rbi
@@ -1,8 +1,1493 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `rspec-mocks` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module RSpec
+  extend ::RSpec::Support::Warnings
+  extend ::RSpec::Core::Warnings
+
+  class << self
+    def clear_examples; end
+    def configuration; end
+    def configuration=(_arg0); end
+    def configure; end
+    def const_missing(name); end
+    def context(*args, &example_group_block); end
+    def current_example; end
+    def current_example=(example); end
+    def describe(*args, &example_group_block); end
+    def example_group(*args, &example_group_block); end
+    def fcontext(*args, &example_group_block); end
+    def fdescribe(*args, &example_group_block); end
+    def reset; end
+    def shared_context(name, *args, &block); end
+    def shared_examples(name, *args, &block); end
+    def shared_examples_for(name, *args, &block); end
+    def world; end
+    def world=(_arg0); end
+    def xcontext(*args, &example_group_block); end
+    def xdescribe(*args, &example_group_block); end
+  end
+end
+
+RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
+
+module RSpec::Mocks
+  class << self
+    def allow_message(subject, message, opts = T.unsafe(nil), &block); end
+    def configuration; end
+    def error_generator; end
+    def expect_message(subject, message, opts = T.unsafe(nil), &block); end
+    def setup; end
+    def space; end
+    def teardown; end
+    def verify; end
+    def with_temporary_scope; end
+  end
+end
+
+class RSpec::Mocks::AllowanceTarget < ::RSpec::Mocks::TargetBase
+  def expression; end
+  def not_to(matcher, *_args); end
+  def to(matcher, &block); end
+  def to_not(matcher, *_args); end
+end
+
+class RSpec::Mocks::AndReturnImplementation
+  def initialize(values_to_return); end
+
+  def call(*_args_to_ignore, &_block); end
+end
+
+class RSpec::Mocks::AndWrapOriginalImplementation
+  def initialize(method, block); end
+
+  def call(*args, &block); end
+  def initial_action=(_value); end
+  def inner_action; end
+  def inner_action=(_value); end
+  def present?; end
+  def terminal_action=(_value); end
+
+  private
+
+  def cannot_modify_further_error; end
+end
+
+class RSpec::Mocks::AndWrapOriginalImplementation::CannotModifyFurtherError < ::StandardError; end
+
+class RSpec::Mocks::AndYieldImplementation
+  def initialize(args_to_yield, eval_context, error_generator); end
+
+  def call(*_args_to_ignore, &block); end
+end
+
+module RSpec::Mocks::AnyInstance
+  class << self
+    def error_generator; end
+  end
+end
+
+class RSpec::Mocks::AnyInstance::Chain
+  include ::RSpec::Mocks::AnyInstance::Chain::Customizations
+
+  def initialize(recorder, *args, &block); end
+
+  def constrained_to_any_of?(*constraints); end
+  def expectation_fulfilled!; end
+  def matches_args?(*args); end
+  def never; end
+  def playback!(instance); end
+  def with(*args, &block); end
+
+  private
+
+  def last_message; end
+  def messages; end
+  def negated?; end
+  def record(rspec_method_name, *args, &block); end
+end
+
+module RSpec::Mocks::AnyInstance::Chain::Customizations
+  def and_call_original(*args, &block); end
+  def and_raise(*args, &block); end
+  def and_return(*args, &block); end
+  def and_throw(*args, &block); end
+  def and_wrap_original(*args, &block); end
+  def and_yield(*args, &block); end
+  def at_least(*args, &block); end
+  def at_most(*args, &block); end
+  def exactly(*args, &block); end
+  def never(*args, &block); end
+  def once(*args, &block); end
+  def thrice(*args, &block); end
+  def time(*args, &block); end
+  def times(*args, &block); end
+  def twice(*args, &block); end
+  def with(*args, &block); end
+
+  class << self
+    def record(method_name); end
+  end
+end
+
+class RSpec::Mocks::AnyInstance::ErrorGenerator < ::RSpec::Mocks::ErrorGenerator
+  def raise_does_not_implement_error(klass, method_name); end
+  def raise_message_already_received_by_other_instance_error(method_name, object_inspect, invoked_instance); end
+  def raise_not_supported_with_prepend_error(method_name, problem_mod); end
+  def raise_second_instance_received_message_error(unfulfilled_expectations); end
+end
+
+class RSpec::Mocks::AnyInstance::ExpectChainChain < ::RSpec::Mocks::AnyInstance::StubChain
+  def initialize(*args); end
+
+  def expectation_fulfilled?; end
+  def playback!(instance); end
+
+  private
+
+  def create_message_expectation_on(instance); end
+  def invocation_order; end
+end
+
+class RSpec::Mocks::AnyInstance::ExpectationChain < ::RSpec::Mocks::AnyInstance::Chain
+  def initialize(*args, &block); end
+
+  def expectation_fulfilled?; end
+
+  private
+
+  def verify_invocation_order(_rspec_method_name, *_args, &_block); end
+end
+
+class RSpec::Mocks::AnyInstance::FluentInterfaceProxy
+  def initialize(targets); end
+
+  def method_missing(*args, &block); end
+
+  private
+
+  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
+end
+
+class RSpec::Mocks::AnyInstance::MessageChains
+  def initialize; end
+
+  def [](method_name); end
+  def add(method_name, chain); end
+  def all_expectations_fulfilled?; end
+  def each_unfulfilled_expectation_matching(method_name, *args); end
+  def has_expectation?(method_name); end
+  def playback!(instance, method_name); end
+  def received_expected_message!(method_name); end
+  def remove_stub_chains_for!(method_name); end
+  def unfulfilled_expectations; end
+
+  private
+
+  def raise_if_second_instance_to_receive_message(instance); end
+end
+
+class RSpec::Mocks::AnyInstance::PositiveExpectationChain < ::RSpec::Mocks::AnyInstance::ExpectationChain
+  private
+
+  def create_message_expectation_on(instance); end
+  def invocation_order; end
+end
+
+RSpec::Mocks::AnyInstance::PositiveExpectationChain::ExpectationInvocationOrder = T.let(T.unsafe(nil), Hash)
+
+class RSpec::Mocks::AnyInstance::Proxy
+  def initialize(recorder, target_proxies); end
+
+  def expect_chain(*chain, &block); end
+  def klass; end
+  def should_not_receive(method_name, &block); end
+  def should_receive(method_name, &block); end
+  def stub(method_name_or_method_map, &block); end
+  def stub_chain(*chain, &block); end
+  def unstub(method_name); end
+
+  private
+
+  def perform_proxying(method_name, args, block, &target_proxy_block); end
+end
+
+class RSpec::Mocks::AnyInstance::Recorder
+  def initialize(klass); end
+
+  def already_observing?(method_name); end
+  def build_alias_method_name(method_name); end
+  def expect_chain(*method_names_and_optional_return_values, &block); end
+  def instance_that_received(method_name); end
+  def klass; end
+  def message_chains; end
+  def notify_received_message(_object, message, args, _blk); end
+  def playback!(instance, method_name); end
+  def should_not_receive(method_name, &block); end
+  def should_receive(method_name, &block); end
+  def stop_all_observation!; end
+  def stub(method_name, &block); end
+  def stub_chain(*method_names_and_optional_return_values, &block); end
+  def stubs; end
+  def unstub(method_name); end
+  def verify; end
+
+  protected
+
+  def stop_observing!(method_name); end
+
+  private
+
+  def allow_no_prepended_module_definition_of(method_name); end
+  def ancestor_is_an_observer?(method_name); end
+  def backup_method!(method_name); end
+  def mark_invoked!(method_name); end
+  def normalize_chain(*args); end
+  def observe!(method_name); end
+  def public_protected_or_private_method_defined?(method_name); end
+  def received_expected_message!(method_name); end
+  def remove_dummy_method!(method_name); end
+  def restore_method!(method_name); end
+  def restore_original_method!(method_name); end
+  def super_class_observers_for(method_name); end
+  def super_class_observing?(method_name); end
+end
+
+class RSpec::Mocks::AnyInstance::StubChain < ::RSpec::Mocks::AnyInstance::Chain
+  def expectation_fulfilled?; end
+
+  private
+
+  def create_message_expectation_on(instance); end
+  def invocation_order; end
+  def verify_invocation_order(rspec_method_name, *_args, &_block); end
+end
+
+RSpec::Mocks::AnyInstance::StubChain::EmptyInvocationOrder = T.let(T.unsafe(nil), Hash)
+RSpec::Mocks::AnyInstance::StubChain::InvocationOrder = T.let(T.unsafe(nil), Hash)
+
+class RSpec::Mocks::AnyInstance::StubChainChain < ::RSpec::Mocks::AnyInstance::StubChain
+  def initialize(*args); end
+
+  private
+
+  def create_message_expectation_on(instance); end
+  def invocation_order; end
+end
+
+class RSpec::Mocks::AnyInstanceAllowanceTarget < ::RSpec::Mocks::TargetBase
+  def expression; end
+  def not_to(matcher, *_args); end
+  def to(matcher, &block); end
+  def to_not(matcher, *_args); end
+end
+
+class RSpec::Mocks::AnyInstanceExpectationTarget < ::RSpec::Mocks::TargetBase
+  def expression; end
+  def not_to(matcher, &block); end
+  def to(matcher, &block); end
+  def to_not(matcher, &block); end
+end
+
+class RSpec::Mocks::ArgumentListMatcher
+  def initialize(*expected_args); end
+
+  def args_match?(*args); end
+  def expected_args; end
+  def resolve_expected_args_based_on(actual_args); end
+
+  private
+
+  def ensure_expected_args_valid!; end
+  def replace_any_args_with_splat_of_anything(before_count, actual_args_count); end
+end
+
+RSpec::Mocks::ArgumentListMatcher::MATCH_ALL = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentListMatcher)
+
+module RSpec::Mocks::ArgumentMatchers
+  def a_kind_of(klass); end
+  def an_instance_of(klass); end
+  def any_args; end
+  def anything; end
+  def array_including(*args); end
+  def boolean; end
+  def duck_type(*args); end
+  def hash_excluding(*args); end
+  def hash_including(*args); end
+  def hash_not_including(*args); end
+  def instance_of(klass); end
+  def kind_of(klass); end
+  def no_args; end
+
+  class << self
+    def anythingize_lonely_keys(*args); end
+  end
+end
+
+class RSpec::Mocks::ArgumentMatchers::AnyArgMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher
+  def ===(_other); end
+  def description; end
+end
+
+RSpec::Mocks::ArgumentMatchers::AnyArgMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::AnyArgMatcher)
+
+class RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher
+  def description; end
+end
+
+RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher)
+
+class RSpec::Mocks::ArgumentMatchers::ArrayIncludingMatcher
+  def initialize(expected); end
+
+  def ===(actual); end
+  def description; end
+
+  private
+
+  def formatted_expected_values; end
+end
+
+class RSpec::Mocks::ArgumentMatchers::BaseHashMatcher
+  def initialize(expected); end
+
+  def ===(predicate, actual); end
+  def description(name); end
+
+  private
+
+  def formatted_expected_hash; end
+end
+
+class RSpec::Mocks::ArgumentMatchers::BooleanMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher
+  def ===(value); end
+  def description; end
+end
+
+RSpec::Mocks::ArgumentMatchers::BooleanMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::BooleanMatcher)
+
+class RSpec::Mocks::ArgumentMatchers::DuckTypeMatcher
+  def initialize(*methods_to_respond_to); end
+
+  def ===(value); end
+  def description; end
+end
+
+class RSpec::Mocks::ArgumentMatchers::HashExcludingMatcher < ::RSpec::Mocks::ArgumentMatchers::BaseHashMatcher
+  def ===(actual); end
+  def description; end
+end
+
+class RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher < ::RSpec::Mocks::ArgumentMatchers::BaseHashMatcher
+  def ===(actual); end
+  def description; end
+end
+
+class RSpec::Mocks::ArgumentMatchers::InstanceOf
+  def initialize(klass); end
+
+  def ===(actual); end
+  def description; end
+end
+
+class RSpec::Mocks::ArgumentMatchers::KindOf
+  def initialize(klass); end
+
+  def ===(actual); end
+  def description; end
+end
+
+class RSpec::Mocks::ArgumentMatchers::NoArgsMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher
+  def description; end
+end
+
+RSpec::Mocks::ArgumentMatchers::NoArgsMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::NoArgsMatcher)
+
+class RSpec::Mocks::ArgumentMatchers::SingletonMatcher
+  class << self
+    def inherited(subklass); end
+  end
+end
+
+class RSpec::Mocks::CallbackInvocationStrategy
+  def call(doubled_module); end
+end
+
+class RSpec::Mocks::CannotSupportArgMutationsError < ::StandardError; end
+
+class RSpec::Mocks::ClassNewMethodReference < ::RSpec::Mocks::ObjectMethodReference
+  def with_signature; end
+
+  class << self
+    def applies_to?(method_name); end
+  end
+end
+
+class RSpec::Mocks::ClassVerifyingDouble < ::Module
+  include ::RSpec::Mocks::TestDouble
+  include ::RSpec::Mocks::VerifyingDouble
+  include ::RSpec::Mocks::ObjectVerifyingDoubleMethods
+end
+
+class RSpec::Mocks::Configuration
+  def initialize; end
+
+  def add_stub_and_should_receive_to(*modules); end
+  def allow_message_expectations_on_nil; end
+  def allow_message_expectations_on_nil=(_arg0); end
+  def before_verifying_doubles(&block); end
+  def color?; end
+  def patch_marshal_to_support_partial_doubles=(val); end
+  def reset_syntaxes_to_default; end
+  def syntax; end
+  def syntax=(*values); end
+  def temporarily_suppress_partial_double_verification; end
+  def temporarily_suppress_partial_double_verification=(_arg0); end
+  def transfer_nested_constants=(_arg0); end
+  def transfer_nested_constants?; end
+  def verify_doubled_constant_names=(_arg0); end
+  def verify_doubled_constant_names?; end
+  def verify_partial_doubles=(val); end
+  def verify_partial_doubles?; end
+  def verifying_double_callbacks; end
+  def when_declaring_verifying_double(&block); end
+  def yield_receiver_to_any_instance_implementation_blocks=(_arg0); end
+  def yield_receiver_to_any_instance_implementation_blocks?; end
+end
+
+class RSpec::Mocks::Constant
+  extend ::RSpec::Support::RecursiveConstMethods
+
+  def initialize(name); end
+
+  def hidden=(_arg0); end
+  def hidden?; end
+  def inspect; end
+  def mutated?; end
+  def name; end
+  def original_value; end
+  def original_value=(_arg0); end
+  def previously_defined=(_arg0); end
+  def previously_defined?; end
+  def stubbed=(_arg0); end
+  def stubbed?; end
+  def to_s; end
+  def valid_name=(_arg0); end
+  def valid_name?; end
+
+  class << self
+    def original(name); end
+    def unmutated(name); end
+  end
+end
+
+class RSpec::Mocks::ConstantMutator
+  extend ::RSpec::Support::RecursiveConstMethods
+
+  class << self
+    def hide(constant_name); end
+    def mutate(mutator); end
+    def raise_on_invalid_const; end
+    def stub(constant_name, value, options = T.unsafe(nil)); end
+  end
+end
+
+class RSpec::Mocks::ConstantMutator::BaseMutator
+  include ::RSpec::Support::RecursiveConstMethods
+
+  def initialize(full_constant_name, mutated_value, transfer_nested_constants); end
+
+  def full_constant_name; end
+  def idempotently_reset; end
+  def original_value; end
+  def to_constant; end
+end
+
+class RSpec::Mocks::ConstantMutator::ConstantHider < ::RSpec::Mocks::ConstantMutator::BaseMutator
+  def mutate; end
+  def reset; end
+  def to_constant; end
+end
+
+class RSpec::Mocks::ConstantMutator::DefinedConstantReplacer < ::RSpec::Mocks::ConstantMutator::BaseMutator
+  def initialize(*args); end
+
+  def mutate; end
+  def reset; end
+  def should_transfer_nested_constants?; end
+  def to_constant; end
+  def transfer_nested_constants; end
+  def verify_constants_to_transfer!; end
+end
+
+class RSpec::Mocks::ConstantMutator::UndefinedConstantSetter < ::RSpec::Mocks::ConstantMutator::BaseMutator
+  def mutate; end
+  def reset; end
+  def to_constant; end
+
+  private
+
+  def name_for(parent, name); end
+end
+
+RSpec::Mocks::DEFAULT_CALLBACK_INVOCATION_STRATEGY = T.let(T.unsafe(nil), RSpec::Mocks::CallbackInvocationStrategy)
+
+class RSpec::Mocks::DirectObjectReference
+  def initialize(object); end
+
+  def const_to_replace; end
+  def defined?; end
+  def description; end
+  def target; end
+  def when_loaded; end
+end
+
+class RSpec::Mocks::Double
+  include ::RSpec::Mocks::TestDouble
+end
+
+class RSpec::Mocks::ErrorGenerator
+  def initialize(target = T.unsafe(nil)); end
+
+  def default_error_message(expectation, expected_args, actual_args); end
+  def describe_expectation(verb, message, expected_received_count, _actual_received_count, args); end
+  def expectation_on_nil_message(method_name); end
+  def intro(unwrapped = T.unsafe(nil)); end
+  def method_call_args_description(args, generic_prefix = T.unsafe(nil), matcher_prefix = T.unsafe(nil)); end
+  def opts; end
+  def opts=(_arg0); end
+  def raise_already_invoked_error(message, calling_customization); end
+  def raise_cant_constrain_count_for_negated_have_received_error(count_constraint); end
+  def raise_double_negation_error(wrapped_expression); end
+  def raise_expectation_error(message, expected_received_count, argument_list_matcher, actual_received_count, expectation_count_type, args, backtrace_line = T.unsafe(nil), source_id = T.unsafe(nil)); end
+  def raise_expectation_on_mocked_method(method); end
+  def raise_expectation_on_nil_error(method_name); end
+  def raise_expectation_on_unstubbed_method(method); end
+  def raise_expired_test_double_error; end
+  def raise_have_received_disallowed(type, reason); end
+  def raise_invalid_arguments_error(verifier); end
+  def raise_method_not_stubbed_error(method_name); end
+  def raise_missing_block_error(args_to_yield); end
+  def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end
+  def raise_non_public_error(method_name, visibility); end
+  def raise_only_valid_on_a_partial_double(method); end
+  def raise_out_of_order_error(message); end
+  def raise_similar_message_args_error(expectation, args_for_multiple_calls, backtrace_line = T.unsafe(nil)); end
+  def raise_unexpected_message_args_error(expectation, args_for_multiple_calls, source_id = T.unsafe(nil)); end
+  def raise_unexpected_message_error(message, args); end
+  def raise_unimplemented_error(doubled_module, method_name, object); end
+  def raise_verifying_double_not_defined_error(ref); end
+  def raise_wrong_arity_error(args_to_yield, signature); end
+
+  private
+
+  def __raise(message, backtrace_line = T.unsafe(nil), source_id = T.unsafe(nil)); end
+  def arg_list(args); end
+  def count_message(count, expectation_count_type = T.unsafe(nil)); end
+  def diff_message(expected_args, actual_args); end
+  def differ; end
+  def error_message(expectation, args_for_multiple_calls); end
+  def expected_part_of_expectation_error(expected_received_count, expectation_count_type, argument_list_matcher); end
+  def format_args(args); end
+  def format_received_args(args_for_multiple_calls); end
+  def group_count(index, args); end
+  def grouped_args(args); end
+  def list_of_exactly_one_string?(args); end
+  def notify(*args); end
+  def prepend_to_backtrace(exception, line); end
+  def received_part_of_expectation_error(actual_received_count, args); end
+  def times(count); end
+  def unexpected_arguments_message(expected_args_string, actual_args_string); end
+  def unpack_string_args(formatted_expected_args, actual_args); end
+end
+
+module RSpec::Mocks::ExampleMethods
+  include ::RSpec::Mocks::ArgumentMatchers
+  include ::RSpec::Mocks::ExampleMethods::ExpectHost
+
+  def allow(target); end
+  def allow_any_instance_of(klass); end
+  def allow_message_expectations_on_nil; end
+  def class_double(doubled_class, *args); end
+  def class_spy(*args); end
+  def double(*args); end
+  def expect_any_instance_of(klass); end
+  def have_received(method_name, &block); end
+  def hide_const(constant_name); end
+  def instance_double(doubled_class, *args); end
+  def instance_spy(*args); end
+  def object_double(object_or_name, *args); end
+  def object_spy(*args); end
+  def receive(method_name, &block); end
+  def receive_message_chain(*messages, &block); end
+  def receive_messages(message_return_value_hash); end
+  def spy(*args); end
+  def stub_const(constant_name, value, options = T.unsafe(nil)); end
+  def without_partial_double_verification; end
+
+  class << self
+    def declare_double(type, *args); end
+    def declare_verifying_double(type, ref, *args); end
+    def extended(object); end
+    def included(klass); end
+  end
+end
+
+module RSpec::Mocks::ExampleMethods::ExpectHost
+  def expect(target); end
+end
+
+class RSpec::Mocks::ExpectChain < ::RSpec::Mocks::MessageChain
+  private
+
+  def expectation(object, message, &return_block); end
+
+  class << self
+    def expect_chain_on(object, *chain, &blk); end
+  end
+end
+
+class RSpec::Mocks::ExpectationTarget < ::RSpec::Mocks::TargetBase
+  include ::RSpec::Mocks::ExpectationTargetMethods
+end
+
+module RSpec::Mocks::ExpectationTargetMethods
+  include ::RSpec::Mocks::TargetDelegationInstanceMethods
+  extend ::RSpec::Mocks::TargetDelegationClassMethods
+
+  def expression; end
+  def not_to(matcher, &block); end
+  def to(matcher, &block); end
+  def to_not(matcher, &block); end
+end
+
+class RSpec::Mocks::ExpiredTestDoubleError < ::RSpec::Mocks::MockExpectationError; end
+RSpec::Mocks::IGNORED_BACKTRACE_LINE = T.let(T.unsafe(nil), String)
+
+class RSpec::Mocks::Implementation
+  def call(*args, &block); end
+  def initial_action; end
+  def initial_action=(_arg0); end
+  def inner_action; end
+  def inner_action=(_arg0); end
+  def present?; end
+  def terminal_action; end
+  def terminal_action=(_arg0); end
+
+  private
+
+  def actions; end
+end
+
+class RSpec::Mocks::InstanceMethodReference < ::RSpec::Mocks::MethodReference
+  private
+
+  def find_method(mod); end
+  def method_defined?(mod); end
+  def method_implemented?(mod); end
+  def visibility_from(mod); end
+end
+
+class RSpec::Mocks::InstanceMethodStasher
+  def initialize(object, method); end
+
+  def handle_restoration_failures; end
+  def method_is_stashed?; end
+  def original_method; end
+  def restore; end
+  def stash; end
+
+  private
+
+  def method_defined_directly_on_klass?; end
+  def method_defined_on_klass?(klass = T.unsafe(nil)); end
+  def method_owned_by_klass?; end
+end
+
+class RSpec::Mocks::InstanceVerifyingDouble
+  include ::RSpec::Mocks::TestDouble
+  include ::RSpec::Mocks::VerifyingDouble
+
+  def __build_mock_proxy(order_group); end
+end
+
+class RSpec::Mocks::MarshalExtension
+  class << self
+    def patch!; end
+    def unpatch!; end
+  end
+end
+
+module RSpec::Mocks::Matchers; end
+
+class RSpec::Mocks::Matchers::ExpectationCustomization
+  def initialize(method_name, args, block); end
+
+  def block; end
+  def block=(_arg0); end
+  def playback_onto(expectation); end
+end
+
+class RSpec::Mocks::Matchers::HaveReceived
+  include ::RSpec::Mocks::Matchers::Matcher
+
+  def initialize(method_name, &block); end
+
+  def at_least(*args); end
+  def at_most(*args); end
+  def description; end
+  def does_not_match?(subject); end
+  def exactly(*args); end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def matches?(subject, &block); end
+  def name; end
+  def once(*args); end
+  def ordered(*args); end
+  def setup_allowance(_subject, &_block); end
+  def setup_any_instance_allowance(_subject, &_block); end
+  def setup_any_instance_expectation(_subject, &_block); end
+  def setup_any_instance_negative_expectation(_subject, &_block); end
+  def setup_expectation(subject, &block); end
+  def setup_negative_expectation(subject, &block); end
+  def thrice(*args); end
+  def time(*args); end
+  def times(*args); end
+  def twice(*args); end
+  def with(*args); end
+
+  private
+
+  def apply_constraints_to(expectation); end
+  def capture_failure_message; end
+  def count_constraint; end
+  def disallow(type, reason = T.unsafe(nil)); end
+  def ensure_count_unconstrained; end
+  def expect; end
+  def expected_messages_received_in_order?; end
+  def mock_proxy; end
+  def notify_failure_message; end
+end
+
+RSpec::Mocks::Matchers::HaveReceived::ARGS_CONSTRAINTS = T.let(T.unsafe(nil), Array)
+RSpec::Mocks::Matchers::HaveReceived::CONSTRAINTS = T.let(T.unsafe(nil), Array)
+RSpec::Mocks::Matchers::HaveReceived::COUNT_CONSTRAINTS = T.let(T.unsafe(nil), Array)
+module RSpec::Mocks::Matchers::Matcher; end
+
+class RSpec::Mocks::Matchers::Receive
+  include ::RSpec::Mocks::Matchers::Matcher
+
+  def initialize(message, block); end
+
+  def and_call_original(*args, &block); end
+  def and_raise(*args, &block); end
+  def and_return(*args, &block); end
+  def and_throw(*args, &block); end
+  def and_wrap_original(*args, &block); end
+  def and_yield(*args, &block); end
+  def at_least(*args, &block); end
+  def at_most(*args, &block); end
+  def description; end
+  def does_not_match?(subject, &block); end
+  def exactly(*args, &block); end
+  def matches?(subject, &block); end
+  def name; end
+  def never(*args, &block); end
+  def once(*args, &block); end
+  def ordered(*args, &block); end
+  def setup_allowance(subject, &block); end
+  def setup_any_instance_allowance(subject, &block); end
+  def setup_any_instance_expectation(subject, &block); end
+  def setup_any_instance_negative_expectation(subject, &block); end
+  def setup_expectation(subject, &block); end
+  def setup_negative_expectation(subject, &block); end
+  def thrice(*args, &block); end
+  def time(*args, &block); end
+  def times(*args, &block); end
+  def twice(*args, &block); end
+  def with(*args, &block); end
+
+  private
+
+  def describable; end
+  def move_block_to_last_customization(block); end
+  def setup_any_instance_method_substitute(subject, method, block); end
+  def setup_method_substitute(host, method, block, *args); end
+  def setup_mock_proxy_method_substitute(subject, method, block); end
+  def warn_if_any_instance(expression, subject); end
+end
+
+class RSpec::Mocks::Matchers::Receive::DefaultDescribable
+  def initialize(message); end
+
+  def description_for(verb); end
+end
+
+class RSpec::Mocks::Matchers::ReceiveMessageChain
+  include ::RSpec::Mocks::Matchers::Matcher
+
+  def initialize(chain, &block); end
+
+  def and_call_original(*args, &block); end
+  def and_raise(*args, &block); end
+  def and_return(*args, &block); end
+  def and_throw(*args, &block); end
+  def and_yield(*args, &block); end
+  def description; end
+  def does_not_match?(*_args); end
+  def matches?(subject, &block); end
+  def name; end
+  def setup_allowance(subject, &block); end
+  def setup_any_instance_allowance(subject, &block); end
+  def setup_any_instance_expectation(subject, &block); end
+  def setup_expectation(subject, &block); end
+  def setup_negative_expectation(*_args); end
+  def with(*args, &block); end
+
+  private
+
+  def formatted_chain; end
+  def replay_customizations(chain); end
+end
+
+class RSpec::Mocks::Matchers::ReceiveMessages
+  include ::RSpec::Mocks::Matchers::Matcher
+
+  def initialize(message_return_value_hash); end
+
+  def description; end
+  def does_not_match?(_subject); end
+  def matches?(subject); end
+  def name; end
+  def setup_allowance(subject); end
+  def setup_any_instance_allowance(subject); end
+  def setup_any_instance_expectation(subject); end
+  def setup_expectation(subject); end
+  def setup_negative_expectation(_subject); end
+  def warn_about_block; end
+
+  private
+
+  def any_instance_of(subject); end
+  def each_message_on(host); end
+  def proxy_on(subject); end
+end
+
+class RSpec::Mocks::MessageChain
+  def initialize(object, *chain, &blk); end
+
+  def block; end
+  def chain; end
+  def object; end
+  def setup_chain; end
+
+  private
+
+  def chain_on(object, *chain, &block); end
+  def find_matching_expectation; end
+  def find_matching_stub; end
+  def format_chain(*chain, &blk); end
+end
+
+class RSpec::Mocks::MessageExpectation
+  include ::RSpec::Mocks::MessageExpectation::ImplementationDetails
+
+  def and_call_original; end
+  def and_raise(*args); end
+  def and_return(first_value, *values); end
+  def and_throw(*args); end
+  def and_wrap_original(&block); end
+  def and_yield(*args, &block); end
+  def at_least(n, &block); end
+  def at_most(n, &block); end
+  def exactly(n, &block); end
+  def inspect; end
+  def never; end
+  def once(&block); end
+  def ordered(&block); end
+  def thrice(&block); end
+  def time(&block); end
+  def times(&block); end
+  def to_s; end
+  def twice(&block); end
+  def with(*args, &block); end
+end
+
+module RSpec::Mocks::MessageExpectation::ImplementationDetails
+  def initialize(error_generator, expectation_ordering, expected_from, method_double, type = T.unsafe(nil), opts = T.unsafe(nil), &implementation_block); end
+
+  def actual_received_count_matters?; end
+  def additional_expected_calls; end
+  def advise(*args); end
+  def and_yield_receiver_to_implementation; end
+  def argument_list_matcher=(_arg0); end
+  def called_max_times?; end
+  def description_for(verb); end
+  def ensure_expected_ordering_received!; end
+  def error_generator; end
+  def expectation_count_type; end
+  def expected_args; end
+  def expected_messages_received?; end
+  def generate_error; end
+  def ignoring_args?; end
+  def implementation; end
+  def increase_actual_received_count!; end
+  def invoke(parent_stub, *args, &block); end
+  def invoke_without_incrementing_received_count(parent_stub, *args, &block); end
+  def matches?(message, *args); end
+  def matches_at_least_count?; end
+  def matches_at_most_count?; end
+  def matches_exact_count?; end
+  def matches_name_but_not_args(message, *args); end
+  def message; end
+  def negative?; end
+  def negative_expectation_for?(message); end
+  def ordered?; end
+  def orig_object; end
+  def raise_out_of_order_error; end
+  def raise_unexpected_message_args_error(args_for_multiple_calls); end
+  def safe_invoke(parent_stub, *args, &block); end
+  def similar_messages; end
+  def type; end
+  def unadvise(args); end
+  def verify_messages_received; end
+  def yield_receiver_to_implementation_block?; end
+
+  protected
+
+  def error_generator=(_arg0); end
+  def expected_from=(_arg0); end
+  def expected_received_count=(_arg0); end
+  def implementation=(_arg0); end
+
+  private
+
+  def exception_source_id; end
+  def has_been_invoked?; end
+  def initial_implementation_action=(action); end
+  def inner_implementation_action=(action); end
+  def invoke_incrementing_actual_calls_by(increment, allowed_to_fail, parent_stub, *args, &block); end
+  def raise_already_invoked_error_if_necessary(calling_customization); end
+  def set_expected_received_count(relativity, n); end
+  def terminal_implementation_action=(action); end
+  def warn_about_stub_override; end
+  def wrap_original(method_name, &block); end
+end
+
+class RSpec::Mocks::MethodDouble
+  def initialize(object, method_name, proxy); end
+
+  def add_default_stub(*args, &implementation); end
+  def add_expectation(error_generator, expectation_ordering, expected_from, opts, &implementation); end
+  def add_simple_expectation(method_name, response, error_generator, backtrace_line); end
+  def add_simple_stub(method_name, response); end
+  def add_stub(error_generator, expectation_ordering, expected_from, opts = T.unsafe(nil), &implementation); end
+  def build_expectation(error_generator, expectation_ordering); end
+  def clear; end
+  def configure_method; end
+  def define_proxy_method; end
+  def expectations; end
+  def message_expectation_class; end
+  def method_name; end
+  def method_stasher; end
+  def object; end
+  def object_singleton_class; end
+  def original_implementation_callable; end
+  def original_method; end
+  def proxy_method_invoked(_obj, *args, &block); end
+  def raise_method_not_stubbed_error; end
+  def remove_stub; end
+  def remove_stub_if_present; end
+  def reset; end
+  def restore_original_method; end
+  def restore_original_visibility; end
+  def save_original_implementation_callable!; end
+  def setup_simple_method_double(method_name, response, collection, error_generator = T.unsafe(nil), backtrace_line = T.unsafe(nil)); end
+  def show_frozen_warning; end
+  def stubs; end
+  def verify; end
+  def visibility; end
+
+  private
+
+  def definition_target; end
+  def new_rspec_prepended_module; end
+  def remove_method_from_definition_target; end
+  def usable_rspec_prepended_module; end
+end
+
+class RSpec::Mocks::MethodDouble::RSpecPrependedModule < ::Module; end
+
+class RSpec::Mocks::MethodReference
+  def initialize(object_reference, method_name); end
+
+  def defined?; end
+  def implemented?; end
+  def unimplemented?; end
+  def visibility; end
+  def with_signature; end
+
+  private
+
+  def original_method; end
+
+  class << self
+    def for(object_reference, method_name); end
+    def instance_method_visibility_for(klass, method_name); end
+    def method_defined_at_any_visibility?(klass, method_name); end
+    def method_visibility_for(object, method_name); end
+  end
+end
+
+class RSpec::Mocks::MockExpectationAlreadyInvokedError < ::Exception; end
+class RSpec::Mocks::MockExpectationError < ::Exception; end
+
+class RSpec::Mocks::NamedObjectReference
+  def initialize(const_name); end
+
+  def const_to_replace; end
+  def defined?; end
+  def description; end
+  def target; end
+  def when_loaded; end
+
+  private
+
+  def object; end
+end
+
+class RSpec::Mocks::NegationUnsupportedError < ::StandardError; end
+
+class RSpec::Mocks::NestedSpace < ::RSpec::Mocks::Space
+  def initialize(parent); end
+
+  def constant_mutator_for(name); end
+  def proxies_of(klass); end
+  def registered?(object); end
+
+  private
+
+  def any_instance_recorder_not_found_for(id, klass); end
+  def proxy_not_found_for(id, object); end
+end
+
+class RSpec::Mocks::NoCallbackInvocationStrategy
+  def call(_doubled_module); end
+end
+
+class RSpec::Mocks::ObjectMethodReference < ::RSpec::Mocks::MethodReference
+  private
+
+  def find_method(object); end
+  def method_defined?(object); end
+  def method_implemented?(object); end
+  def visibility_from(object); end
+
+  class << self
+    def for(object_reference, method_name); end
+  end
+end
+
+class RSpec::Mocks::ObjectReference
+  class << self
+    def for(object_module_or_name, allow_direct_object_refs = T.unsafe(nil)); end
+
+    private
+
+    def anonymous_module?(mod); end
+    def name_of(mod); end
+  end
+end
+
+RSpec::Mocks::ObjectReference::MODULE_NAME_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+class RSpec::Mocks::ObjectVerifyingDouble
+  include ::RSpec::Mocks::TestDouble
+  include ::RSpec::Mocks::VerifyingDouble
+  include ::RSpec::Mocks::ObjectVerifyingDoubleMethods
+end
+
+module RSpec::Mocks::ObjectVerifyingDoubleMethods
+  include ::RSpec::Mocks::TestDouble
+  include ::RSpec::Mocks::VerifyingDouble
+
+  def as_stubbed_const(options = T.unsafe(nil)); end
+
+  private
+
+  def __build_mock_proxy(order_group); end
+end
+
+class RSpec::Mocks::OrderGroup
+  def initialize; end
+
+  def clear; end
+  def consume; end
+  def empty?; end
+  def handle_order_constraint(expectation); end
+  def invoked(message); end
+  def ready_for?(expectation); end
+  def register(expectation); end
+  def verify_invocation_order(expectation); end
+
+  private
+
+  def expectation_for(message); end
+  def expectations_invoked_in_order?; end
+  def expected_invocations; end
+  def invoked_expectations; end
+  def remaining_expectations; end
+end
+
+class RSpec::Mocks::OutsideOfExampleError < ::StandardError; end
+
+class RSpec::Mocks::PartialClassDoubleProxy < ::RSpec::Mocks::PartialDoubleProxy
+  include ::RSpec::Mocks::PartialClassDoubleProxyMethods
+end
+
+module RSpec::Mocks::PartialClassDoubleProxyMethods
+  def initialize(source_space, *args); end
+
+  def original_method_handle_for(message); end
+
+  protected
+
+  def method_double_from_ancestor_for(message); end
+  def original_unbound_method_handle_from_ancestor_for(message); end
+  def superclass_proxy; end
+end
+
+class RSpec::Mocks::PartialDoubleProxy < ::RSpec::Mocks::Proxy
+  def add_simple_expectation(method_name, response, location); end
+  def add_simple_stub(method_name, response); end
+  def message_received(message, *args, &block); end
+  def original_method_handle_for(message); end
+  def reset; end
+  def visibility_for(method_name); end
+
+  private
+
+  def any_instance_class_recorder_observing_method?(klass, method_name); end
+end
+
+class RSpec::Mocks::Proxy
+  def initialize(object, order_group, options = T.unsafe(nil)); end
+
+  def add_message_expectation(method_name, opts = T.unsafe(nil), &block); end
+  def add_simple_expectation(method_name, response, location); end
+  def add_simple_stub(method_name, response); end
+  def add_stub(method_name, opts = T.unsafe(nil), &implementation); end
+  def as_null_object; end
+  def build_expectation(method_name); end
+  def check_for_unexpected_arguments(expectation); end
+  def ensure_can_be_proxied!(object); end
+  def ensure_implemented(*_args); end
+  def has_negative_expectation?(message); end
+  def message_received(message, *args, &block); end
+  def messages_arg_list; end
+  def method_double_if_exists_for_message(message); end
+  def null_object?; end
+  def object; end
+  def original_method_handle_for(_message); end
+  def prepended_modules_of_singleton_class; end
+  def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end
+  def raise_unexpected_message_error(method_name, args); end
+  def received_message?(method_name, *args, &block); end
+  def record_message_received(message, *args, &block); end
+  def remove_stub(method_name); end
+  def remove_stub_if_present(method_name); end
+  def replay_received_message_on(expectation, &block); end
+  def reset; end
+  def verify; end
+  def visibility_for(_method_name); end
+
+  private
+
+  def find_almost_matching_expectation(method_name, *args); end
+  def find_almost_matching_stub(method_name, *args); end
+  def find_best_matching_expectation_for(method_name); end
+  def find_matching_expectation(method_name, *args); end
+  def find_matching_method_stub(method_name, *args); end
+  def method_double_for(message); end
+
+  class << self
+    def prepended_modules_of(klass); end
+  end
+end
+
+RSpec::Mocks::Proxy::DEFAULT_MESSAGE_EXPECTATION_OPTS = T.let(T.unsafe(nil), Hash)
+
+class RSpec::Mocks::Proxy::SpecificMessage < ::Struct
+  def ==(expectation); end
+  def args; end
+  def args=(_); end
+  def message; end
+  def message=(_); end
+  def object; end
+  def object=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class RSpec::Mocks::ProxyForNil < ::RSpec::Mocks::PartialDoubleProxy
+  def initialize(order_group); end
+
+  def add_message_expectation(method_name, opts = T.unsafe(nil), &block); end
+  def add_stub(method_name, opts = T.unsafe(nil), &implementation); end
+  def disallow_expectations; end
+  def disallow_expectations=(_arg0); end
+  def warn_about_expectations; end
+  def warn_about_expectations=(_arg0); end
+
+  private
+
+  def raise_error(method_name); end
+  def set_expectation_behavior; end
+  def warn(method_name); end
+  def warn_or_raise!(method_name); end
+end
+
+class RSpec::Mocks::RootSpace
+  def any_instance_proxy_for(*_args); end
+  def any_instance_recorder_for(*_args); end
+  def any_instance_recorders_from_ancestry_of(_object); end
+  def new_scope; end
+  def proxy_for(*_args); end
+  def register_constant_mutator(_mutator); end
+  def registered?(_object); end
+  def reset_all; end
+  def superclass_proxy_for(*_args); end
+  def verify_all; end
+
+  private
+
+  def raise_lifecycle_message; end
+end
+
+class RSpec::Mocks::SimpleMessageExpectation
+  def initialize(message, response, error_generator, backtrace_line = T.unsafe(nil)); end
+
+  def called_max_times?; end
+  def invoke(*_); end
+  def matches?(message, *_); end
+  def unadvise(_); end
+  def verify_messages_received; end
+end
+
+class RSpec::Mocks::Space
+  def initialize; end
+
+  def any_instance_mutex; end
+  def any_instance_proxy_for(klass); end
+  def any_instance_recorder_for(klass, only_return_existing = T.unsafe(nil)); end
+  def any_instance_recorders; end
+  def any_instance_recorders_from_ancestry_of(object); end
+  def constant_mutator_for(name); end
+  def ensure_registered(object); end
+  def new_scope; end
+  def proxies; end
+  def proxies_of(klass); end
+  def proxy_for(object); end
+  def proxy_mutex; end
+  def register_constant_mutator(mutator); end
+  def registered?(object); end
+  def reset_all; end
+  def superclass_proxy_for(klass); end
+  def verify_all; end
+
+  private
+
+  def any_instance_recorder_not_found_for(id, klass); end
+  def class_proxy_with_callback_verification_strategy(object, strategy); end
+  def id_for(object); end
+  def new_mutex; end
+  def proxy_not_found_for(id, object); end
+  def superclass_proxy_not_found_for(id, object); end
+end
+
+class RSpec::Mocks::StubChain < ::RSpec::Mocks::MessageChain
+  private
+
+  def expectation(object, message, &return_block); end
+
+  class << self
+    def stub_chain_on(object, *chain, &blk); end
+  end
+end
+
+module RSpec::Mocks::Syntax
+  class << self
+    def default_should_syntax_host; end
+    def disable_expect(syntax_host = T.unsafe(nil)); end
+    def disable_should(syntax_host = T.unsafe(nil)); end
+    def enable_expect(syntax_host = T.unsafe(nil)); end
+    def enable_should(syntax_host = T.unsafe(nil)); end
+    def expect_enabled?(syntax_host = T.unsafe(nil)); end
+    def should_enabled?(syntax_host = T.unsafe(nil)); end
+    def warn_about_should!; end
+    def warn_unless_should_configured(method_name, replacement = T.unsafe(nil)); end
+  end
+end
+
+class RSpec::Mocks::TargetBase
+  include ::RSpec::Mocks::TargetDelegationInstanceMethods
+  extend ::RSpec::Mocks::TargetDelegationClassMethods
+
+  def initialize(target); end
+end
+
+module RSpec::Mocks::TargetDelegationClassMethods
+  def delegate_not_to(matcher_method, options = T.unsafe(nil)); end
+  def delegate_to(matcher_method); end
+  def disallow_negation(method_name); end
+end
+
+module RSpec::Mocks::TargetDelegationInstanceMethods
+  def target; end
+
+  private
+
+  def define_matcher(matcher, name, &block); end
+  def matcher_allowed?(matcher); end
+  def raise_negation_unsupported(method_name, matcher); end
+  def raise_unsupported_matcher(method_name, matcher); end
+end
+
+module RSpec::Mocks::TestDouble
+  def initialize(name = T.unsafe(nil), stubs = T.unsafe(nil)); end
+
+  def ==(other); end
+  def __build_mock_proxy_unless_expired(order_group); end
+  def __disallow_further_usage!; end
+  def as_null_object; end
+  def freeze; end
+  def inspect; end
+  def null_object?; end
+  def respond_to?(message, incl_private = T.unsafe(nil)); end
+  def to_s; end
+
+  private
+
+  def __build_mock_proxy(order_group); end
+  def __mock_proxy; end
+  def __raise_expired_error; end
+  def assign_stubs(stubs); end
+  def initialize_copy(other); end
+  def method_missing(message, *args, &block); end
+end
+
+module RSpec::Mocks::TestDoubleFormatter
+  class << self
+    def format(dbl, unwrap = T.unsafe(nil)); end
+
+    private
+
+    def name_desc(dbl); end
+    def type_desc(dbl); end
+    def verified_module_desc(dbl); end
+  end
+end
+
+class RSpec::Mocks::TestDoubleProxy < ::RSpec::Mocks::Proxy
+  def reset; end
+end
+
+class RSpec::Mocks::UnsupportedMatcherError < ::StandardError; end
+
+module RSpec::Mocks::VerifyingDouble
+  def initialize(doubled_module, *args); end
+
+  def __send__(name, *args, &block); end
+  def method_missing(message, *args, &block); end
+  def respond_to?(message, include_private = T.unsafe(nil)); end
+  def send(name, *args, &block); end
+end
+
+module RSpec::Mocks::VerifyingDouble::SilentIO
+  class << self
+    def method_missing(*_arg0); end
+    def respond_to?(*_arg0); end
+  end
+end
+
+class RSpec::Mocks::VerifyingDoubleNotDefinedError < ::StandardError; end
+
+class RSpec::Mocks::VerifyingExistingClassNewMethodDouble < ::RSpec::Mocks::VerifyingExistingMethodDouble
+  def with_signature; end
+end
+
+class RSpec::Mocks::VerifyingExistingMethodDouble < ::RSpec::Mocks::VerifyingMethodDouble
+  def initialize(object, method_name, proxy); end
+
+  def unimplemented?; end
+  def with_signature; end
+
+  class << self
+    def for(object, method_name, proxy); end
+  end
+end
+
+class RSpec::Mocks::VerifyingMessageExpectation < ::RSpec::Mocks::MessageExpectation
+  def initialize(*args); end
+
+  def method_reference; end
+  def method_reference=(_arg0); end
+  def with(*args, &block); end
+
+  private
+
+  def validate_expected_arguments!; end
+end
+
+class RSpec::Mocks::VerifyingMethodDouble < ::RSpec::Mocks::MethodDouble
+  def initialize(object, method_name, proxy, method_reference); end
+
+  def add_expectation(*args, &block); end
+  def add_stub(*args, &block); end
+  def message_expectation_class; end
+  def proxy_method_invoked(obj, *args, &block); end
+  def validate_arguments!(actual_args); end
+end
+
+class RSpec::Mocks::VerifyingPartialClassDoubleProxy < ::RSpec::Mocks::VerifyingPartialDoubleProxy
+  include ::RSpec::Mocks::PartialClassDoubleProxyMethods
+end
+
+class RSpec::Mocks::VerifyingPartialDoubleProxy < ::RSpec::Mocks::PartialDoubleProxy
+  include ::RSpec::Mocks::VerifyingProxyMethods
+
+  def initialize(object, expectation_ordering, optional_callback_invocation_strategy = T.unsafe(nil)); end
+
+  def ensure_implemented(_method_name); end
+  def method_reference; end
+end
+
+class RSpec::Mocks::VerifyingProxy < ::RSpec::Mocks::TestDoubleProxy
+  include ::RSpec::Mocks::VerifyingProxyMethods
+
+  def initialize(object, order_group, doubled_module, method_reference_class); end
+
+  def method_reference; end
+  def validate_arguments!(method_name, args); end
+  def visibility_for(method_name); end
+end
+
+module RSpec::Mocks::VerifyingProxyMethods
+  def add_message_expectation(method_name, opts = T.unsafe(nil), &block); end
+  def add_simple_stub(method_name, *args); end
+  def add_stub(method_name, opts = T.unsafe(nil), &implementation); end
+  def ensure_implemented(method_name); end
+  def ensure_publicly_implemented(method_name, _object); end
+end
+
+module RSpec::Mocks::Version; end
+RSpec::Mocks::Version::STRING = T.let(T.unsafe(nil), String)
+RSpec::SharedContext = RSpec::Core::SharedContext
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi
index 328046941f..087e6093c0 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi
@@ -1,7 +1,282 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `rspec-retry` gem.
-# Please instead update this file by running `tapioca generate --exclude json`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
+module RSpec
+  extend ::RSpec::Support::Warnings
+  extend ::RSpec::Core::Warnings
 
+  class << self
+    def clear_examples; end
+    def configuration; end
+    def configuration=(_arg0); end
+    def configure; end
+    def const_missing(name); end
+    def context(*args, &example_group_block); end
+    def current_example; end
+    def current_example=(example); end
+    def describe(*args, &example_group_block); end
+    def example_group(*args, &example_group_block); end
+    def fcontext(*args, &example_group_block); end
+    def fdescribe(*args, &example_group_block); end
+    def reset; end
+    def shared_context(name, *args, &block); end
+    def shared_examples(name, *args, &block); end
+    def shared_examples_for(name, *args, &block); end
+    def world; end
+    def world=(_arg0); end
+    def xcontext(*args, &example_group_block); end
+    def xdescribe(*args, &example_group_block); end
+  end
+end
+
+module RSpec::Core
+  class << self
+    def path_to_executable; end
+  end
+end
+
+class RSpec::Core::DeprecationError < ::StandardError; end
+
+class RSpec::Core::Example
+  def initialize(example_group_class, description, user_metadata, example_block = T.unsafe(nil)); end
+
+  def attempts; end
+  def attempts=(_arg0); end
+  def clear_exception; end
+  def clock; end
+  def clock=(_arg0); end
+  def description; end
+  def display_exception; end
+  def display_exception=(ex); end
+  def duplicate_with(metadata_overrides = T.unsafe(nil)); end
+  def example_group; end
+  def example_group_instance; end
+  def exception; end
+  def execution_result; end
+  def fail_with_exception(reporter, exception); end
+  def file_path; end
+  def full_description; end
+  def id; end
+  def inspect; end
+  def inspect_output; end
+  def instance_exec(*args, &block); end
+  def location; end
+  def location_rerun_argument; end
+  def metadata; end
+  def pending; end
+  def pending?; end
+  def reporter; end
+  def rerun_argument; end
+  def run(example_group_instance, reporter); end
+  def set_aggregate_failures_exception(exception); end
+  def set_exception(exception); end
+  def skip; end
+  def skip_with_exception(reporter, exception); end
+  def skipped?; end
+  def to_s; end
+  def update_inherited_metadata(updates); end
+
+  private
+
+  def assign_generated_description; end
+  def finish(reporter); end
+  def generate_description; end
+  def hooks; end
+  def location_description; end
+  def mocks_need_verification?; end
+  def record_finished(status, reporter); end
+  def run_after_example; end
+  def run_before_example; end
+  def start(reporter); end
+  def verify_mocks; end
+  def with_around_and_singleton_context_hooks; end
+  def with_around_example_hooks; end
+
+  class << self
+    def delegate_to_metadata(key); end
+    def parse_id(id); end
+  end
+end
+
+RSpec::Core::Example::AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt = RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
+
+class RSpec::Core::Example::Procsy
+  def initialize(example, &block); end
+
+  def <<(*a, &b); end
+  def ===(*a, &b); end
+  def >>(*a, &b); end
+  def [](*a, &b); end
+  def arity(*a, &b); end
+  def attempts; end
+  def binding(*a, &b); end
+  def call(*args, &block); end
+  def clock(*a, &b); end
+  def clock=(*a, &b); end
+  def clone(*a, &b); end
+  def curry(*a, &b); end
+  def description(*a, &b); end
+  def dup(*a, &b); end
+  def duplicate_with(*a, &b); end
+  def example; end
+  def example_group(*a, &b); end
+  def example_group_instance(*a, &b); end
+  def exception(*a, &b); end
+  def executed?; end
+  def execution_result(*a, &b); end
+  def file_path(*a, &b); end
+  def full_description(*a, &b); end
+  def hash(*a, &b); end
+  def id(*a, &b); end
+  def inspect; end
+  def inspect_output(*a, &b); end
+  def lambda?(*a, &b); end
+  def location(*a, &b); end
+  def location_rerun_argument(*a, &b); end
+  def metadata(*a, &b); end
+  def parameters(*a, &b); end
+  def pending(*a, &b); end
+  def pending?(*a, &b); end
+  def reporter(*a, &b); end
+  def rerun_argument(*a, &b); end
+  def run(*args, &block); end
+  def run_with_retry(opts = T.unsafe(nil)); end
+  def skip(*a, &b); end
+  def skipped?(*a, &b); end
+  def source_location(*a, &b); end
+  def to_proc; end
+  def update_inherited_metadata(*a, &b); end
+  def wrap(&block); end
+  def yield(*a, &b); end
+end
+
+class RSpec::Core::ExampleGroup
+  include ::RSpec::Core::MemoizedHelpers
+  include ::RSpec::Core::Pending
+  extend ::RSpec::Core::Hooks
+  extend ::RSpec::Core::MemoizedHelpers::ClassMethods
+  extend ::RSpec::Core::SharedExampleGroup
+
+  def initialize(inspect_output = T.unsafe(nil)); end
+
+  def clear_lets; end
+  def clear_memoized; end
+  def described_class; end
+  def inspect; end
+
+  private
+
+  def method_missing(name, *args); end
+
+  class << self
+    def add_example(example); end
+    def before_context_ivars; end
+    def children; end
+    def context(*args, &example_group_block); end
+    def currently_executing_a_context_hook?; end
+    def declaration_locations; end
+    def define_example_group_method(name, metadata = T.unsafe(nil)); end
+    def define_example_method(name, extra_options = T.unsafe(nil)); end
+    def define_nested_shared_group_method(new_name, report_label = T.unsafe(nil)); end
+    def delegate_to_metadata(*names); end
+    def descendant_filtered_examples; end
+    def descendants; end
+    def describe(*args, &example_group_block); end
+    def described_class; end
+    def description; end
+    def each_instance_variable_for_example(group); end
+    def ensure_example_groups_are_configured; end
+    def example(*all_args, &block); end
+    def example_group(*args, &example_group_block); end
+    def examples; end
+    def fcontext(*args, &example_group_block); end
+    def fdescribe(*args, &example_group_block); end
+    def fexample(*all_args, &block); end
+    def file_path; end
+    def filtered_examples; end
+    def find_and_eval_shared(label, name, inclusion_location, *args, &customization_block); end
+    def fit(*all_args, &block); end
+    def focus(*all_args, &block); end
+    def for_filtered_examples(reporter, &block); end
+    def fspecify(*all_args, &block); end
+    def id; end
+    def idempotently_define_singleton_method(name, &definition); end
+    def include_context(name, *args, &block); end
+    def include_examples(name, *args, &block); end
+    def it(*all_args, &block); end
+    def it_behaves_like(name, *args, &customization_block); end
+    def it_should_behave_like(name, *args, &customization_block); end
+    def location; end
+    def metadata; end
+    def next_runnable_index_for(file); end
+    def ordering_strategy; end
+    def parent_groups; end
+    def pending(*all_args, &block); end
+    def remove_example(example); end
+    def reset_memoized; end
+    def run(reporter = T.unsafe(nil)); end
+    def run_after_context_hooks(example_group_instance); end
+    def run_before_context_hooks(example_group_instance); end
+    def run_examples(reporter); end
+    def set_it_up(description, args, registration_collection, &example_group_block); end
+    def set_ivars(instance, ivars); end
+    def skip(*all_args, &block); end
+    def specify(*all_args, &block); end
+    def store_before_context_ivars(example_group_instance); end
+    def subclass(parent, description, args, registration_collection, &example_group_block); end
+    def superclass_before_context_ivars; end
+    def superclass_metadata; end
+    def top_level?; end
+    def top_level_description; end
+    def traverse_tree_until(&block); end
+    def update_inherited_metadata(updates); end
+    def with_replaced_metadata(meta); end
+    def xcontext(*args, &example_group_block); end
+    def xdescribe(*args, &example_group_block); end
+    def xexample(*all_args, &block); end
+    def xit(*all_args, &block); end
+    def xspecify(*all_args, &block); end
+
+    private
+
+    def method_missing(name, *args); end
+  end
+end
+
+RSpec::Core::ExampleGroup::INSTANCE_VARIABLE_TO_IGNORE = T.let(T.unsafe(nil), Symbol)
+class RSpec::Core::ExampleGroup::WrongScopeError < ::NoMethodError; end
+RSpec::Core::ExclusionRules = RSpec::Core::FilterRules
+RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
+
+class RSpec::Retry
+  def initialize(ex, opts = T.unsafe(nil)); end
+
+  def attempts; end
+  def attempts=(val); end
+  def clear_lets; end
+  def context; end
+  def current_example; end
+  def display_try_failure_messages?; end
+  def ex; end
+  def exceptions_to_hard_fail; end
+  def exceptions_to_retry; end
+  def retry_count; end
+  def run; end
+  def sleep_interval; end
+  def verbose_retry?; end
+
+  private
+
+  def exception_exists_in?(list, exception); end
+  def ordinalize(number); end
+
+  class << self
+    def setup; end
+  end
+end
+
+RSpec::Retry::VERSION = T.let(T.unsafe(nil), String)
+RSpec::SharedContext = RSpec::Core::SharedContext
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-sorbet@1.8.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-sorbet@1.8.0.rbi
index bbc503d5d5..7a3d4705ea 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-sorbet@1.8.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rspec-sorbet@1.8.0.rbi
@@ -1,8 +1,57 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `rspec-sorbet` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module RSpec
+  extend ::RSpec::Support::Warnings
+  extend ::RSpec::Core::Warnings
+
+  class << self
+    def clear_examples; end
+    def configuration; end
+    def configuration=(_arg0); end
+    def configure; end
+    def const_missing(name); end
+    def context(*args, &example_group_block); end
+    def current_example; end
+    def current_example=(example); end
+    def describe(*args, &example_group_block); end
+    def example_group(*args, &example_group_block); end
+    def fcontext(*args, &example_group_block); end
+    def fdescribe(*args, &example_group_block); end
+    def reset; end
+    def shared_context(name, *args, &block); end
+    def shared_examples(name, *args, &block); end
+    def shared_examples_for(name, *args, &block); end
+    def world; end
+    def world=(_arg0); end
+    def xcontext(*args, &example_group_block); end
+    def xdescribe(*args, &example_group_block); end
+  end
+end
+
+RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
+RSpec::SharedContext = RSpec::Core::SharedContext
+
+module RSpec::Sorbet
+  extend ::RSpec::Sorbet::Doubles
+end
+
+module RSpec::Sorbet::Doubles
+  def allow_doubles!; end
+  def allow_instance_doubles!; end
+
+  private
+
+  def call_validation_error_handler(_signature, opts); end
+  def double_message_with_ellipsis?(message); end
+  def inline_type_error_handler(error); end
+  def typed_array_message?(message); end
+  def unable_to_check_type_for_message?(message); end
+end
+
+RSpec::Sorbet::Doubles::INLINE_DOUBLE_REGEX = T.let(T.unsafe(nil), Regexp)
+RSpec::Sorbet::Doubles::TYPED_ARRAY_MESSAGE = T.let(T.unsafe(nil), Regexp)
+RSpec::Sorbet::Doubles::VERIFYING_DOUBLE_OR_DOUBLE = T.let(T.unsafe(nil), Regexp)
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-support@3.10.2.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-support@3.10.2.rbi
index 0b7d45ba67..96a4cf4bf7 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-support@3.10.2.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rspec-support@3.10.2.rbi
@@ -1,8 +1,509 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `rspec-support` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module RSpec
+  extend ::RSpec::Support::Warnings
+  extend ::RSpec::Core::Warnings
+
+  class << self
+    def clear_examples; end
+    def configuration; end
+    def configuration=(_arg0); end
+    def configure; end
+    def const_missing(name); end
+    def context(*args, &example_group_block); end
+    def current_example; end
+    def current_example=(example); end
+    def describe(*args, &example_group_block); end
+    def example_group(*args, &example_group_block); end
+    def fcontext(*args, &example_group_block); end
+    def fdescribe(*args, &example_group_block); end
+    def reset; end
+    def shared_context(name, *args, &block); end
+    def shared_examples(name, *args, &block); end
+    def shared_examples_for(name, *args, &block); end
+    def world; end
+    def world=(_arg0); end
+    def xcontext(*args, &example_group_block); end
+    def xdescribe(*args, &example_group_block); end
+  end
+end
+
+class RSpec::CallerFilter
+  class << self
+    def first_non_rspec_line(skip_frames = T.unsafe(nil), increment = T.unsafe(nil)); end
+  end
+end
+
+RSpec::CallerFilter::ADDITIONAL_TOP_LEVEL_FILES = T.let(T.unsafe(nil), Array)
+RSpec::CallerFilter::IGNORE_REGEX = T.let(T.unsafe(nil), Regexp)
+RSpec::CallerFilter::LIB_REGEX = T.let(T.unsafe(nil), Regexp)
+RSpec::CallerFilter::RSPEC_LIBS = T.let(T.unsafe(nil), Array)
+RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
+RSpec::SharedContext = RSpec::Core::SharedContext
+
+module RSpec::Support
+  class << self
+    def class_of(object); end
+    def define_optimized_require_for_rspec(lib, &require_relative); end
+    def deregister_matcher_definition(&block); end
+    def failure_notifier; end
+    def failure_notifier=(callable); end
+    def is_a_matcher?(object); end
+    def matcher_definitions; end
+    def method_handle_for(object, method_name); end
+    def notify_failure(failure, options = T.unsafe(nil)); end
+    def register_matcher_definition(&block); end
+    def require_rspec_core(f); end
+    def require_rspec_expectations(f); end
+    def require_rspec_matchers(f); end
+    def require_rspec_mocks(f); end
+    def require_rspec_support(f); end
+    def rspec_description_for_object(object); end
+    def thread_local_data; end
+    def warning_notifier; end
+    def warning_notifier=(_arg0); end
+    def with_failure_notifier(callable); end
+  end
+end
+
+module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
+  class << self
+    def ===(exception); end
+  end
+end
+
+RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue::AVOID_RESCUING = T.let(T.unsafe(nil), Array)
+
+class RSpec::Support::BlockSignature < ::RSpec::Support::MethodSignature
+  def classify_parameters; end
+end
+
+class RSpec::Support::ComparableVersion
+  include ::Comparable
+
+  def initialize(string); end
+
+  def <=>(other); end
+  def segments; end
+  def string; end
+end
+
+RSpec::Support::DEFAULT_FAILURE_NOTIFIER = T.let(T.unsafe(nil), Proc)
+RSpec::Support::DEFAULT_WARNING_NOTIFIER = T.let(T.unsafe(nil), Proc)
+
+class RSpec::Support::Differ
+  def initialize(opts = T.unsafe(nil)); end
+
+  def color?; end
+  def diff(actual, expected); end
+  def diff_as_object(actual, expected); end
+  def diff_as_string(actual, expected); end
+
+  private
+
+  def add_old_hunk_to_hunk(hunk, oldhunk); end
+  def add_to_output(output, string); end
+  def all_strings?(*args); end
+  def any_multiline_strings?(*args); end
+  def blue(text); end
+  def build_hunks(actual, expected); end
+  def coerce_to_string(string_or_array); end
+  def color(text, color_code); end
+  def color_diff(diff); end
+  def diffably_stringify(array); end
+  def finalize_output(output, final_line); end
+  def format_type; end
+  def green(text); end
+  def handle_encoding_errors(actual, expected); end
+  def hash_to_string(hash); end
+  def multiline?(string); end
+  def no_numbers?(*args); end
+  def no_procs?(*args); end
+  def normal(text); end
+  def object_to_string(object); end
+  def red(text); end
+  def safely_flatten(array); end
+end
+
+class RSpec::Support::DirectoryMaker
+  class << self
+    def mkdir_p(path); end
+
+    private
+
+    def directory_exists?(dirname); end
+    def generate_path(stack, part); end
+    def generate_stack(path); end
+  end
+end
+
+class RSpec::Support::EncodedString
+  def initialize(string, encoding = T.unsafe(nil)); end
+
+  def <<(string); end
+  def ==(*args, &block); end
+  def empty?(*args, &block); end
+  def encoding(*args, &block); end
+  def eql?(*args, &block); end
+  def lines(*args, &block); end
+  def source_encoding; end
+  def split(regex_or_string); end
+  def to_s; end
+  def to_str; end
+
+  private
+
+  def detect_source_encoding(string); end
+  def matching_encoding(string); end
+  def remove_invalid_bytes(string); end
+
+  class << self
+    def pick_encoding(source_a, source_b); end
+  end
+end
+
+RSpec::Support::EncodedString::REPLACE = T.let(T.unsafe(nil), String)
+RSpec::Support::EncodedString::US_ASCII = T.let(T.unsafe(nil), String)
+RSpec::Support::EncodedString::UTF_8 = T.let(T.unsafe(nil), String)
+
+module RSpec::Support::FuzzyMatcher
+  class << self
+    def values_match?(expected, actual); end
+
+    private
+
+    def arrays_match?(expected_list, actual_list); end
+    def hashes_match?(expected_hash, actual_hash); end
+  end
+end
+
+class RSpec::Support::HunkGenerator
+  def initialize(actual, expected); end
+
+  def hunks; end
+
+  private
+
+  def actual_lines; end
+  def build_hunk(piece); end
+  def context_lines; end
+  def diffs; end
+  def expected_lines; end
+end
+
+RSpec::Support::KERNEL_METHOD_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+class RSpec::Support::LooseSignatureVerifier < ::RSpec::Support::MethodSignatureVerifier
+  private
+
+  def split_args(*args); end
+end
+
+class RSpec::Support::LooseSignatureVerifier::SignatureWithKeywordArgumentsMatcher
+  def initialize(signature); end
+
+  def has_kw_args_in?(args); end
+  def invalid_kw_args_from(_kw_args); end
+  def missing_kw_args_from(_kw_args); end
+  def non_kw_args_arity_description; end
+  def valid_non_kw_args?(*args); end
+end
+
+class RSpec::Support::MethodSignature
+  def initialize(method); end
+
+  def arbitrary_kw_args?; end
+  def classify_arity(arity = T.unsafe(nil)); end
+  def classify_parameters; end
+  def could_contain_kw_args?(args); end
+  def description; end
+  def has_kw_args_in?(args); end
+  def invalid_kw_args_from(given_kw_args); end
+  def max_non_kw_args; end
+  def min_non_kw_args; end
+  def missing_kw_args_from(given_kw_args); end
+  def non_kw_args_arity_description; end
+  def optional_kw_args; end
+  def required_kw_args; end
+  def unlimited_args?; end
+  def valid_non_kw_args?(positional_arg_count, optional_max_arg_count = T.unsafe(nil)); end
+end
+
+RSpec::Support::MethodSignature::INFINITY = T.let(T.unsafe(nil), Float)
+
+class RSpec::Support::MethodSignatureExpectation
+  def initialize; end
+
+  def empty?; end
+  def expect_arbitrary_keywords; end
+  def expect_arbitrary_keywords=(_arg0); end
+  def expect_unlimited_arguments; end
+  def expect_unlimited_arguments=(_arg0); end
+  def keywords; end
+  def keywords=(values); end
+  def max_count; end
+  def max_count=(number); end
+  def min_count; end
+  def min_count=(number); end
+end
+
+class RSpec::Support::MethodSignatureVerifier
+  def initialize(signature, args = T.unsafe(nil)); end
+
+  def error_message; end
+  def kw_args; end
+  def max_non_kw_args; end
+  def min_non_kw_args; end
+  def non_kw_args; end
+  def valid?; end
+  def with_expectation(expectation); end
+
+  private
+
+  def arbitrary_kw_args?; end
+  def invalid_kw_args; end
+  def missing_kw_args; end
+  def split_args(*args); end
+  def unlimited_args?; end
+  def valid_non_kw_args?; end
+end
+
+class RSpec::Support::Mutex < ::Thread::Mutex
+  class << self
+    def new; end
+  end
+end
+
+RSpec::Support::Mutex::NEW_MUTEX_METHOD = T.let(T.unsafe(nil), Method)
+
+module RSpec::Support::OS
+  private
+
+  def windows?; end
+  def windows_file_path?; end
+
+  class << self
+    def windows?; end
+    def windows_file_path?; end
+  end
+end
+
+class RSpec::Support::ObjectFormatter
+  def initialize(max_formatted_output_length = T.unsafe(nil)); end
+
+  def format(object); end
+  def max_formatted_output_length; end
+  def max_formatted_output_length=(_arg0); end
+  def prepare_array(array); end
+  def prepare_element(element); end
+  def prepare_for_inspection(object); end
+  def prepare_hash(input_hash); end
+  def recursive_structure?(object); end
+  def sort_hash_keys(input_hash); end
+  def with_entering_structure(structure); end
+
+  private
+
+  def truncate_string(str, start_index, end_index); end
+
+  class << self
+    def default_instance; end
+    def format(object); end
+    def prepare_for_inspection(object); end
+  end
+end
+
+class RSpec::Support::ObjectFormatter::BaseInspector < ::Struct
+  def formatter; end
+  def formatter=(_); end
+  def inspect; end
+  def object; end
+  def object=(_); end
+  def pretty_print(pp); end
+
+  class << self
+    def [](*_arg0); end
+    def can_inspect?(_object); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class RSpec::Support::ObjectFormatter::BigDecimalInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
+  def inspect; end
+
+  class << self
+    def can_inspect?(object); end
+  end
+end
+
+class RSpec::Support::ObjectFormatter::DateTimeInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
+  def inspect; end
+
+  class << self
+    def can_inspect?(object); end
+  end
+end
+
+RSpec::Support::ObjectFormatter::DateTimeInspector::FORMAT = T.let(T.unsafe(nil), String)
+
+class RSpec::Support::ObjectFormatter::DelegatorInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
+  def inspect; end
+
+  class << self
+    def can_inspect?(object); end
+  end
+end
+
+class RSpec::Support::ObjectFormatter::DescribableMatcherInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
+  def inspect; end
+
+  class << self
+    def can_inspect?(object); end
+  end
+end
+
+RSpec::Support::ObjectFormatter::ELLIPSIS = T.let(T.unsafe(nil), String)
+RSpec::Support::ObjectFormatter::INSPECTOR_CLASSES = T.let(T.unsafe(nil), Array)
+
+class RSpec::Support::ObjectFormatter::InspectableItem < ::Struct
+  def inspect; end
+  def pretty_print(pp); end
+  def text; end
+  def text=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class RSpec::Support::ObjectFormatter::InspectableObjectInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
+  def inspect; end
+
+  class << self
+    def can_inspect?(object); end
+  end
+end
+
+class RSpec::Support::ObjectFormatter::TimeInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
+  def inspect; end
+
+  class << self
+    def can_inspect?(object); end
+  end
+end
+
+RSpec::Support::ObjectFormatter::TimeInspector::FORMAT = T.let(T.unsafe(nil), String)
+
+class RSpec::Support::ObjectFormatter::UninspectableObjectInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
+  def inspect; end
+  def klass; end
+  def native_object_id; end
+
+  class << self
+    def can_inspect?(object); end
+  end
+end
+
+RSpec::Support::ObjectFormatter::UninspectableObjectInspector::OBJECT_ID_FORMAT = T.let(T.unsafe(nil), String)
+
+module RSpec::Support::RecursiveConstMethods
+  def const_defined_on?(mod, const_name); end
+  def constants_defined_on(mod); end
+  def get_const_defined_on(mod, const_name); end
+  def normalize_const_name(const_name); end
+  def recursive_const_defined?(const_name); end
+  def recursive_const_get(const_name); end
+end
+
+class RSpec::Support::ReentrantMutex
+  def initialize; end
+
+  def synchronize; end
+
+  private
+
+  def enter; end
+  def exit; end
+end
+
+module RSpec::Support::Ruby
+  private
+
+  def jruby?; end
+  def jruby_9000?; end
+  def jruby_version; end
+  def mri?; end
+  def non_mri?; end
+  def rbx?; end
+  def truffleruby?; end
+
+  class << self
+    def jruby?; end
+    def jruby_9000?; end
+    def jruby_version; end
+    def mri?; end
+    def non_mri?; end
+    def rbx?; end
+    def truffleruby?; end
+  end
+end
+
+module RSpec::Support::RubyFeatures
+  private
+
+  def caller_locations_supported?; end
+  def fork_supported?; end
+  def kw_args_supported?; end
+  def module_prepends_supported?; end
+  def module_refinement_supported?; end
+  def optional_and_splat_args_supported?; end
+  def required_kw_args_supported?; end
+  def ripper_supported?; end
+  def supports_exception_cause?; end
+  def supports_rebinding_module_methods?; end
+  def supports_taint?; end
+
+  class << self
+    def caller_locations_supported?; end
+    def fork_supported?; end
+    def kw_args_supported?; end
+    def module_prepends_supported?; end
+    def module_refinement_supported?; end
+    def optional_and_splat_args_supported?; end
+    def required_kw_args_supported?; end
+    def ripper_supported?; end
+    def supports_exception_cause?; end
+    def supports_rebinding_module_methods?; end
+    def supports_taint?; end
+  end
+end
+
+RSpec::Support::StrictSignatureVerifier = RSpec::Support::MethodSignatureVerifier
+module RSpec::Support::Version; end
+RSpec::Support::Version::STRING = T.let(T.unsafe(nil), String)
+
+module RSpec::Support::Warnings
+  def deprecate(deprecated, options = T.unsafe(nil)); end
+  def warn_deprecation(message, options = T.unsafe(nil)); end
+  def warn_with(message, options = T.unsafe(nil)); end
+  def warning(text, options = T.unsafe(nil)); end
+end
+
+module RSpec::Support::WithKeywordsWhenNeeded
+  private
+
+  def class_exec(klass, *args, &block); end
+
+  class << self
+    def class_exec(klass, *args, &block); end
+  end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec-wait@0.0.9.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec-wait@0.0.9.rbi
index f94543a332..4e99e4220a 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rspec-wait@0.0.9.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rspec-wait@0.0.9.rbi
@@ -1,7 +1,89 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `rspec-wait` gem.
-# Please instead update this file by running `tapioca generate --exclude json`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
+module RSpec
+  extend ::RSpec::Support::Warnings
+  extend ::RSpec::Core::Warnings
 
+  class << self
+    def clear_examples; end
+    def configuration; end
+    def configuration=(_arg0); end
+    def configure; end
+    def const_missing(name); end
+    def context(*args, &example_group_block); end
+    def current_example; end
+    def current_example=(example); end
+    def describe(*args, &example_group_block); end
+    def example_group(*args, &example_group_block); end
+    def fcontext(*args, &example_group_block); end
+    def fdescribe(*args, &example_group_block); end
+    def reset; end
+    def shared_context(name, *args, &block); end
+    def shared_examples(name, *args, &block); end
+    def shared_examples_for(name, *args, &block); end
+    def world; end
+    def world=(_arg0); end
+    def xcontext(*args, &example_group_block); end
+    def xdescribe(*args, &example_group_block); end
+  end
+end
+
+RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
+RSpec::SharedContext = RSpec::Core::SharedContext
+
+module RSpec::Wait
+  private
+
+  def wait(timeout = T.unsafe(nil), options = T.unsafe(nil)); end
+  def wait_for(value = T.unsafe(nil), &block); end
+  def with_wait(options); end
+
+  class << self
+    def wait(timeout = T.unsafe(nil), options = T.unsafe(nil)); end
+    def wait_for(value = T.unsafe(nil), &block); end
+    def with_wait(options); end
+  end
+end
+
+class RSpec::Wait::Error < ::StandardError; end
+
+module RSpec::Wait::Handler
+  def handle_matcher(target, *args, &block); end
+end
+
+class RSpec::Wait::NegativeHandler < ::RSpec::Expectations::NegativeExpectationHandler
+  extend ::RSpec::Wait::Handler
+end
+
+class RSpec::Wait::PositiveHandler < ::RSpec::Expectations::PositiveExpectationHandler
+  extend ::RSpec::Wait::Handler
+end
+
+class RSpec::Wait::Proxy
+  def initialize(options); end
+
+  def for(value = T.unsafe(nil), &block); end
+end
+
+class RSpec::Wait::Target < ::RSpec::Expectations::ExpectationTarget
+  def initialize(target, options); end
+
+  def not_to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
+  def to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
+  def to_not(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
+
+  private
+
+  def with_wait; end
+
+  class << self
+    def for(value, block, options = T.unsafe(nil)); end
+  end
+end
+
+module RSpec::Wait::Target::UndefinedValue; end
+class RSpec::Wait::TimeoutError < ::RSpec::Wait::Error; end
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec@3.10.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec@3.10.0.rbi
index 8dc5c653a2..36dd9da2a9 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rspec@3.10.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rspec@3.10.0.rbi
@@ -1,8 +1,38 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `rspec` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module RSpec
+  extend ::RSpec::Support::Warnings
+  extend ::RSpec::Core::Warnings
+
+  class << self
+    def clear_examples; end
+    def configuration; end
+    def configuration=(_arg0); end
+    def configure; end
+    def const_missing(name); end
+    def context(*args, &example_group_block); end
+    def current_example; end
+    def current_example=(example); end
+    def describe(*args, &example_group_block); end
+    def example_group(*args, &example_group_block); end
+    def fcontext(*args, &example_group_block); end
+    def fdescribe(*args, &example_group_block); end
+    def reset; end
+    def shared_context(name, *args, &block); end
+    def shared_examples(name, *args, &block); end
+    def shared_examples_for(name, *args, &block); end
+    def world; end
+    def world=(_arg0); end
+    def xcontext(*args, &example_group_block); end
+    def xdescribe(*args, &example_group_block); end
+  end
+end
+
+RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
+RSpec::SharedContext = RSpec::Core::SharedContext
+module RSpec::Version; end
+RSpec::Version::STRING = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/rspec_junit_formatter@0.4.1.rbi b/Library/Homebrew/sorbet/rbi/gems/rspec_junit_formatter@0.4.1.rbi
index 62306a9721..587ff79129 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rspec_junit_formatter@0.4.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rspec_junit_formatter@0.4.1.rbi
@@ -4,5 +4,46 @@
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+class RSpecJUnitFormatter < ::RSpec::Core::Formatters::BaseFormatter
+  def dump_summary(notification); end
+  def start(notification); end
+  def stop(notification); end
+
+  private
+
+  def classname_for(notification); end
+  def description_for(notification); end
+  def duration; end
+  def duration_for(notification); end
+  def escape(text); end
+  def example_count; end
+  def example_group_file_path_for(notification); end
+  def examples; end
+  def exception_for(notification); end
+  def failure_count; end
+  def failure_for(notification); end
+  def failure_message_for(example); end
+  def failure_type_for(example); end
+  def pending_count; end
+  def result_of(notification); end
+  def started; end
+  def stderr_for(example_notification); end
+  def stdout_for(example_notification); end
+  def strip_diff_colors(string); end
+  def swap_rspec_configuration(key, value); end
+  def without_color(&block); end
+  def xml_dump; end
+  def xml_dump_example(example); end
+  def xml_dump_examples; end
+  def xml_dump_failed(example); end
+  def xml_dump_output(example); end
+  def xml_dump_pending(example); end
+end
+
+RSpecJUnitFormatter::DISCOURAGED_REGEXP = T.let(T.unsafe(nil), Regexp)
+RSpecJUnitFormatter::DISCOURAGED_REPLACEMENTS = T.let(T.unsafe(nil), Hash)
+RSpecJUnitFormatter::ILLEGAL_REGEXP = T.let(T.unsafe(nil), Regexp)
+RSpecJUnitFormatter::ILLEGAL_REPLACEMENT = T.let(T.unsafe(nil), Hash)
+RSpecJUnitFormatter::STRIP_DIFF_COLORS_BLOCK_REGEXP = T.let(T.unsafe(nil), Regexp)
+RSpecJUnitFormatter::STRIP_DIFF_COLORS_CODES_REGEXP = T.let(T.unsafe(nil), Regexp)
+RspecJunitFormatter = RSpecJUnitFormatter
diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@1.11.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@1.11.0.rbi
index d7600dc39c..bae1beb69c 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@1.11.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rubocop-ast@1.11.0.rbi
@@ -4,269 +4,6 @@
 
 # typed: true
 
-class AST::Node
-  def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
-
-  def +(array); end
-  def <<(element); end
-  def ==(other); end
-  def append(element); end
-  def children; end
-  def clone; end
-  def concat(array); end
-  def deconstruct; end
-  def dup; end
-  def eql?(other); end
-  def hash; end
-  def inspect(indent = T.unsafe(nil)); end
-  def to_a; end
-  def to_ast; end
-  def to_s(indent = T.unsafe(nil)); end
-  def to_sexp(indent = T.unsafe(nil)); end
-  def to_sexp_array; end
-  def type; end
-  def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end
-
-  protected
-
-  def assign_properties(properties); end
-  def fancy_type; end
-
-  private
-
-  def original_dup; end
-end
-
-class Parser::AST::Node < ::AST::Node
-  def assign_properties(properties); end
-  def loc; end
-  def location; end
-end
-
-class Parser::Builders::Default
-  def initialize; end
-
-  def __ENCODING__(__ENCODING__t); end
-  def __FILE__(__FILE__t); end
-  def __LINE__(__LINE__t); end
-  def accessible(node); end
-  def alias(alias_t, to, from); end
-  def arg(name_t); end
-  def arg_expr(expr); end
-  def args(begin_t, args, end_t, check_args = T.unsafe(nil)); end
-  def array(begin_t, elements, end_t); end
-  def array_pattern(lbrack_t, elements, rbrack_t); end
-  def assign(lhs, eql_t, rhs); end
-  def assignable(node); end
-  def associate(begin_t, pairs, end_t); end
-  def attr_asgn(receiver, dot_t, selector_t); end
-  def back_ref(token); end
-  def begin(begin_t, body, end_t); end
-  def begin_body(compound_stmt, rescue_bodies = T.unsafe(nil), else_t = T.unsafe(nil), else_ = T.unsafe(nil), ensure_t = T.unsafe(nil), ensure_ = T.unsafe(nil)); end
-  def begin_keyword(begin_t, body, end_t); end
-  def binary_op(receiver, operator_t, arg); end
-  def block(method_call, begin_t, args, body, end_t); end
-  def block_pass(amper_t, arg); end
-  def blockarg(amper_t, name_t); end
-  def blockarg_expr(amper_t, expr); end
-  def call_lambda(lambda_t); end
-  def call_method(receiver, dot_t, selector_t, lparen_t = T.unsafe(nil), args = T.unsafe(nil), rparen_t = T.unsafe(nil)); end
-  def call_type_for_dot(dot_t); end
-  def case(case_t, expr, when_bodies, else_t, else_body, end_t); end
-  def case_match(case_t, expr, in_bodies, else_t, else_body, end_t); end
-  def character(char_t); end
-  def complex(complex_t); end
-  def compstmt(statements); end
-  def condition(cond_t, cond, then_t, if_true, else_t, if_false, end_t); end
-  def condition_mod(if_true, if_false, cond_t, cond); end
-  def const(name_t); end
-  def const_fetch(scope, t_colon2, name_t); end
-  def const_global(t_colon3, name_t); end
-  def const_op_assignable(node); end
-  def const_pattern(const, ldelim_t, pattern, rdelim_t); end
-  def cvar(token); end
-  def dedent_string(node, dedent_level); end
-  def def_class(class_t, name, lt_t, superclass, body, end_t); end
-  def def_endless_method(def_t, name_t, args, assignment_t, body); end
-  def def_endless_singleton(def_t, definee, dot_t, name_t, args, assignment_t, body); end
-  def def_method(def_t, name_t, args, body, end_t); end
-  def def_module(module_t, name, body, end_t); end
-  def def_sclass(class_t, lshft_t, expr, body, end_t); end
-  def def_singleton(def_t, definee, dot_t, name_t, args, body, end_t); end
-  def emit_file_line_as_literals; end
-  def emit_file_line_as_literals=(_arg0); end
-  def false(false_t); end
-  def find_pattern(lbrack_t, elements, rbrack_t); end
-  def float(float_t); end
-  def for(for_t, iterator, in_t, iteratee, do_t, body, end_t); end
-  def forward_arg(dots_t); end
-  def forward_only_args(begin_t, dots_t, end_t); end
-  def forwarded_args(dots_t); end
-  def gvar(token); end
-  def hash_pattern(lbrace_t, kwargs, rbrace_t); end
-  def ident(token); end
-  def if_guard(if_t, if_body); end
-  def in_match(lhs, in_t, rhs); end
-  def in_pattern(in_t, pattern, guard, then_t, body); end
-  def index(receiver, lbrack_t, indexes, rbrack_t); end
-  def index_asgn(receiver, lbrack_t, indexes, rbrack_t); end
-  def integer(integer_t); end
-  def ivar(token); end
-  def keyword_cmd(type, keyword_t, lparen_t = T.unsafe(nil), args = T.unsafe(nil), rparen_t = T.unsafe(nil)); end
-  def kwarg(name_t); end
-  def kwnilarg(dstar_t, nil_t); end
-  def kwoptarg(name_t, value); end
-  def kwrestarg(dstar_t, name_t = T.unsafe(nil)); end
-  def kwsplat(dstar_t, arg); end
-  def logical_op(type, lhs, op_t, rhs); end
-  def loop(type, keyword_t, cond, do_t, body, end_t); end
-  def loop_mod(type, body, keyword_t, cond); end
-  def match_alt(left, pipe_t, right); end
-  def match_as(value, assoc_t, as); end
-  def match_hash_var(name_t); end
-  def match_hash_var_from_str(begin_t, strings, end_t); end
-  def match_label(label_type, label); end
-  def match_nil_pattern(dstar_t, nil_t); end
-  def match_op(receiver, match_t, arg); end
-  def match_pair(label_type, label, value); end
-  def match_pattern(lhs, match_t, rhs); end
-  def match_pattern_p(lhs, match_t, rhs); end
-  def match_rest(star_t, name_t = T.unsafe(nil)); end
-  def match_var(name_t); end
-  def match_with_trailing_comma(match, comma_t); end
-  def multi_assign(lhs, eql_t, rhs); end
-  def multi_lhs(begin_t, items, end_t); end
-  def nil(nil_t); end
-  def not_op(not_t, begin_t = T.unsafe(nil), receiver = T.unsafe(nil), end_t = T.unsafe(nil)); end
-  def nth_ref(token); end
-  def numargs(max_numparam); end
-  def objc_kwarg(kwname_t, assoc_t, name_t); end
-  def objc_restarg(star_t, name = T.unsafe(nil)); end
-  def objc_varargs(pair, rest_of_varargs); end
-  def op_assign(lhs, op_t, rhs); end
-  def optarg(name_t, eql_t, value); end
-  def pair(key, assoc_t, value); end
-  def pair_keyword(key_t, value); end
-  def pair_list_18(list); end
-  def pair_quoted(begin_t, parts, end_t, value); end
-  def parser; end
-  def parser=(_arg0); end
-  def pin(pin_t, var); end
-  def postexe(postexe_t, lbrace_t, compstmt, rbrace_t); end
-  def preexe(preexe_t, lbrace_t, compstmt, rbrace_t); end
-  def procarg0(arg); end
-  def range_exclusive(lhs, dot3_t, rhs); end
-  def range_inclusive(lhs, dot2_t, rhs); end
-  def rational(rational_t); end
-  def regexp_compose(begin_t, parts, end_t, options); end
-  def regexp_options(regopt_t); end
-  def rescue_body(rescue_t, exc_list, assoc_t, exc_var, then_t, compound_stmt); end
-  def restarg(star_t, name_t = T.unsafe(nil)); end
-  def restarg_expr(star_t, expr = T.unsafe(nil)); end
-  def self(token); end
-  def shadowarg(name_t); end
-  def splat(star_t, arg = T.unsafe(nil)); end
-  def string(string_t); end
-  def string_compose(begin_t, parts, end_t); end
-  def string_internal(string_t); end
-  def symbol(symbol_t); end
-  def symbol_compose(begin_t, parts, end_t); end
-  def symbol_internal(symbol_t); end
-  def symbols_compose(begin_t, parts, end_t); end
-  def ternary(cond, question_t, if_true, colon_t, if_false); end
-  def true(true_t); end
-  def unary_num(unary_t, numeric); end
-  def unary_op(op_t, receiver); end
-  def undef_method(undef_t, names); end
-  def unless_guard(unless_t, unless_body); end
-  def when(when_t, patterns, then_t, body); end
-  def word(parts); end
-  def words_compose(begin_t, parts, end_t); end
-  def xstring_compose(begin_t, parts, end_t); end
-
-  private
-
-  def arg_name_collides?(this_name, that_name); end
-  def arg_prefix_map(op_t, name_t = T.unsafe(nil)); end
-  def binary_op_map(left_e, op_t, right_e); end
-  def block_map(receiver_l, begin_t, end_t); end
-  def check_assignment_to_numparam(name, loc); end
-  def check_condition(cond); end
-  def check_duplicate_arg(this_arg, map = T.unsafe(nil)); end
-  def check_duplicate_args(args, map = T.unsafe(nil)); end
-  def check_duplicate_pattern_key(name, loc); end
-  def check_duplicate_pattern_variable(name, loc); end
-  def check_lvar_name(name, loc); end
-  def check_reserved_for_numparam(name, loc); end
-  def collapse_string_parts?(parts); end
-  def collection_map(begin_t, parts, end_t); end
-  def condition_map(keyword_t, cond_e, begin_t, body_e, else_t, else_e, end_t); end
-  def constant_map(scope, colon2_t, name_t); end
-  def definition_map(keyword_t, operator_t, name_t, end_t); end
-  def delimited_string_map(string_t); end
-  def diagnostic(type, reason, arguments, location, highlights = T.unsafe(nil)); end
-  def eh_keyword_map(compstmt_e, keyword_t, body_es, else_t, else_e); end
-  def endless_definition_map(keyword_t, operator_t, name_t, assignment_t, body_e); end
-  def expr_map(loc); end
-  def for_map(keyword_t, in_t, begin_t, end_t); end
-  def guard_map(keyword_t, guard_body_e); end
-  def index_map(receiver_e, lbrack_t, rbrack_t); end
-  def join_exprs(left_expr, right_expr); end
-  def keyword_map(keyword_t, begin_t, args, end_t); end
-  def keyword_mod_map(pre_e, keyword_t, post_e); end
-  def kwarg_map(name_t, value_e = T.unsafe(nil)); end
-  def kwargs?(node); end
-  def loc(token); end
-  def module_definition_map(keyword_t, name_e, operator_t, end_t); end
-  def n(type, children, source_map); end
-  def n0(type, source_map); end
-  def numeric(kind, token); end
-  def pair_keyword_map(key_t, value_e); end
-  def pair_quoted_map(begin_t, end_t, value_e); end
-  def prefix_string_map(symbol); end
-  def range_map(start_e, op_t, end_e); end
-  def regexp_map(begin_t, end_t, options_e); end
-  def rescue_body_map(keyword_t, exc_list_e, assoc_t, exc_var_e, then_t, compstmt_e); end
-  def rewrite_hash_args_to_kwargs(args); end
-  def send_binary_op_map(lhs_e, selector_t, rhs_e); end
-  def send_index_map(receiver_e, lbrack_t, rbrack_t); end
-  def send_map(receiver_e, dot_t, selector_t, begin_t = T.unsafe(nil), args = T.unsafe(nil), end_t = T.unsafe(nil)); end
-  def send_unary_op_map(selector_t, arg_e); end
-  def static_regexp(parts, options); end
-  def static_regexp_node(node); end
-  def static_string(nodes); end
-  def string_map(begin_t, parts, end_t); end
-  def string_value(token); end
-  def ternary_map(begin_e, question_t, mid_e, colon_t, end_e); end
-  def token_map(token); end
-  def unary_op_map(op_t, arg_e = T.unsafe(nil)); end
-  def unquoted_map(token); end
-  def validate_definee(definee); end
-  def value(token); end
-  def var_send_map(variable_e); end
-  def variable_map(name_t); end
-
-  class << self
-    def emit_arg_inside_procarg0; end
-    def emit_arg_inside_procarg0=(_arg0); end
-    def emit_encoding; end
-    def emit_encoding=(_arg0); end
-    def emit_forward_arg; end
-    def emit_forward_arg=(_arg0); end
-    def emit_index; end
-    def emit_index=(_arg0); end
-    def emit_kwargs; end
-    def emit_kwargs=(_arg0); end
-    def emit_lambda; end
-    def emit_lambda=(_arg0); end
-    def emit_match_pattern; end
-    def emit_match_pattern=(_arg0); end
-    def emit_procarg0; end
-    def emit_procarg0=(_arg0); end
-    def modernize; end
-  end
-end
-
 module RuboCop; end
 
 module RuboCop::AST
diff --git a/Library/Homebrew/sorbet/rbi/gems/rubocop@1.20.0.rbi b/Library/Homebrew/sorbet/rbi/gems/rubocop@1.20.0.rbi
index 3c282c1fc1..06fb558c36 100644
--- a/Library/Homebrew/sorbet/rbi/gems/rubocop@1.20.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/rubocop@1.20.0.rbi
@@ -4,251 +4,6 @@
 
 # typed: true
 
-module Parser::Deprecation
-  def warn_of_deprecation; end
-  def warned_of_deprecation=(_arg0); end
-end
-
-class Parser::Source::Map
-  def initialize(expression); end
-
-  def ==(other); end
-  def column; end
-  def expression; end
-  def first_line; end
-  def last_column; end
-  def last_line; end
-  def line; end
-  def node; end
-  def node=(node); end
-  def to_hash; end
-  def with_expression(expression_l); end
-
-  protected
-
-  def update_expression(expression_l); end
-  def with(&block); end
-
-  private
-
-  def initialize_copy(other); end
-end
-
-class Parser::Source::Map::Collection < ::Parser::Source::Map
-  def initialize(begin_l, end_l, expression_l); end
-
-  def begin; end
-  def end; end
-end
-
-class Parser::Source::Map::Condition < ::Parser::Source::Map
-  def initialize(keyword_l, begin_l, else_l, end_l, expression_l); end
-
-  def begin; end
-  def else; end
-  def end; end
-  def keyword; end
-end
-
-class Parser::Source::Map::Constant < ::Parser::Source::Map
-  def initialize(double_colon, name, expression); end
-
-  def double_colon; end
-  def name; end
-  def operator; end
-  def with_operator(operator_l); end
-
-  protected
-
-  def update_operator(operator_l); end
-end
-
-class Parser::Source::Map::Definition < ::Parser::Source::Map
-  def initialize(keyword_l, operator_l, name_l, end_l); end
-
-  def end; end
-  def keyword; end
-  def name; end
-  def operator; end
-end
-
-class Parser::Source::Map::For < ::Parser::Source::Map
-  def initialize(keyword_l, in_l, begin_l, end_l, expression_l); end
-
-  def begin; end
-  def end; end
-  def in; end
-  def keyword; end
-end
-
-class Parser::Source::Map::Heredoc < ::Parser::Source::Map
-  def initialize(begin_l, body_l, end_l); end
-
-  def heredoc_body; end
-  def heredoc_end; end
-end
-
-class Parser::Source::Map::Index < ::Parser::Source::Map
-  def initialize(begin_l, end_l, expression_l); end
-
-  def begin; end
-  def end; end
-  def operator; end
-  def with_operator(operator_l); end
-
-  protected
-
-  def update_operator(operator_l); end
-end
-
-class Parser::Source::Map::Keyword < ::Parser::Source::Map
-  def initialize(keyword_l, begin_l, end_l, expression_l); end
-
-  def begin; end
-  def end; end
-  def keyword; end
-end
-
-class Parser::Source::Map::MethodDefinition < ::Parser::Source::Map
-  def initialize(keyword_l, operator_l, name_l, end_l, assignment_l, body_l); end
-
-  def assignment; end
-  def end; end
-  def keyword; end
-  def name; end
-  def operator; end
-end
-
-class Parser::Source::Map::ObjcKwarg < ::Parser::Source::Map
-  def initialize(keyword_l, operator_l, argument_l, expression_l); end
-
-  def argument; end
-  def keyword; end
-  def operator; end
-end
-
-class Parser::Source::Map::Operator < ::Parser::Source::Map
-  def initialize(operator, expression); end
-
-  def operator; end
-end
-
-class Parser::Source::Map::RescueBody < ::Parser::Source::Map
-  def initialize(keyword_l, assoc_l, begin_l, expression_l); end
-
-  def assoc; end
-  def begin; end
-  def keyword; end
-end
-
-class Parser::Source::Map::Send < ::Parser::Source::Map
-  def initialize(dot_l, selector_l, begin_l, end_l, expression_l); end
-
-  def begin; end
-  def dot; end
-  def end; end
-  def operator; end
-  def selector; end
-  def with_operator(operator_l); end
-
-  protected
-
-  def update_operator(operator_l); end
-end
-
-class Parser::Source::Map::Ternary < ::Parser::Source::Map
-  def initialize(question_l, colon_l, expression_l); end
-
-  def colon; end
-  def question; end
-end
-
-class Parser::Source::Map::Variable < ::Parser::Source::Map
-  def initialize(name_l, expression_l = T.unsafe(nil)); end
-
-  def name; end
-  def operator; end
-  def with_operator(operator_l); end
-
-  protected
-
-  def update_operator(operator_l); end
-end
-
-class Parser::Source::TreeRewriter
-  extend ::Parser::Deprecation
-
-  def initialize(source_buffer, crossing_deletions: T.unsafe(nil), different_replacements: T.unsafe(nil), swallowed_insertions: T.unsafe(nil)); end
-
-  def as_nested_actions; end
-  def as_replacements; end
-  def diagnostics; end
-  def empty?; end
-  def import!(foreign_rewriter, offset: T.unsafe(nil)); end
-  def in_transaction?; end
-  def insert_after(range, content); end
-  def insert_after_multi(range, text); end
-  def insert_before(range, content); end
-  def insert_before_multi(range, text); end
-  def inspect; end
-  def merge(with); end
-  def merge!(with); end
-  def process; end
-  def remove(range); end
-  def replace(range, content); end
-  def source_buffer; end
-  def transaction; end
-  def wrap(range, insert_before, insert_after); end
-
-  protected
-
-  def action_root; end
-
-  private
-
-  def action_summary; end
-  def check_policy_validity; end
-  def check_range_validity(range); end
-  def combine(range, attributes); end
-  def enforce_policy(event); end
-  def trigger_policy(event, range: T.unsafe(nil), conflict: T.unsafe(nil), **arguments); end
-end
-
-Parser::Source::TreeRewriter::ACTIONS = T.let(T.unsafe(nil), Array)
-
-class Parser::Source::TreeRewriter::Action
-  def initialize(range, enforcer, insert_before: T.unsafe(nil), replacement: T.unsafe(nil), insert_after: T.unsafe(nil), children: T.unsafe(nil)); end
-
-  def combine(action); end
-  def contract; end
-  def empty?; end
-  def insert_after; end
-  def insert_before; end
-  def insertion?; end
-  def moved(source_buffer, offset); end
-  def nested_actions; end
-  def ordered_replacements; end
-  def range; end
-  def replacement; end
-
-  protected
-
-  def analyse_hierarchy(action); end
-  def bsearch_child_index(from = T.unsafe(nil)); end
-  def call_enforcer_for_merge(action); end
-  def check_fusible(action, *fusible); end
-  def children; end
-  def combine_children(more_children); end
-  def do_combine(action); end
-  def fuse_deletions(action, fusible, other_sibblings); end
-  def merge(action); end
-  def place_in_hierarchy(action); end
-  def swallow(children); end
-  def with(range: T.unsafe(nil), enforcer: T.unsafe(nil), children: T.unsafe(nil), insert_before: T.unsafe(nil), replacement: T.unsafe(nil), insert_after: T.unsafe(nil)); end
-end
-
-Parser::Source::TreeRewriter::DEPRECATION_WARNING = T.let(T.unsafe(nil), String)
-Parser::Source::TreeRewriter::POLICY_TO_LEVEL = T.let(T.unsafe(nil), Hash)
 module RuboCop; end
 
 class RuboCop::CLI
@@ -12775,8 +12530,8 @@ end
 
 RuboCop::Formatter::PacmanFormatter::FALLBACK_TERMINAL_WIDTH = T.let(T.unsafe(nil), Integer)
 RuboCop::Formatter::PacmanFormatter::GHOST = T.let(T.unsafe(nil), String)
-RuboCop::Formatter::PacmanFormatter::PACDOT = T.let(T.unsafe(nil), Rainbow::NullPresenter)
-RuboCop::Formatter::PacmanFormatter::PACMAN = T.let(T.unsafe(nil), Rainbow::NullPresenter)
+RuboCop::Formatter::PacmanFormatter::PACDOT = T.let(T.unsafe(nil), Rainbow::Presenter)
+RuboCop::Formatter::PacmanFormatter::PACMAN = T.let(T.unsafe(nil), Rainbow::Presenter)
 
 class RuboCop::Formatter::ProgressFormatter < ::RuboCop::Formatter::ClangStyleFormatter
   include ::RuboCop::Formatter::TextUtil
@@ -13353,6 +13108,7 @@ class String
   include ::Comparable
   include ::JSON::Ext::Generator::GeneratorMethods::String
   include ::Colorize::InstanceMethods
+  include ::MessagePack::CoreExt
   extend ::JSON::Ext::Generator::GeneratorMethods::String::Extend
   extend ::Colorize::ClassMethods
 end
diff --git a/Library/Homebrew/sorbet/rbi/gems/ruby-macho@2.5.1.rbi b/Library/Homebrew/sorbet/rbi/gems/ruby-macho@2.5.1.rbi
index 51cabe4960..9ea9570b24 100644
--- a/Library/Homebrew/sorbet/rbi/gems/ruby-macho@2.5.1.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/ruby-macho@2.5.1.rbi
@@ -4,5 +4,950 @@
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module MachO
+  class << self
+    def codesign!(filename); end
+    def open(filename); end
+  end
+end
+
+class MachO::CPUSubtypeError < ::MachO::MachOError
+  def initialize(cputype, cpusubtype); end
+end
+
+class MachO::CPUTypeError < ::MachO::MachOError
+  def initialize(cputype); end
+end
+
+class MachO::CodeSigningError < ::MachO::MachOError; end
+
+class MachO::DylibIdMissingError < ::MachO::RecoverableModificationError
+  def initialize; end
+end
+
+class MachO::DylibUnknownError < ::MachO::RecoverableModificationError
+  def initialize(dylib); end
+end
+
+class MachO::FatArchOffsetOverflowError < ::MachO::MachOError
+  def initialize(offset); end
+end
+
+class MachO::FatBinaryError < ::MachO::MachOError
+  def initialize; end
+end
+
+class MachO::FatFile
+  extend ::Forwardable
+
+  def initialize(filename, **opts); end
+
+  def add_rpath(path, options = T.unsafe(nil)); end
+  def bundle?(*args, &block); end
+  def change_dylib(old_name, new_name, options = T.unsafe(nil)); end
+  def change_dylib_id(new_id, options = T.unsafe(nil)); end
+  def change_install_name(old_name, new_name, options = T.unsafe(nil)); end
+  def change_rpath(old_path, new_path, options = T.unsafe(nil)); end
+  def core?(*args, &block); end
+  def delete_rpath(path, options = T.unsafe(nil)); end
+  def dsym?(*args, &block); end
+  def dylib?(*args, &block); end
+  def dylib_id(*args, &block); end
+  def dylib_id=(new_id, options = T.unsafe(nil)); end
+  def dylib_load_commands; end
+  def dylinker?(*args, &block); end
+  def executable?(*args, &block); end
+  def extract(cputype); end
+  def fat_archs; end
+  def filename; end
+  def filename=(_arg0); end
+  def filetype(*args, &block); end
+  def fvmlib?(*args, &block); end
+  def header; end
+  def initialize_from_bin(bin, opts); end
+  def kext?(*args, &block); end
+  def linked_dylibs; end
+  def machos; end
+  def magic(*args, &block); end
+  def magic_string; end
+  def object?(*args, &block); end
+  def options; end
+  def populate_fields; end
+  def preload?(*args, &block); end
+  def rpaths; end
+  def serialize; end
+  def to_h; end
+  def write(filename); end
+  def write!; end
+
+  private
+
+  def canonical_macho; end
+  def each_macho(options = T.unsafe(nil)); end
+  def populate_fat_archs; end
+  def populate_fat_header; end
+  def populate_machos; end
+  def repopulate_raw_machos; end
+
+  class << self
+    def new_from_bin(bin, **opts); end
+    def new_from_machos(*machos, fat64: T.unsafe(nil)); end
+  end
+end
+
+class MachO::FiletypeError < ::MachO::MachOError
+  def initialize(num); end
+end
+
+class MachO::HeaderPadError < ::MachO::ModificationError
+  def initialize(filename); end
+end
+
+module MachO::Headers; end
+MachO::Headers::CPU_ARCH_ABI32 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_ARCH_ABI64 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPES = T.let(T.unsafe(nil), Hash)
+MachO::Headers::CPU_SUBTYPE_486 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_486SX = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_586 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_ARM64E = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_ARM64_32_V8 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_ARM64_ALL = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_ARM64_V8 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_ARM_ALL = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_ARM_V4T = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_ARM_V5TEJ = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_ARM_V6 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_ARM_V6M = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_ARM_V7 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_ARM_V7EM = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_ARM_V7F = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_ARM_V7K = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_ARM_V7M = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_ARM_V7S = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_ARM_V8 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_ARM_XSCALE = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_I386 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_LIB64 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_MASK = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_MC68030 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_MC68030_ONLY = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_MC68040 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_MC680X0_ALL = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_MC88000_ALL = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_MC88100 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_MC88110 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_MMAX_JPC = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_PENT = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_PENTII_M3 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_PENTII_M5 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_PENTIUM_4 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_PENTPRO = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_POWERPC64_ALL = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_POWERPC_601 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_POWERPC_602 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_POWERPC_603 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_POWERPC_603E = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_POWERPC_603EV = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_POWERPC_604 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_POWERPC_604E = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_POWERPC_620 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_POWERPC_7400 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_POWERPC_7450 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_POWERPC_750 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_POWERPC_970 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_POWERPC_ALL = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_X86_64_ALL = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_SUBTYPE_X86_64_H = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_TYPES = T.let(T.unsafe(nil), Hash)
+MachO::Headers::CPU_TYPE_ANY = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_TYPE_ARM = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_TYPE_ARM64 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_TYPE_ARM64_32 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_TYPE_I386 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_TYPE_MC680X0 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_TYPE_MC88000 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_TYPE_POWERPC = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_TYPE_POWERPC64 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::CPU_TYPE_X86_64 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::FAT_CIGAM = T.let(T.unsafe(nil), Integer)
+MachO::Headers::FAT_CIGAM_64 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::FAT_MAGIC = T.let(T.unsafe(nil), Integer)
+MachO::Headers::FAT_MAGIC_64 = T.let(T.unsafe(nil), Integer)
+
+class MachO::Headers::FatArch < ::MachO::MachOStructure
+  def initialize(cputype, cpusubtype, offset, size, align); end
+
+  def align; end
+  def cpusubtype; end
+  def cputype; end
+  def offset; end
+  def serialize; end
+  def size; end
+  def to_h; end
+end
+
+class MachO::Headers::FatArch64 < ::MachO::Headers::FatArch
+  def initialize(cputype, cpusubtype, offset, size, align, reserved = T.unsafe(nil)); end
+
+  def reserved; end
+  def serialize; end
+  def to_h; end
+end
+
+MachO::Headers::FatArch64::FORMAT = T.let(T.unsafe(nil), String)
+MachO::Headers::FatArch64::SIZEOF = T.let(T.unsafe(nil), Integer)
+MachO::Headers::FatArch::FORMAT = T.let(T.unsafe(nil), String)
+MachO::Headers::FatArch::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::Headers::FatHeader < ::MachO::MachOStructure
+  def initialize(magic, nfat_arch); end
+
+  def magic; end
+  def nfat_arch; end
+  def serialize; end
+  def to_h; end
+end
+
+MachO::Headers::FatHeader::FORMAT = T.let(T.unsafe(nil), String)
+MachO::Headers::FatHeader::SIZEOF = T.let(T.unsafe(nil), Integer)
+MachO::Headers::MH_BUNDLE = T.let(T.unsafe(nil), Integer)
+MachO::Headers::MH_CIGAM = T.let(T.unsafe(nil), Integer)
+MachO::Headers::MH_CIGAM_64 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::MH_CORE = T.let(T.unsafe(nil), Integer)
+MachO::Headers::MH_DSYM = T.let(T.unsafe(nil), Integer)
+MachO::Headers::MH_DYLIB = T.let(T.unsafe(nil), Integer)
+MachO::Headers::MH_DYLIB_STUB = T.let(T.unsafe(nil), Integer)
+MachO::Headers::MH_DYLINKER = T.let(T.unsafe(nil), Integer)
+MachO::Headers::MH_EXECUTE = T.let(T.unsafe(nil), Integer)
+MachO::Headers::MH_FILETYPES = T.let(T.unsafe(nil), Hash)
+MachO::Headers::MH_FLAGS = T.let(T.unsafe(nil), Hash)
+MachO::Headers::MH_FVMLIB = T.let(T.unsafe(nil), Integer)
+MachO::Headers::MH_KEXT_BUNDLE = T.let(T.unsafe(nil), Integer)
+MachO::Headers::MH_MAGIC = T.let(T.unsafe(nil), Integer)
+MachO::Headers::MH_MAGICS = T.let(T.unsafe(nil), Hash)
+MachO::Headers::MH_MAGIC_64 = T.let(T.unsafe(nil), Integer)
+MachO::Headers::MH_OBJECT = T.let(T.unsafe(nil), Integer)
+MachO::Headers::MH_PRELOAD = T.let(T.unsafe(nil), Integer)
+
+class MachO::Headers::MachHeader < ::MachO::MachOStructure
+  def initialize(magic, cputype, cpusubtype, filetype, ncmds, sizeofcmds, flags); end
+
+  def alignment; end
+  def bundle?; end
+  def core?; end
+  def cpusubtype; end
+  def cputype; end
+  def dsym?; end
+  def dylib?; end
+  def dylinker?; end
+  def executable?; end
+  def filetype; end
+  def flag?(flag); end
+  def flags; end
+  def fvmlib?; end
+  def kext?; end
+  def magic; end
+  def magic32?; end
+  def magic64?; end
+  def ncmds; end
+  def object?; end
+  def preload?; end
+  def sizeofcmds; end
+  def to_h; end
+end
+
+class MachO::Headers::MachHeader64 < ::MachO::Headers::MachHeader
+  def initialize(magic, cputype, cpusubtype, filetype, ncmds, sizeofcmds, flags, reserved); end
+
+  def reserved; end
+  def to_h; end
+end
+
+MachO::Headers::MachHeader64::FORMAT = T.let(T.unsafe(nil), String)
+MachO::Headers::MachHeader64::SIZEOF = T.let(T.unsafe(nil), Integer)
+MachO::Headers::MachHeader::FORMAT = T.let(T.unsafe(nil), String)
+MachO::Headers::MachHeader::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::JavaClassFileError < ::MachO::NotAMachOError
+  def initialize; end
+end
+
+class MachO::LCStrMalformedError < ::MachO::MachOError
+  def initialize(lc); end
+end
+
+class MachO::LoadCommandCreationArityError < ::MachO::MachOError
+  def initialize(cmd_sym, expected_arity, actual_arity); end
+end
+
+class MachO::LoadCommandError < ::MachO::MachOError
+  def initialize(num); end
+end
+
+class MachO::LoadCommandNotCreatableError < ::MachO::MachOError
+  def initialize(cmd_sym); end
+end
+
+class MachO::LoadCommandNotSerializableError < ::MachO::MachOError
+  def initialize(cmd_sym); end
+end
+
+module MachO::LoadCommands; end
+
+class MachO::LoadCommands::BuildVersionCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, platform, minos, sdk, ntools); end
+
+  def minos; end
+  def minos_string; end
+  def platform; end
+  def sdk; end
+  def sdk_string; end
+  def to_h; end
+  def tool_entries; end
+end
+
+MachO::LoadCommands::BuildVersionCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::BuildVersionCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::BuildVersionCommand::ToolEntries
+  def initialize(view, ntools); end
+
+  def tools; end
+end
+
+class MachO::LoadCommands::BuildVersionCommand::ToolEntries::Tool
+  def initialize(tool, version); end
+
+  def to_h; end
+  def tool; end
+  def version; end
+end
+
+MachO::LoadCommands::CREATABLE_LOAD_COMMANDS = T.let(T.unsafe(nil), Array)
+MachO::LoadCommands::DYLIB_LOAD_COMMANDS = T.let(T.unsafe(nil), Array)
+
+class MachO::LoadCommands::DyldInfoCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, rebase_off, rebase_size, bind_off, bind_size, weak_bind_off, weak_bind_size, lazy_bind_off, lazy_bind_size, export_off, export_size); end
+
+  def bind_off; end
+  def bind_size; end
+  def export_off; end
+  def export_size; end
+  def lazy_bind_off; end
+  def lazy_bind_size; end
+  def rebase_off; end
+  def rebase_size; end
+  def to_h; end
+  def weak_bind_off; end
+  def weak_bind_size; end
+end
+
+MachO::LoadCommands::DyldInfoCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::DyldInfoCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::DylibCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, name, timestamp, current_version, compatibility_version); end
+
+  def compatibility_version; end
+  def current_version; end
+  def name; end
+  def serialize(context); end
+  def timestamp; end
+  def to_h; end
+end
+
+MachO::LoadCommands::DylibCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::DylibCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::DylinkerCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, name); end
+
+  def name; end
+  def serialize(context); end
+  def to_h; end
+end
+
+MachO::LoadCommands::DylinkerCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::DylinkerCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::DysymtabCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, ilocalsym, nlocalsym, iextdefsym, nextdefsym, iundefsym, nundefsym, tocoff, ntoc, modtaboff, nmodtab, extrefsymoff, nextrefsyms, indirectsymoff, nindirectsyms, extreloff, nextrel, locreloff, nlocrel); end
+
+  def extrefsymoff; end
+  def extreloff; end
+  def iextdefsym; end
+  def ilocalsym; end
+  def indirectsymoff; end
+  def iundefsym; end
+  def locreloff; end
+  def modtaboff; end
+  def nextdefsym; end
+  def nextrefsyms; end
+  def nextrel; end
+  def nindirectsyms; end
+  def nlocalsym; end
+  def nlocrel; end
+  def nmodtab; end
+  def ntoc; end
+  def nundefsym; end
+  def to_h; end
+  def tocoff; end
+end
+
+MachO::LoadCommands::DysymtabCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::DysymtabCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::EncryptionInfoCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, cryptoff, cryptsize, cryptid); end
+
+  def cryptid; end
+  def cryptoff; end
+  def cryptsize; end
+  def to_h; end
+end
+
+class MachO::LoadCommands::EncryptionInfoCommand64 < ::MachO::LoadCommands::EncryptionInfoCommand
+  def initialize(view, cmd, cmdsize, cryptoff, cryptsize, cryptid, pad); end
+
+  def pad; end
+  def to_h; end
+end
+
+MachO::LoadCommands::EncryptionInfoCommand64::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::EncryptionInfoCommand64::SIZEOF = T.let(T.unsafe(nil), Integer)
+MachO::LoadCommands::EncryptionInfoCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::EncryptionInfoCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::EntryPointCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, entryoff, stacksize); end
+
+  def entryoff; end
+  def stacksize; end
+  def to_h; end
+end
+
+MachO::LoadCommands::EntryPointCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::EntryPointCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::FvmfileCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, name, header_addr); end
+
+  def header_addr; end
+  def name; end
+  def to_h; end
+end
+
+MachO::LoadCommands::FvmfileCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::FvmfileCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::FvmlibCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, name, minor_version, header_addr); end
+
+  def header_addr; end
+  def minor_version; end
+  def name; end
+  def to_h; end
+end
+
+MachO::LoadCommands::FvmlibCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::FvmlibCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+class MachO::LoadCommands::IdentCommand < ::MachO::LoadCommands::LoadCommand; end
+MachO::LoadCommands::IdentCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::IdentCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+MachO::LoadCommands::LC_REQ_DYLD = T.let(T.unsafe(nil), Integer)
+MachO::LoadCommands::LC_STRUCTURES = T.let(T.unsafe(nil), Hash)
+MachO::LoadCommands::LOAD_COMMANDS = T.let(T.unsafe(nil), Hash)
+MachO::LoadCommands::LOAD_COMMAND_CONSTANTS = T.let(T.unsafe(nil), Hash)
+
+class MachO::LoadCommands::LinkeditDataCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, dataoff, datasize); end
+
+  def dataoff; end
+  def datasize; end
+  def to_h; end
+end
+
+MachO::LoadCommands::LinkeditDataCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::LinkeditDataCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::LinkerOptionCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, count); end
+
+  def count; end
+  def to_h; end
+end
+
+MachO::LoadCommands::LinkerOptionCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::LinkerOptionCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::LoadCommand < ::MachO::MachOStructure
+  def initialize(view, cmd, cmdsize); end
+
+  def cmd; end
+  def cmdsize; end
+  def offset; end
+  def serializable?; end
+  def serialize(context); end
+  def to_h; end
+  def to_s; end
+  def to_sym; end
+  def type; end
+  def view; end
+
+  class << self
+    def create(cmd_sym, *args); end
+    def new_from_bin(view); end
+  end
+end
+
+MachO::LoadCommands::LoadCommand::FORMAT = T.let(T.unsafe(nil), String)
+
+class MachO::LoadCommands::LoadCommand::LCStr
+  def initialize(lc, lc_str); end
+
+  def to_h; end
+  def to_i; end
+  def to_s; end
+end
+
+MachO::LoadCommands::LoadCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::LoadCommand::SerializationContext
+  def initialize(endianness, alignment); end
+
+  def alignment; end
+  def endianness; end
+
+  class << self
+    def context_for(macho); end
+  end
+end
+
+class MachO::LoadCommands::NoteCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, data_owner, offset, size); end
+
+  def data_owner; end
+  def offset; end
+  def size; end
+  def to_h; end
+end
+
+MachO::LoadCommands::NoteCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::NoteCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::PrebindCksumCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, cksum); end
+
+  def cksum; end
+  def to_h; end
+end
+
+MachO::LoadCommands::PrebindCksumCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::PrebindCksumCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::PreboundDylibCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, name, nmodules, linked_modules); end
+
+  def linked_modules; end
+  def name; end
+  def nmodules; end
+  def to_h; end
+end
+
+MachO::LoadCommands::PreboundDylibCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::PreboundDylibCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::RoutinesCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, init_address, init_module, reserved1, reserved2, reserved3, reserved4, reserved5, reserved6); end
+
+  def init_address; end
+  def init_module; end
+  def reserved1; end
+  def reserved2; end
+  def reserved3; end
+  def reserved4; end
+  def reserved5; end
+  def reserved6; end
+  def to_h; end
+end
+
+class MachO::LoadCommands::RoutinesCommand64 < ::MachO::LoadCommands::RoutinesCommand; end
+MachO::LoadCommands::RoutinesCommand64::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::RoutinesCommand64::SIZEOF = T.let(T.unsafe(nil), Integer)
+MachO::LoadCommands::RoutinesCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::RoutinesCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::RpathCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, path); end
+
+  def path; end
+  def serialize(context); end
+  def to_h; end
+end
+
+MachO::LoadCommands::RpathCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::RpathCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+MachO::LoadCommands::SEGMENT_FLAGS = T.let(T.unsafe(nil), Hash)
+MachO::LoadCommands::SEGMENT_NAMES = T.let(T.unsafe(nil), Hash)
+
+class MachO::LoadCommands::SegmentCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, segname, vmaddr, vmsize, fileoff, filesize, maxprot, initprot, nsects, flags); end
+
+  def fileoff; end
+  def filesize; end
+  def flag?(flag); end
+  def flags; end
+  def guess_align; end
+  def initprot; end
+  def maxprot; end
+  def nsects; end
+  def sections; end
+  def segname; end
+  def to_h; end
+  def vmaddr; end
+  def vmsize; end
+end
+
+class MachO::LoadCommands::SegmentCommand64 < ::MachO::LoadCommands::SegmentCommand; end
+MachO::LoadCommands::SegmentCommand64::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::SegmentCommand64::SIZEOF = T.let(T.unsafe(nil), Integer)
+MachO::LoadCommands::SegmentCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::SegmentCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::SourceVersionCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, version); end
+
+  def to_h; end
+  def version; end
+  def version_string; end
+end
+
+MachO::LoadCommands::SourceVersionCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::SourceVersionCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::SubClientCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, sub_client); end
+
+  def sub_client; end
+  def to_h; end
+end
+
+MachO::LoadCommands::SubClientCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::SubClientCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::SubFrameworkCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, umbrella); end
+
+  def to_h; end
+  def umbrella; end
+end
+
+MachO::LoadCommands::SubFrameworkCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::SubFrameworkCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::SubLibraryCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, sub_library); end
+
+  def sub_library; end
+  def to_h; end
+end
+
+MachO::LoadCommands::SubLibraryCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::SubLibraryCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::SubUmbrellaCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, sub_umbrella); end
+
+  def sub_umbrella; end
+  def to_h; end
+end
+
+MachO::LoadCommands::SubUmbrellaCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::SubUmbrellaCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::SymsegCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, offset, size); end
+
+  def offset; end
+  def size; end
+  def to_h; end
+end
+
+MachO::LoadCommands::SymsegCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::SymsegCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::SymtabCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, symoff, nsyms, stroff, strsize); end
+
+  def nsyms; end
+  def stroff; end
+  def strsize; end
+  def symoff; end
+  def to_h; end
+end
+
+MachO::LoadCommands::SymtabCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::SymtabCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+class MachO::LoadCommands::ThreadCommand < ::MachO::LoadCommands::LoadCommand; end
+MachO::LoadCommands::ThreadCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::ThreadCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::TwolevelHintsCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, htoffset, nhints); end
+
+  def htoffset; end
+  def nhints; end
+  def table; end
+  def to_h; end
+end
+
+MachO::LoadCommands::TwolevelHintsCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::TwolevelHintsCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::TwolevelHintsCommand::TwolevelHintsTable
+  def initialize(view, htoffset, nhints); end
+
+  def hints; end
+end
+
+class MachO::LoadCommands::TwolevelHintsCommand::TwolevelHintsTable::TwolevelHint
+  def initialize(blob); end
+
+  def isub_image; end
+  def itoc; end
+  def to_h; end
+end
+
+class MachO::LoadCommands::UUIDCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, uuid); end
+
+  def to_h; end
+  def uuid; end
+  def uuid_string; end
+end
+
+MachO::LoadCommands::UUIDCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::UUIDCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::LoadCommands::VersionMinCommand < ::MachO::LoadCommands::LoadCommand
+  def initialize(view, cmd, cmdsize, version, sdk); end
+
+  def sdk; end
+  def sdk_string; end
+  def to_h; end
+  def version; end
+  def version_string; end
+end
+
+MachO::LoadCommands::VersionMinCommand::FORMAT = T.let(T.unsafe(nil), String)
+MachO::LoadCommands::VersionMinCommand::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::MachOBinaryError < ::MachO::MachOError
+  def initialize; end
+end
+
+class MachO::MachOError < ::RuntimeError; end
+
+class MachO::MachOFile
+  extend ::Forwardable
+
+  def initialize(filename, **opts); end
+
+  def [](name); end
+  def add_command(lc, options = T.unsafe(nil)); end
+  def add_rpath(path, _options = T.unsafe(nil)); end
+  def alignment(*args, &block); end
+  def bundle?(*args, &block); end
+  def change_dylib(old_name, new_name, _options = T.unsafe(nil)); end
+  def change_dylib_id(new_id, _options = T.unsafe(nil)); end
+  def change_install_name(old_name, new_name, _options = T.unsafe(nil)); end
+  def change_rpath(old_path, new_path, _options = T.unsafe(nil)); end
+  def command(name); end
+  def core?(*args, &block); end
+  def cpusubtype; end
+  def cputype; end
+  def delete_command(lc, options = T.unsafe(nil)); end
+  def delete_rpath(path, _options = T.unsafe(nil)); end
+  def dsym?(*args, &block); end
+  def dylib?(*args, &block); end
+  def dylib_id; end
+  def dylib_id=(new_id, _options = T.unsafe(nil)); end
+  def dylib_load_commands; end
+  def dylinker?(*args, &block); end
+  def endianness; end
+  def executable?(*args, &block); end
+  def filename; end
+  def filename=(_arg0); end
+  def filetype; end
+  def flags(*args, &block); end
+  def fvmlib?(*args, &block); end
+  def header; end
+  def initialize_from_bin(bin, opts); end
+  def insert_command(offset, lc, options = T.unsafe(nil)); end
+  def kext?(*args, &block); end
+  def linked_dylibs; end
+  def load_commands; end
+  def magic(*args, &block); end
+  def magic32?(*args, &block); end
+  def magic64?(*args, &block); end
+  def magic_string; end
+  def ncmds(*args, &block); end
+  def object?(*args, &block); end
+  def options; end
+  def populate_fields; end
+  def preload?(*args, &block); end
+  def replace_command(old_lc, new_lc); end
+  def rpaths; end
+  def segment_alignment; end
+  def segments; end
+  def serialize; end
+  def sizeofcmds(*args, &block); end
+  def to_h; end
+  def write(filename); end
+  def write!; end
+
+  private
+
+  def check_cpusubtype(cputype, cpusubtype); end
+  def check_cputype(cputype); end
+  def check_filetype(filetype); end
+  def low_fileoff; end
+  def populate_and_check_magic; end
+  def populate_load_commands; end
+  def populate_mach_header; end
+  def update_ncmds(ncmds); end
+  def update_sizeofcmds(size); end
+
+  class << self
+    def new_from_bin(bin, **opts); end
+  end
+end
+
+class MachO::MachOStructure
+  def to_h; end
+
+  class << self
+    def bytesize; end
+    def new_from_bin(endianness, bin); end
+  end
+end
+
+MachO::MachOStructure::FORMAT = T.let(T.unsafe(nil), String)
+MachO::MachOStructure::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+class MachO::MachOView
+  def initialize(raw_data, endianness, offset); end
+
+  def endianness; end
+  def offset; end
+  def raw_data; end
+  def to_h; end
+end
+
+class MachO::MagicError < ::MachO::NotAMachOError
+  def initialize(magic); end
+end
+
+class MachO::ModificationError < ::MachO::MachOError; end
+class MachO::NotAMachOError < ::MachO::MachOError; end
+
+class MachO::OffsetInsertionError < ::MachO::ModificationError
+  def initialize(offset); end
+end
+
+class MachO::RecoverableModificationError < ::MachO::ModificationError
+  def macho_slice; end
+  def macho_slice=(_arg0); end
+  def to_s; end
+end
+
+class MachO::RpathExistsError < ::MachO::RecoverableModificationError
+  def initialize(path); end
+end
+
+class MachO::RpathUnknownError < ::MachO::RecoverableModificationError
+  def initialize(path); end
+end
+
+module MachO::Sections; end
+MachO::Sections::MAX_SECT_ALIGN = T.let(T.unsafe(nil), Integer)
+MachO::Sections::SECTION_ATTRIBUTES = T.let(T.unsafe(nil), Integer)
+MachO::Sections::SECTION_ATTRIBUTES_SYS = T.let(T.unsafe(nil), Integer)
+MachO::Sections::SECTION_ATTRIBUTES_USR = T.let(T.unsafe(nil), Integer)
+MachO::Sections::SECTION_FLAGS = T.let(T.unsafe(nil), Hash)
+MachO::Sections::SECTION_NAMES = T.let(T.unsafe(nil), Hash)
+MachO::Sections::SECTION_TYPE = T.let(T.unsafe(nil), Integer)
+
+class MachO::Sections::Section < ::MachO::MachOStructure
+  def initialize(sectname, segname, addr, size, offset, align, reloff, nreloc, flags, reserved1, reserved2); end
+
+  def addr; end
+  def align; end
+  def empty?; end
+  def flag?(flag); end
+  def flags; end
+  def nreloc; end
+  def offset; end
+  def reloff; end
+  def reserved1; end
+  def reserved2; end
+  def section_name; end
+  def sectname; end
+  def segment_name; end
+  def segname; end
+  def size; end
+  def to_h; end
+end
+
+class MachO::Sections::Section64 < ::MachO::Sections::Section
+  def initialize(sectname, segname, addr, size, offset, align, reloff, nreloc, flags, reserved1, reserved2, reserved3); end
+
+  def reserved3; end
+  def to_h; end
+end
+
+MachO::Sections::Section64::FORMAT = T.let(T.unsafe(nil), String)
+MachO::Sections::Section64::SIZEOF = T.let(T.unsafe(nil), Integer)
+MachO::Sections::Section::FORMAT = T.let(T.unsafe(nil), String)
+MachO::Sections::Section::SIZEOF = T.let(T.unsafe(nil), Integer)
+
+module MachO::Tools
+  class << self
+    def add_rpath(filename, new_path, options = T.unsafe(nil)); end
+    def change_dylib_id(filename, new_id, options = T.unsafe(nil)); end
+    def change_install_name(filename, old_name, new_name, options = T.unsafe(nil)); end
+    def change_rpath(filename, old_path, new_path, options = T.unsafe(nil)); end
+    def delete_rpath(filename, old_path, options = T.unsafe(nil)); end
+    def dylibs(filename); end
+    def merge_machos(filename, *files, fat64: T.unsafe(nil)); end
+  end
+end
+
+class MachO::TruncatedFileError < ::MachO::NotAMachOError
+  def initialize; end
+end
+
+class MachO::UnimplementedError < ::MachO::MachOError
+  def initialize(thing); end
+end
+
+module MachO::Utils
+  class << self
+    def big_magic?(num); end
+    def fat_magic32?(num); end
+    def fat_magic64?(num); end
+    def fat_magic?(num); end
+    def little_magic?(num); end
+    def magic32?(num); end
+    def magic64?(num); end
+    def magic?(num); end
+    def nullpad(size); end
+    def pack_strings(fixed_offset, alignment, strings = T.unsafe(nil)); end
+    def padding_for(size, alignment); end
+    def round(value, round); end
+    def specialize_format(format, endianness); end
+  end
+end
+
+MachO::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi b/Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi
index b478cbbd92..8caf7f8ef7 100644
--- a/Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.11.0.rbi
@@ -1,6 +1,6 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `ruby-progressbar` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
@@ -11,7 +11,7 @@ class ProgressBar
 end
 
 class ProgressBar::Base
-  extend(::Forwardable)
+  extend ::Forwardable
 
   def initialize(options = T.unsafe(nil)); end
 
@@ -71,8 +71,7 @@ class ProgressBar::Base
   def update_progress(*args); end
 end
 
-module ProgressBar::Calculators
-end
+module ProgressBar::Calculators; end
 
 class ProgressBar::Calculators::Length
   def initialize(options = T.unsafe(nil)); end
@@ -106,8 +105,7 @@ class ProgressBar::Calculators::RunningAverage
   end
 end
 
-module ProgressBar::Components
-end
+module ProgressBar::Components; end
 
 class ProgressBar::Components::Bar
   def initialize(options = T.unsafe(nil)); end
@@ -140,9 +138,7 @@ class ProgressBar::Components::Bar
 end
 
 ProgressBar::Components::Bar::DEFAULT_PROGRESS_MARK = T.let(T.unsafe(nil), String)
-
 ProgressBar::Components::Bar::DEFAULT_REMAINDER_MARK = T.let(T.unsafe(nil), String)
-
 ProgressBar::Components::Bar::DEFAULT_UPA_STEPS = T.let(T.unsafe(nil), Array)
 
 class ProgressBar::Components::Percentage
@@ -209,21 +205,13 @@ class ProgressBar::Components::Time
 end
 
 ProgressBar::Components::Time::ELAPSED_LABEL = T.let(T.unsafe(nil), String)
-
 ProgressBar::Components::Time::ESTIMATED_LABEL = T.let(T.unsafe(nil), String)
-
 ProgressBar::Components::Time::NO_TIME_ELAPSED_TEXT = T.let(T.unsafe(nil), String)
-
 ProgressBar::Components::Time::OOB_FRIENDLY_TIME_TEXT = T.let(T.unsafe(nil), String)
-
 ProgressBar::Components::Time::OOB_LIMIT_IN_HOURS = T.let(T.unsafe(nil), Integer)
-
 ProgressBar::Components::Time::OOB_TEXT_TO_FORMAT = T.let(T.unsafe(nil), Hash)
-
 ProgressBar::Components::Time::OOB_TIME_FORMATS = T.let(T.unsafe(nil), Array)
-
 ProgressBar::Components::Time::OOB_UNKNOWN_TIME_TEXT = T.let(T.unsafe(nil), String)
-
 ProgressBar::Components::Time::TIME_FORMAT = T.let(T.unsafe(nil), String)
 
 class ProgressBar::Components::Title
@@ -234,9 +222,7 @@ class ProgressBar::Components::Title
 end
 
 ProgressBar::Components::Title::DEFAULT_TITLE = T.let(T.unsafe(nil), String)
-
-module ProgressBar::Format
-end
+module ProgressBar::Format; end
 
 class ProgressBar::Format::Formatter
   class << self
@@ -258,7 +244,6 @@ class ProgressBar::Format::Molecule
 end
 
 ProgressBar::Format::Molecule::BAR_MOLECULES = T.let(T.unsafe(nil), Array)
-
 ProgressBar::Format::Molecule::MOLECULES = T.let(T.unsafe(nil), Hash)
 
 class ProgressBar::Format::String < ::String
@@ -270,11 +255,8 @@ class ProgressBar::Format::String < ::String
 end
 
 ProgressBar::Format::String::ANSI_SGR_PATTERN = T.let(T.unsafe(nil), Regexp)
-
 ProgressBar::Format::String::MOLECULE_PATTERN = T.let(T.unsafe(nil), Regexp)
-
-class ProgressBar::InvalidProgressError < ::RuntimeError
-end
+class ProgressBar::InvalidProgressError < ::RuntimeError; end
 
 class ProgressBar::Output
   def initialize(options = T.unsafe(nil)); end
@@ -306,9 +288,7 @@ class ProgressBar::Output
 end
 
 ProgressBar::Output::DEFAULT_OUTPUT_STREAM = T.let(T.unsafe(nil), IO)
-
-module ProgressBar::Outputs
-end
+module ProgressBar::Outputs; end
 
 class ProgressBar::Outputs::NonTty < ::ProgressBar::Output
   def bar_update_string; end
@@ -365,16 +345,10 @@ class ProgressBar::Progress
 end
 
 ProgressBar::Progress::DEFAULT_BEGINNING_POSITION = T.let(T.unsafe(nil), Integer)
-
 ProgressBar::Progress::DEFAULT_SMOOTHING = T.let(T.unsafe(nil), Float)
-
 ProgressBar::Progress::DEFAULT_TOTAL = T.let(T.unsafe(nil), Integer)
-
-module ProgressBar::Refinements
-end
-
-module ProgressBar::Refinements::Enumerator
-end
+module ProgressBar::Refinements; end
+module ProgressBar::Refinements::Enumerator; end
 
 class ProgressBar::Throttle
   def initialize(options = T.unsafe(nil)); end
diff --git a/Library/Homebrew/sorbet/rbi/gems/simplecov-cobertura@1.4.2.rbi b/Library/Homebrew/sorbet/rbi/gems/simplecov-cobertura@1.4.2.rbi
index f7adcbc881..04dad64faa 100644
--- a/Library/Homebrew/sorbet/rbi/gems/simplecov-cobertura@1.4.2.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/simplecov-cobertura@1.4.2.rbi
@@ -1,8 +1,82 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `simplecov-cobertura` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module SimpleCov
+  extend ::SimpleCov::Configuration
+
+  class << self
+    def at_exit_behavior; end
+    def clear_result; end
+    def collate(result_filenames, profile = T.unsafe(nil), ignore_timeout: T.unsafe(nil), &block); end
+    def exit_and_report_previous_error(exit_status); end
+    def exit_status_from_exception; end
+    def external_at_exit; end
+    def external_at_exit=(_arg0); end
+    def external_at_exit?; end
+    def filtered(files); end
+    def final_result_process?; end
+    def grouped(files); end
+    def load_adapter(name); end
+    def load_profile(name); end
+    def pid; end
+    def pid=(_arg0); end
+    def previous_error?(error_exit_status); end
+    def process_result(result); end
+    def process_results_and_report_error; end
+    def ready_to_process_results?; end
+    def result; end
+    def result?; end
+    def result_exit_status(result); end
+    def round_coverage(coverage); end
+    def run_exit_tasks!; end
+    def running; end
+    def running=(_arg0); end
+    def start(profile = T.unsafe(nil), &block); end
+    def wait_for_other_processes; end
+    def write_last_run(result); end
+
+    private
+
+    def adapt_coverage_result; end
+    def add_not_loaded_files(result); end
+    def initial_setup(profile, &block); end
+    def lookup_corresponding_ruby_coverage_name(criterion); end
+    def make_parallel_tests_available; end
+    def probably_running_parallel_tests?; end
+    def process_coverage_result; end
+    def remove_useless_results; end
+    def result_with_not_loaded_files; end
+    def start_coverage_measurement; end
+    def start_coverage_with_criteria; end
+  end
+end
+
+module SimpleCov::Formatter
+  class << self
+    def from_env(env); end
+  end
+end
+
+class SimpleCov::Formatter::CoberturaFormatter
+  def format(result); end
+
+  private
+
+  def coverage_output(result); end
+  def project_root; end
+  def resolve_filename(filename); end
+  def result_to_xml(result); end
+  def set_class_attributes(class_, file); end
+  def set_coverage_attributes(coverage, result); end
+  def set_line_attributes(line, file_line); end
+  def set_package_attributes(package, name, result); end
+  def set_xml_head(lines = T.unsafe(nil)); end
+end
+
+SimpleCov::Formatter::CoberturaFormatter::DTD_URL = T.let(T.unsafe(nil), String)
+SimpleCov::Formatter::CoberturaFormatter::RESULT_FILE_NAME = T.let(T.unsafe(nil), String)
+SimpleCov::Formatter::CoberturaFormatter::VERSION = T.let(T.unsafe(nil), String)
+SimpleCov::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.12.3.rbi b/Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.12.3.rbi
index 250d6d8839..edc4e1efe2 100644
--- a/Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.12.3.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.12.3.rbi
@@ -1,8 +1,89 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `simplecov-html` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module SimpleCov
+  extend ::SimpleCov::Configuration
+
+  class << self
+    def at_exit_behavior; end
+    def clear_result; end
+    def collate(result_filenames, profile = T.unsafe(nil), ignore_timeout: T.unsafe(nil), &block); end
+    def exit_and_report_previous_error(exit_status); end
+    def exit_status_from_exception; end
+    def external_at_exit; end
+    def external_at_exit=(_arg0); end
+    def external_at_exit?; end
+    def filtered(files); end
+    def final_result_process?; end
+    def grouped(files); end
+    def load_adapter(name); end
+    def load_profile(name); end
+    def pid; end
+    def pid=(_arg0); end
+    def previous_error?(error_exit_status); end
+    def process_result(result); end
+    def process_results_and_report_error; end
+    def ready_to_process_results?; end
+    def result; end
+    def result?; end
+    def result_exit_status(result); end
+    def round_coverage(coverage); end
+    def run_exit_tasks!; end
+    def running; end
+    def running=(_arg0); end
+    def start(profile = T.unsafe(nil), &block); end
+    def wait_for_other_processes; end
+    def write_last_run(result); end
+
+    private
+
+    def adapt_coverage_result; end
+    def add_not_loaded_files(result); end
+    def initial_setup(profile, &block); end
+    def lookup_corresponding_ruby_coverage_name(criterion); end
+    def make_parallel_tests_available; end
+    def probably_running_parallel_tests?; end
+    def process_coverage_result; end
+    def remove_useless_results; end
+    def result_with_not_loaded_files; end
+    def start_coverage_measurement; end
+    def start_coverage_with_criteria; end
+  end
+end
+
+module SimpleCov::Formatter
+  class << self
+    def from_env(env); end
+  end
+end
+
+class SimpleCov::Formatter::HTMLFormatter
+  def initialize; end
+
+  def branchable_result?; end
+  def format(result); end
+  def line_status?(source_file, line); end
+  def output_message(result); end
+
+  private
+
+  def asset_output_path; end
+  def assets_path(name); end
+  def coverage_css_class(covered_percent); end
+  def covered_percent(percent); end
+  def formatted_file_list(title, source_files); end
+  def formatted_source_file(source_file); end
+  def id(source_file); end
+  def link_to_source_file(source_file); end
+  def output_path; end
+  def shortened_filename(source_file); end
+  def strength_css_class(covered_strength); end
+  def template(name); end
+  def timeago(time); end
+end
+
+SimpleCov::Formatter::HTMLFormatter::VERSION = T.let(T.unsafe(nil), String)
+SimpleCov::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/simplecov@0.21.2.rbi b/Library/Homebrew/sorbet/rbi/gems/simplecov@0.21.2.rbi
index c23edb26bd..6ba4e0778c 100644
--- a/Library/Homebrew/sorbet/rbi/gems/simplecov@0.21.2.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/simplecov@0.21.2.rbi
@@ -1,8 +1,577 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `simplecov` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module SimpleCov
+  extend ::SimpleCov::Configuration
+
+  class << self
+    def at_exit_behavior; end
+    def clear_result; end
+    def collate(result_filenames, profile = T.unsafe(nil), ignore_timeout: T.unsafe(nil), &block); end
+    def exit_and_report_previous_error(exit_status); end
+    def exit_status_from_exception; end
+    def external_at_exit; end
+    def external_at_exit=(_arg0); end
+    def external_at_exit?; end
+    def filtered(files); end
+    def final_result_process?; end
+    def grouped(files); end
+    def load_adapter(name); end
+    def load_profile(name); end
+    def pid; end
+    def pid=(_arg0); end
+    def previous_error?(error_exit_status); end
+    def process_result(result); end
+    def process_results_and_report_error; end
+    def ready_to_process_results?; end
+    def result; end
+    def result?; end
+    def result_exit_status(result); end
+    def round_coverage(coverage); end
+    def run_exit_tasks!; end
+    def running; end
+    def running=(_arg0); end
+    def start(profile = T.unsafe(nil), &block); end
+    def wait_for_other_processes; end
+    def write_last_run(result); end
+
+    private
+
+    def adapt_coverage_result; end
+    def add_not_loaded_files(result); end
+    def initial_setup(profile, &block); end
+    def lookup_corresponding_ruby_coverage_name(criterion); end
+    def make_parallel_tests_available; end
+    def probably_running_parallel_tests?; end
+    def process_coverage_result; end
+    def remove_useless_results; end
+    def result_with_not_loaded_files; end
+    def start_coverage_measurement; end
+    def start_coverage_with_criteria; end
+  end
+end
+
+class SimpleCov::ArrayFilter < ::SimpleCov::Filter
+  def initialize(filter_argument); end
+
+  def matches?(source_files_list); end
+end
+
+class SimpleCov::BlockFilter < ::SimpleCov::Filter
+  def matches?(source_file); end
+end
+
+module SimpleCov::Combine
+  private
+
+  def combine(combiner_module, coverage_a, coverage_b); end
+  def empty_coverage?(coverage_a, coverage_b); end
+  def existing_coverage(coverage_a, coverage_b); end
+
+  class << self
+    def combine(combiner_module, coverage_a, coverage_b); end
+    def empty_coverage?(coverage_a, coverage_b); end
+    def existing_coverage(coverage_a, coverage_b); end
+  end
+end
+
+module SimpleCov::Combine::BranchesCombiner
+  private
+
+  def combine(coverage_a, coverage_b); end
+
+  class << self
+    def combine(coverage_a, coverage_b); end
+  end
+end
+
+module SimpleCov::Combine::FilesCombiner
+  private
+
+  def combine(coverage_a, coverage_b); end
+
+  class << self
+    def combine(coverage_a, coverage_b); end
+  end
+end
+
+module SimpleCov::Combine::LinesCombiner
+  private
+
+  def combine(coverage_a, coverage_b); end
+  def merge_line_coverage(first_val, second_val); end
+
+  class << self
+    def combine(coverage_a, coverage_b); end
+    def merge_line_coverage(first_val, second_val); end
+  end
+end
+
+module SimpleCov::Combine::ResultsCombiner
+  private
+
+  def combine(*results); end
+  def combine_file_coverage(coverage_a, coverage_b); end
+  def combine_result_sets(combined_results, result); end
+
+  class << self
+    def combine(*results); end
+    def combine_file_coverage(coverage_a, coverage_b); end
+    def combine_result_sets(combined_results, result); end
+  end
+end
+
+module SimpleCov::CommandGuesser
+  class << self
+    def guess; end
+    def original_run_command; end
+    def original_run_command=(_arg0); end
+
+    private
+
+    def from_command_line_options; end
+    def from_defined_constants; end
+    def from_env; end
+  end
+end
+
+module SimpleCov::Configuration
+  def adapters; end
+  def add_filter(filter_argument = T.unsafe(nil), &filter_proc); end
+  def add_group(group_name, filter_argument = T.unsafe(nil), &filter_proc); end
+  def at_exit(&block); end
+  def at_fork(&block); end
+  def branch_coverage?; end
+  def branch_coverage_supported?; end
+  def clear_coverage_criteria; end
+  def command_name(name = T.unsafe(nil)); end
+  def configure(&block); end
+  def coverage_criteria; end
+  def coverage_criterion(criterion = T.unsafe(nil)); end
+  def coverage_criterion_enabled?(criterion); end
+  def coverage_dir(dir = T.unsafe(nil)); end
+  def coverage_path; end
+  def coverage_start_arguments_supported?; end
+  def enable_coverage(criterion); end
+  def enable_for_subprocesses(value = T.unsafe(nil)); end
+  def enabled_for_subprocesses?; end
+  def filters; end
+  def filters=(_arg0); end
+  def formatter(formatter = T.unsafe(nil)); end
+  def formatter=(_arg0); end
+  def formatters; end
+  def formatters=(formatters); end
+  def groups; end
+  def groups=(_arg0); end
+  def maximum_coverage_drop(coverage_drop = T.unsafe(nil)); end
+  def merge_timeout(seconds = T.unsafe(nil)); end
+  def minimum_coverage(coverage = T.unsafe(nil)); end
+  def minimum_coverage_by_file(coverage = T.unsafe(nil)); end
+  def nocov_token(nocov_token = T.unsafe(nil)); end
+  def primary_coverage(criterion = T.unsafe(nil)); end
+  def print_error_status; end
+  def print_error_status=(_arg0); end
+  def profiles; end
+  def project_name(new_name = T.unsafe(nil)); end
+  def raise_on_invalid_coverage(coverage, coverage_setting); end
+  def refuse_coverage_drop(*criteria); end
+  def root(root = T.unsafe(nil)); end
+  def skip_token(nocov_token = T.unsafe(nil)); end
+  def track_files(glob); end
+  def tracked_files; end
+  def use_merging(use = T.unsafe(nil)); end
+
+  private
+
+  def minimum_possible_coverage_exceeded(coverage_option); end
+  def parse_filter(filter_argument = T.unsafe(nil), &filter_proc); end
+  def raise_if_criterion_disabled(criterion); end
+  def raise_if_criterion_unsupported(criterion); end
+end
+
+SimpleCov::Configuration::DEFAULT_COVERAGE_CRITERION = T.let(T.unsafe(nil), Symbol)
+SimpleCov::Configuration::SUPPORTED_COVERAGE_CRITERIA = T.let(T.unsafe(nil), Array)
+
+class SimpleCov::CoverageStatistics
+  def initialize(covered:, missed:, total_strength: T.unsafe(nil)); end
+
+  def covered; end
+  def missed; end
+  def percent; end
+  def strength; end
+  def total; end
+
+  private
+
+  def compute_percent(covered, missed, total); end
+  def compute_strength(total_strength, total); end
+
+  class << self
+    def from(coverage_statistics); end
+  end
+end
+
+module SimpleCov::ExitCodes; end
+SimpleCov::ExitCodes::EXCEPTION = T.let(T.unsafe(nil), Integer)
+
+module SimpleCov::ExitCodes::ExitCodeHandling
+  private
+
+  def call(result, coverage_limits:); end
+  def coverage_checks(result, coverage_limits); end
+
+  class << self
+    def call(result, coverage_limits:); end
+    def coverage_checks(result, coverage_limits); end
+  end
+end
+
+SimpleCov::ExitCodes::MAXIMUM_COVERAGE_DROP = T.let(T.unsafe(nil), Integer)
+SimpleCov::ExitCodes::MINIMUM_COVERAGE = T.let(T.unsafe(nil), Integer)
+
+class SimpleCov::ExitCodes::MaximumCoverageDropCheck
+  def initialize(result, maximum_coverage_drop); end
+
+  def exit_code; end
+  def failing?; end
+  def report; end
+
+  private
+
+  def compute_coverage_drop_data; end
+  def coverage_drop_violations; end
+  def drop_percent(criterion); end
+  def last_coverage(criterion); end
+  def last_run; end
+  def maximum_coverage_drop; end
+  def result; end
+end
+
+SimpleCov::ExitCodes::MaximumCoverageDropCheck::MAX_DROP_ACCURACY = T.let(T.unsafe(nil), Integer)
+
+class SimpleCov::ExitCodes::MinimumCoverageByFileCheck
+  def initialize(result, minimum_coverage_by_file); end
+
+  def exit_code; end
+  def failing?; end
+  def report; end
+
+  private
+
+  def compute_minimum_coverage_data; end
+  def minimum_coverage_by_file; end
+  def minimum_violations; end
+  def result; end
+end
+
+class SimpleCov::ExitCodes::MinimumOverallCoverageCheck
+  def initialize(result, minimum_coverage); end
+
+  def exit_code; end
+  def failing?; end
+  def report; end
+
+  private
+
+  def calculate_minimum_violations; end
+  def minimum_coverage; end
+  def minimum_violations; end
+  def result; end
+end
+
+SimpleCov::ExitCodes::SUCCESS = T.let(T.unsafe(nil), Integer)
+
+class SimpleCov::FileList
+  include ::Enumerable
+  extend ::Forwardable
+
+  def initialize(files); end
+
+  def branch_covered_percent; end
+  def count(*args, &block); end
+  def coverage_statistics; end
+  def coverage_statistics_by_file; end
+  def covered_branches; end
+  def covered_lines; end
+  def covered_percent; end
+  def covered_percentages; end
+  def covered_strength; end
+  def each(*args, &block); end
+  def empty?(*args, &block); end
+  def least_covered_file; end
+  def length(*args, &block); end
+  def lines_of_code; end
+  def map(*args, &block); end
+  def missed_branches; end
+  def missed_lines; end
+  def never_lines; end
+  def size(*args, &block); end
+  def skipped_lines; end
+  def to_a(*args, &block); end
+  def to_ary(*args, &block); end
+  def total_branches; end
+
+  private
+
+  def compute_coverage_statistics; end
+  def compute_coverage_statistics_by_file; end
+end
+
+class SimpleCov::Filter
+  def initialize(filter_argument); end
+
+  def filter_argument; end
+  def matches?(_source_file); end
+  def passes?(source_file); end
+
+  class << self
+    def build_filter(filter_argument); end
+    def class_for_argument(filter_argument); end
+  end
+end
+
+module SimpleCov::Formatter
+  class << self
+    def from_env(env); end
+  end
+end
+
+class SimpleCov::Formatter::MultiFormatter
+  class << self
+    def [](*args); end
+    def new(formatters = T.unsafe(nil)); end
+  end
+end
+
+module SimpleCov::Formatter::MultiFormatter::InstanceMethods
+  def format(result); end
+end
+
+class SimpleCov::Formatter::SimpleFormatter
+  def format(result); end
+end
+
+module SimpleCov::LastRun
+  class << self
+    def last_run_path; end
+    def read; end
+    def write(json); end
+  end
+end
+
+class SimpleCov::LinesClassifier
+  def classify(lines); end
+
+  class << self
+    def no_cov_line; end
+    def no_cov_line?(line); end
+    def whitespace_line?(line); end
+  end
+end
+
+SimpleCov::LinesClassifier::COMMENT_LINE = T.let(T.unsafe(nil), Regexp)
+SimpleCov::LinesClassifier::RELEVANT = T.let(T.unsafe(nil), Integer)
+SimpleCov::LinesClassifier::WHITESPACE_LINE = T.let(T.unsafe(nil), Regexp)
+SimpleCov::LinesClassifier::WHITESPACE_OR_COMMENT_LINE = T.let(T.unsafe(nil), Regexp)
+
+class SimpleCov::Profiles < ::Hash
+  def define(name, &blk); end
+  def load(name); end
+end
+
+class SimpleCov::RegexFilter < ::SimpleCov::Filter
+  def matches?(source_file); end
+end
+
+class SimpleCov::Result
+  extend ::Forwardable
+
+  def initialize(original_result, command_name: T.unsafe(nil), created_at: T.unsafe(nil)); end
+
+  def command_name; end
+  def command_name=(_arg0); end
+  def coverage_statistics(*args, &block); end
+  def coverage_statistics_by_file(*args, &block); end
+  def covered_branches(*args, &block); end
+  def covered_lines(*args, &block); end
+  def covered_percent(*args, &block); end
+  def covered_percentages(*args, &block); end
+  def covered_strength(*args, &block); end
+  def created_at; end
+  def created_at=(_arg0); end
+  def filenames; end
+  def files; end
+  def format!; end
+  def groups; end
+  def least_covered_file(*args, &block); end
+  def missed_branches(*args, &block); end
+  def missed_lines(*args, &block); end
+  def original_result; end
+  def source_files; end
+  def to_hash; end
+  def total_branches(*args, &block); end
+  def total_lines(*args, &block); end
+
+  private
+
+  def coverage; end
+  def filter!; end
+
+  class << self
+    def from_hash(hash); end
+  end
+end
+
+class SimpleCov::ResultAdapter
+  def initialize(result); end
+
+  def adapt; end
+  def result; end
+
+  class << self
+    def call(*args); end
+  end
+end
+
+module SimpleCov::ResultMerger
+  class << self
+    def adapt_pre_simplecov_0_18_result(result); end
+    def adapt_result(result); end
+    def create_result(command_names, coverage); end
+    def merge_and_store(*file_paths, ignore_timeout: T.unsafe(nil)); end
+    def merge_coverage(*results); end
+    def merge_results(*file_paths, ignore_timeout: T.unsafe(nil)); end
+    def merge_valid_results(results, ignore_timeout: T.unsafe(nil)); end
+    def merged_result; end
+    def parse_file(path); end
+    def parse_json(content); end
+    def pre_simplecov_0_18_result?(result); end
+    def read_file(path); end
+    def read_resultset; end
+    def resultset_path; end
+    def resultset_writelock; end
+    def store_result(result); end
+    def synchronize_resultset; end
+    def time_since_result_creation(data); end
+    def valid_results(file_path, ignore_timeout: T.unsafe(nil)); end
+    def within_merge_timeout?(data); end
+  end
+end
+
+module SimpleCov::SimulateCoverage
+  private
+
+  def call(absolute_path); end
+
+  class << self
+    def call(absolute_path); end
+  end
+end
+
+class SimpleCov::SourceFile
+  def initialize(filename, coverage_data); end
+
+  def branches; end
+  def branches_coverage_percent; end
+  def branches_for_line(line_number); end
+  def branches_report; end
+  def coverage_data; end
+  def coverage_statistics; end
+  def covered_branches; end
+  def covered_lines; end
+  def covered_percent; end
+  def covered_strength; end
+  def filename; end
+  def line(number); end
+  def line_with_missed_branch?(line_number); end
+  def lines; end
+  def lines_of_code; end
+  def missed_branches; end
+  def missed_lines; end
+  def never_lines; end
+  def no_branches?; end
+  def no_lines?; end
+  def project_filename; end
+  def relevant_lines; end
+  def skipped_lines; end
+  def source; end
+  def source_lines; end
+  def src; end
+  def total_branches; end
+
+  private
+
+  def branch_coverage_statistics; end
+  def build_branch(branch_data, hit_count, condition_start_line); end
+  def build_branches; end
+  def build_branches_from(condition, branches); end
+  def build_branches_report; end
+  def build_lines; end
+  def build_no_cov_chunks; end
+  def coverage_exceeding_source_warn; end
+  def ensure_remove_undefs(file_lines); end
+  def line_coverage_statistics; end
+  def lines_strength; end
+  def load_source; end
+  def no_cov_chunks; end
+  def process_skipped_branches(branches); end
+  def process_skipped_lines(lines); end
+  def read_lines(file, lines, current_line); end
+  def restore_ruby_data_structure(structure); end
+  def set_encoding_based_on_magic_comment(file, line); end
+  def shebang?(line); end
+end
+
+class SimpleCov::SourceFile::Branch
+  def initialize(start_line:, end_line:, coverage:, inline:, type:); end
+
+  def coverage; end
+  def covered?; end
+  def end_line; end
+  def inline?; end
+  def missed?; end
+  def overlaps_with?(line_range); end
+  def report; end
+  def report_line; end
+  def skipped!; end
+  def skipped?; end
+  def start_line; end
+  def type; end
+end
+
+class SimpleCov::SourceFile::Line
+  def initialize(src, line_number, coverage); end
+
+  def coverage; end
+  def covered?; end
+  def line; end
+  def line_number; end
+  def missed?; end
+  def never?; end
+  def number; end
+  def skipped; end
+  def skipped!; end
+  def skipped?; end
+  def source; end
+  def src; end
+  def status; end
+end
+
+SimpleCov::SourceFile::RUBY_FILE_ENCODING_MAGIC_COMMENT_REGEX = T.let(T.unsafe(nil), Regexp)
+SimpleCov::SourceFile::SHEBANG_REGEX = T.let(T.unsafe(nil), Regexp)
+
+class SimpleCov::StringFilter < ::SimpleCov::Filter
+  def matches?(source_file); end
+end
+
+module SimpleCov::UselessResultsRemover
+  class << self
+    def call(coverage_result); end
+    def root_regx; end
+  end
+end
+
+SimpleCov::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/simplecov_json_formatter@0.1.3.rbi b/Library/Homebrew/sorbet/rbi/gems/simplecov_json_formatter@0.1.3.rbi
index 831705facb..52df2afa03 100644
--- a/Library/Homebrew/sorbet/rbi/gems/simplecov_json_formatter@0.1.3.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/simplecov_json_formatter@0.1.3.rbi
@@ -4,5 +4,110 @@
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module SimpleCov
+  extend ::SimpleCov::Configuration
+
+  class << self
+    def at_exit_behavior; end
+    def clear_result; end
+    def collate(result_filenames, profile = T.unsafe(nil), ignore_timeout: T.unsafe(nil), &block); end
+    def exit_and_report_previous_error(exit_status); end
+    def exit_status_from_exception; end
+    def external_at_exit; end
+    def external_at_exit=(_arg0); end
+    def external_at_exit?; end
+    def filtered(files); end
+    def final_result_process?; end
+    def grouped(files); end
+    def load_adapter(name); end
+    def load_profile(name); end
+    def pid; end
+    def pid=(_arg0); end
+    def previous_error?(error_exit_status); end
+    def process_result(result); end
+    def process_results_and_report_error; end
+    def ready_to_process_results?; end
+    def result; end
+    def result?; end
+    def result_exit_status(result); end
+    def round_coverage(coverage); end
+    def run_exit_tasks!; end
+    def running; end
+    def running=(_arg0); end
+    def start(profile = T.unsafe(nil), &block); end
+    def wait_for_other_processes; end
+    def write_last_run(result); end
+
+    private
+
+    def adapt_coverage_result; end
+    def add_not_loaded_files(result); end
+    def initial_setup(profile, &block); end
+    def lookup_corresponding_ruby_coverage_name(criterion); end
+    def make_parallel_tests_available; end
+    def probably_running_parallel_tests?; end
+    def process_coverage_result; end
+    def remove_useless_results; end
+    def result_with_not_loaded_files; end
+    def start_coverage_measurement; end
+    def start_coverage_with_criteria; end
+  end
+end
+
+module SimpleCov::Formatter
+  class << self
+    def from_env(env); end
+  end
+end
+
+class SimpleCov::Formatter::JSONFormatter
+  def format(result); end
+
+  private
+
+  def export_formatted_result(result_hash); end
+  def format_result(result); end
+  def output_message(result); end
+end
+
+SimpleCov::VERSION = T.let(T.unsafe(nil), String)
+module SimpleCovJSONFormatter; end
+
+class SimpleCovJSONFormatter::ResultExporter
+  def initialize(result_hash); end
+
+  def export; end
+
+  private
+
+  def export_path; end
+  def json_result; end
+end
+
+SimpleCovJSONFormatter::ResultExporter::FILENAME = T.let(T.unsafe(nil), String)
+
+class SimpleCovJSONFormatter::ResultHashFormatter
+  def initialize(result); end
+
+  def format; end
+
+  private
+
+  def format_source_file(source_file); end
+  def formatted_result; end
+end
+
+class SimpleCovJSONFormatter::SourceFileFormatter
+  def initialize(source_file); end
+
+  def format; end
+
+  private
+
+  def branch_coverage; end
+  def branches; end
+  def line_coverage; end
+  def lines; end
+  def parse_branch(branch); end
+  def parse_line(line); end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/sorbet-runtime-stub@0.2.0.rbi b/Library/Homebrew/sorbet/rbi/gems/sorbet-runtime-stub@0.2.0.rbi
index f03b037d47..2cfe66bc30 100644
--- a/Library/Homebrew/sorbet/rbi/gems/sorbet-runtime-stub@0.2.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/sorbet-runtime-stub@0.2.0.rbi
@@ -1,6 +1,6 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `sorbet-runtime-stub` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/tapioca@0.4.26.rbi b/Library/Homebrew/sorbet/rbi/gems/tapioca@0.4.26.rbi
index 613d498290..6674f3e76c 100644
--- a/Library/Homebrew/sorbet/rbi/gems/tapioca@0.4.26.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/tapioca@0.4.26.rbi
@@ -4,602 +4,16 @@
 
 # typed: true
 
-class Parlour::Generator
-  sig { params(break_params: Integer, tab_size: Integer, sort_namespaces: T::Boolean).void }
-  def initialize(break_params: T.unsafe(nil), tab_size: T.unsafe(nil), sort_namespaces: T.unsafe(nil)); end
-
-  sig { overridable.returns(T.nilable(Parlour::Plugin)) }
-  def current_plugin; end
-
-  def current_plugin=(_arg0); end
-
-  sig { overridable.returns(Parlour::Options) }
-  def options; end
-end
-
-class Parlour::Options
-  sig { params(break_params: Integer, tab_size: Integer, sort_namespaces: T::Boolean).void }
-  def initialize(break_params:, tab_size:, sort_namespaces:); end
-
-  sig { returns(Integer) }
-  def break_params; end
-
-  sig { params(level: Integer, str: String).returns(String) }
-  def indented(level, str); end
-
-  sig { returns(T::Boolean) }
-  def sort_namespaces; end
-
-  sig { returns(Integer) }
-  def tab_size; end
-end
-
-class Parlour::RbiGenerator < ::Parlour::Generator
-  def initialize(**hash); end
-
-  sig { overridable.params(strictness: String).returns(String) }
-  def rbi(strictness = T.unsafe(nil)); end
-
-  sig { overridable.returns(Parlour::RbiGenerator::Namespace) }
-  def root; end
-end
-
-class Parlour::RbiGenerator::Arbitrary < ::Parlour::RbiGenerator::RbiObject
-  sig { params(generator: Parlour::Generator, code: String, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Arbitrary).void)).void }
-  def initialize(generator, code: T.unsafe(nil), &block); end
-
-  sig { params(other: Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { returns(String) }
-  def code; end
-
-  def code=(_arg0); end
-
-  sig { override.returns(String) }
-  def describe; end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
-  def generate_rbi(indent_level, options); end
-
-  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-end
-
-class Parlour::RbiGenerator::Attribute < ::Parlour::RbiGenerator::Method
-  sig { params(generator: Parlour::Generator, name: String, kind: Symbol, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).void }
-  def initialize(generator, name, kind, type, class_attribute: T.unsafe(nil), &block); end
-
-  sig { override.params(other: Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { returns(T::Boolean) }
-  def class_attribute; end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { returns(Symbol) }
-  def kind; end
-
-  sig { returns(T.any(Parlour::Types::Type, String)) }
-  def type; end
-
-  private
-
-  sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
-  def generate_definition(indent_level, options); end
-end
-
-class Parlour::RbiGenerator::ClassNamespace < ::Parlour::RbiGenerator::Namespace
-  sig { params(generator: Parlour::Generator, name: String, final: T::Boolean, sealed: T::Boolean, superclass: T.nilable(String), abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)).void }
-  def initialize(generator, name, final, sealed, superclass, abstract, &block); end
-
-  sig { returns(T::Boolean) }
-  def abstract; end
-
-  sig { override.returns(String) }
-  def describe; end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
-  def generate_rbi(indent_level, options); end
-
-  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-
-  sig { returns(T.nilable(String)) }
-  def superclass; end
-end
-
-class Parlour::RbiGenerator::Constant < ::Parlour::RbiGenerator::RbiObject
-  sig { params(generator: Parlour::Generator, name: String, value: T.any(Parlour::Types::Type, String), eigen_constant: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Constant).void)).void }
-  def initialize(generator, name: T.unsafe(nil), value: T.unsafe(nil), eigen_constant: T.unsafe(nil), &block); end
-
-  sig { params(other: Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(String) }
-  def describe; end
-
-  def eigen_constant; end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
-  def generate_rbi(indent_level, options); end
-
-  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-
-  sig { returns(T.any(Parlour::Types::Type, String)) }
-  def value; end
-end
-
-class Parlour::RbiGenerator::EnumClassNamespace < ::Parlour::RbiGenerator::ClassNamespace
-  sig { params(generator: Parlour::Generator, name: String, final: T::Boolean, sealed: T::Boolean, enums: T::Array[T.any(String, [String, String])], abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::EnumClassNamespace).void)).void }
-  def initialize(generator, name, final, sealed, enums, abstract, &block); end
-
-  sig { returns(T::Array[T.any(String, [String, String])]) }
-  def enums; end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
-  def generate_body(indent_level, options); end
-
-  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-end
-
-class Parlour::RbiGenerator::Extend < ::Parlour::RbiGenerator::RbiObject
-  sig { params(generator: Parlour::Generator, name: String, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Extend).void)).void }
-  def initialize(generator, name: T.unsafe(nil), &block); end
-
-  sig { params(other: Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(String) }
-  def describe; end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
-  def generate_rbi(indent_level, options); end
-
-  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-end
-
-class Parlour::RbiGenerator::Include < ::Parlour::RbiGenerator::RbiObject
-  sig { params(generator: Parlour::Generator, name: String, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Include).void)).void }
-  def initialize(generator, name: T.unsafe(nil), &block); end
-
-  sig { params(other: Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(String) }
-  def describe; end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
-  def generate_rbi(indent_level, options); end
-
-  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-end
-
-class Parlour::RbiGenerator::Method < ::Parlour::RbiGenerator::RbiObject
-  sig { params(generator: Parlour::Generator, name: String, parameters: T::Array[Parlour::RbiGenerator::Parameter], return_type: T.nilable(T.any(Parlour::Types::Type, String)), abstract: T::Boolean, implementation: T::Boolean, override: T::Boolean, overridable: T::Boolean, class_method: T::Boolean, final: T::Boolean, type_parameters: T.nilable(T::Array[Symbol]), block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Method).void)).void }
-  def initialize(generator, name, parameters, return_type = T.unsafe(nil), abstract: T.unsafe(nil), implementation: T.unsafe(nil), override: T.unsafe(nil), overridable: T.unsafe(nil), class_method: T.unsafe(nil), final: T.unsafe(nil), type_parameters: T.unsafe(nil), &block); end
-
-  sig { overridable.params(other: Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { returns(T::Boolean) }
-  def abstract; end
-
-  sig { returns(T::Boolean) }
-  def class_method; end
-
-  sig { override.returns(String) }
-  def describe; end
-
-  sig { returns(T::Boolean) }
-  def final; end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
-  def generate_rbi(indent_level, options); end
-
-  sig { returns(T::Boolean) }
-  def implementation; end
-
-  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-
-  sig { returns(T::Boolean) }
-  def overridable; end
-
-  sig { returns(T::Boolean) }
-  def override; end
-
-  sig { returns(T::Array[Parlour::RbiGenerator::Parameter]) }
-  def parameters; end
-
-  sig { returns(T.nilable(T.any(Parlour::Types::Type, String))) }
-  def return_type; end
-
-  sig { returns(T::Array[Symbol]) }
-  def type_parameters; end
-
-  private
-
-  sig { overridable.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
-  def generate_definition(indent_level, options); end
-
-  sig { returns(String) }
-  def qualifiers; end
-end
-
-class Parlour::RbiGenerator::ModuleNamespace < ::Parlour::RbiGenerator::Namespace
-  sig { params(generator: Parlour::Generator, name: String, final: T::Boolean, sealed: T::Boolean, interface: T::Boolean, abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)).void }
-  def initialize(generator, name, final, sealed, interface, abstract, &block); end
-
-  sig { returns(T::Boolean) }
-  def abstract; end
-
-  sig { override.returns(String) }
-  def describe; end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
-  def generate_rbi(indent_level, options); end
-
-  sig { returns(T::Boolean) }
-  def interface; end
-
-  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-end
-
-class Parlour::RbiGenerator::Namespace < ::Parlour::RbiGenerator::RbiObject
-  sig { params(generator: Parlour::Generator, name: T.nilable(String), final: T::Boolean, sealed: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Namespace).void)).void }
-  def initialize(generator, name = T.unsafe(nil), final = T.unsafe(nil), sealed = T.unsafe(nil), &block); end
-
-  sig { params(comment: T.any(String, T::Array[String])).void }
-  def add_comment_to_next_child(comment); end
-
-  sig { returns(T::Array[Parlour::RbiGenerator::TypeAlias]) }
-  def aliases; end
-
-  sig { returns(T::Array[Parlour::RbiGenerator::RbiObject]) }
-  def children; end
-
-  sig { returns(T::Array[Parlour::RbiGenerator::Constant]) }
-  def constants; end
-
-  def create_arbitrary(code:, &block); end
-  def create_attr(*args, &blk); end
-
-  sig { params(name: String, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).returns(Parlour::RbiGenerator::Attribute) }
-  def create_attr_accessor(name, type:, class_attribute: T.unsafe(nil), &block); end
-
-  sig { params(name: String, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).returns(Parlour::RbiGenerator::Attribute) }
-  def create_attr_reader(name, type:, class_attribute: T.unsafe(nil), &block); end
-
-  sig { params(name: String, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).returns(Parlour::RbiGenerator::Attribute) }
-  def create_attr_writer(name, type:, class_attribute: T.unsafe(nil), &block); end
-
-  sig { params(name: String, kind: Symbol, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).returns(Parlour::RbiGenerator::Attribute) }
-  def create_attribute(name, kind:, type:, class_attribute: T.unsafe(nil), &block); end
-
-  sig { params(name: String, final: T::Boolean, sealed: T::Boolean, superclass: T.nilable(String), abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)).returns(Parlour::RbiGenerator::ClassNamespace) }
-  def create_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), superclass: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
-
-  sig { params(name: String, value: String, eigen_constant: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Constant).void)).returns(Parlour::RbiGenerator::Constant) }
-  def create_constant(name, value:, eigen_constant: T.unsafe(nil), &block); end
-
-  sig { params(name: String, final: T::Boolean, sealed: T::Boolean, enums: T.nilable(T::Array[T.any(String, [String, String])]), abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::EnumClassNamespace).void)).returns(Parlour::RbiGenerator::EnumClassNamespace) }
-  def create_enum_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), enums: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
-
-  sig { params(name: String, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Extend).void)).returns(Parlour::RbiGenerator::Extend) }
-  def create_extend(name, &block); end
-
-  sig { params(extendables: T::Array[String]).returns(T::Array[Parlour::RbiGenerator::Extend]) }
-  def create_extends(extendables); end
-
-  sig { params(name: String, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Include).void)).returns(Parlour::RbiGenerator::Include) }
-  def create_include(name, &block); end
-
-  sig { params(includables: T::Array[String]).returns(T::Array[Parlour::RbiGenerator::Include]) }
-  def create_includes(includables); end
-
-  sig { params(name: String, parameters: T.nilable(T::Array[Parlour::RbiGenerator::Parameter]), return_type: T.nilable(T.any(Parlour::Types::Type, String)), returns: T.nilable(T.any(Parlour::Types::Type, String)), abstract: T::Boolean, implementation: T::Boolean, override: T::Boolean, overridable: T::Boolean, class_method: T::Boolean, final: T::Boolean, type_parameters: T.nilable(T::Array[Symbol]), block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Method).void)).returns(Parlour::RbiGenerator::Method) }
-  def create_method(name, parameters: T.unsafe(nil), return_type: T.unsafe(nil), returns: T.unsafe(nil), abstract: T.unsafe(nil), implementation: T.unsafe(nil), override: T.unsafe(nil), overridable: T.unsafe(nil), class_method: T.unsafe(nil), final: T.unsafe(nil), type_parameters: T.unsafe(nil), &block); end
-
-  sig { params(name: String, final: T::Boolean, sealed: T::Boolean, interface: T::Boolean, abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)).returns(Parlour::RbiGenerator::ModuleNamespace) }
-  def create_module(name, final: T.unsafe(nil), sealed: T.unsafe(nil), interface: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
-
-  sig { params(name: String, final: T::Boolean, sealed: T::Boolean, props: T.nilable(T::Array[Parlour::RbiGenerator::StructProp]), abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::StructClassNamespace).void)).returns(Parlour::RbiGenerator::StructClassNamespace) }
-  def create_struct_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), props: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
-
-  sig { params(name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::TypeAlias).void)).returns(Parlour::RbiGenerator::TypeAlias) }
-  def create_type_alias(name, type:, &block); end
-
-  sig { override.overridable.returns(String) }
-  def describe; end
-
-  sig { returns(T::Array[Parlour::RbiGenerator::Extend]) }
-  def extends; end
-
-  sig { returns(T::Boolean) }
-  def final; end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { override.overridable.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
-  def generate_rbi(indent_level, options); end
-
-  sig { returns(T::Array[Parlour::RbiGenerator::Include]) }
-  def includes; end
-
-  sig { override.overridable.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.overridable.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-
-  sig { params(constant: Module, block: T.proc.params(x: Parlour::RbiGenerator::Namespace).void).void }
-  def path(constant, &block); end
-
-  sig { returns(T::Boolean) }
-  def sealed; end
-
-  def type_aliases(*args, &blk); end
-
-  private
-
-  sig { overridable.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
-  def generate_body(indent_level, options); end
-
-  sig { params(object: Parlour::RbiGenerator::RbiObject).void }
-  def move_next_comments(object); end
-end
-
-Parlour::RbiGenerator::Options = Parlour::Options
-
-class Parlour::RbiGenerator::Parameter
-  sig { params(name: String, type: T.nilable(T.any(Parlour::Types::Type, String)), default: T.nilable(String)).void }
-  def initialize(name, type: T.unsafe(nil), default: T.unsafe(nil)); end
-
-  sig { params(other: Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { returns(T.nilable(String)) }
-  def default; end
-
-  sig { void }
-  def generalize_from_rbi!; end
-
-  sig { returns(Symbol) }
-  def kind; end
-
-  sig { returns(String) }
-  def name; end
-
-  sig { returns(String) }
-  def name_without_kind; end
-
-  sig { returns(String) }
-  def to_def_param; end
-
-  sig { returns(String) }
-  def to_sig_param; end
-
-  sig { returns(T.any(Parlour::Types::Type, String)) }
-  def type; end
-end
-
-Parlour::RbiGenerator::Parameter::PREFIXES = T.let(T.unsafe(nil), Hash)
-
-class Parlour::RbiGenerator::RbiObject < ::Parlour::TypedObject
-  abstract!
-
-  sig { params(generator: Parlour::Generator, name: String).void }
-  def initialize(generator, name); end
-
-  sig { override.overridable.returns(String) }
-  def describe; end
-
-  sig { abstract.void }
-  def generalize_from_rbi!; end
-
-  sig { abstract.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
-  def generate_rbi(indent_level, options); end
-
-  sig { returns(Parlour::Generator) }
-  def generator; end
-
-  sig { abstract.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { abstract.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-end
-
-class Parlour::RbiGenerator::StructClassNamespace < ::Parlour::RbiGenerator::ClassNamespace
-  sig { params(generator: Parlour::Generator, name: String, final: T::Boolean, sealed: T::Boolean, props: T::Array[Parlour::RbiGenerator::StructProp], abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::StructClassNamespace).void)).void }
-  def initialize(generator, name, final, sealed, props, abstract, &block); end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
-  def generate_body(indent_level, options); end
-
-  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-
-  sig { returns(T::Array[Parlour::RbiGenerator::StructProp]) }
-  def props; end
-end
-
-class Parlour::RbiGenerator::StructProp
-  sig { params(name: String, type: T.any(Parlour::Types::Type, String), optional: T.nilable(T.any(Symbol, T::Boolean)), enum: T.nilable(String), dont_store: T.nilable(T::Boolean), foreign: T.nilable(String), default: T.nilable(String), factory: T.nilable(String), immutable: T.nilable(T::Boolean), array: T.nilable(String), override: T.nilable(T::Boolean), redaction: T.nilable(String)).void }
-  def initialize(name, type, optional: T.unsafe(nil), enum: T.unsafe(nil), dont_store: T.unsafe(nil), foreign: T.unsafe(nil), default: T.unsafe(nil), factory: T.unsafe(nil), immutable: T.unsafe(nil), array: T.unsafe(nil), override: T.unsafe(nil), redaction: T.unsafe(nil)); end
-
-  sig { params(other: Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { returns(T.nilable(String)) }
-  def array; end
-
-  sig { returns(T.nilable(String)) }
-  def default; end
-
-  sig { returns(T.nilable(T::Boolean)) }
-  def dont_store; end
-
-  sig { returns(T.nilable(String)) }
-  def enum; end
-
-  sig { returns(T.nilable(String)) }
-  def factory; end
-
-  sig { returns(T.nilable(String)) }
-  def foreign; end
-
-  sig { void }
-  def generalize_from_rbi!; end
-
-  sig { returns(T.nilable(T::Boolean)) }
-  def immutable; end
-
-  sig { returns(String) }
-  def name; end
-
-  sig { returns(T.nilable(T.any(Symbol, T::Boolean))) }
-  def optional; end
-
-  sig { returns(T.nilable(T::Boolean)) }
-  def override; end
-
-  sig { returns(T.nilable(String)) }
-  def redaction; end
-
-  sig { returns(String) }
-  def to_prop_call; end
-
-  sig { returns(T.any(Parlour::Types::Type, String)) }
-  def type; end
-end
-
-Parlour::RbiGenerator::StructProp::EXTRA_PROPERTIES = T.let(T.unsafe(nil), Array)
-
-class Parlour::RbiGenerator::TypeAlias < ::Parlour::RbiGenerator::RbiObject
-  sig { params(generator: Parlour::Generator, name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::TypeAlias).void)).void }
-  def initialize(generator, name:, type:, &block); end
-
-  sig { params(other: Object).returns(T::Boolean) }
-  def ==(other); end
-
-  sig { override.returns(String) }
-  def describe; end
-
-  sig { override.void }
-  def generalize_from_rbi!; end
-
-  sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
-  def generate_rbi(indent_level, options); end
-
-  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
-  def merge_into_self(others); end
-
-  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
-  def mergeable?(others); end
-
-  sig { returns(T.any(Parlour::Types::Type, String)) }
-  def type; end
-end
-
-class Parlour::TypedObject
-  abstract!
-
-  sig { params(name: String).void }
-  def initialize(name); end
-
-  sig { params(comment: T.any(String, T::Array[String])).void }
-  def add_comment(comment); end
-
-  def add_comments(*args, &blk); end
-
-  sig { returns(T::Array[String]) }
-  def comments; end
-
-  sig { abstract.returns(String) }
-  def describe; end
-
-  sig { returns(T.nilable(Parlour::Plugin)) }
-  def generated_by; end
-
-  sig { returns(String) }
-  def name; end
-
-  protected
-
-  sig { params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
-  def generate_comments(indent_level, options); end
-end
-
 class String
   include ::Comparable
   include ::JSON::Ext::Generator::GeneratorMethods::String
   include ::Colorize::InstanceMethods
+  include ::MessagePack::CoreExt
   extend ::JSON::Ext::Generator::GeneratorMethods::String::Extend
   extend ::Colorize::ClassMethods
+
+  sig { returns(String) }
+  def underscore; end
 end
 
 String::BLANK_RE = T.let(T.unsafe(nil), Regexp)
diff --git a/Library/Homebrew/sorbet/rbi/gems/thor@1.1.0.rbi b/Library/Homebrew/sorbet/rbi/gems/thor@1.1.0.rbi
index 392c72ab72..71ce9dd31f 100644
--- a/Library/Homebrew/sorbet/rbi/gems/thor@1.1.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/thor@1.1.0.rbi
@@ -1,15 +1,15 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `thor` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
 class Thor
-  include(::Thor::Base)
-  include(::Thor::Invocation)
-  include(::Thor::Shell)
-  extend(::Thor::Base::ClassMethods)
-  extend(::Thor::Invocation::ClassMethods)
+  include ::Thor::Base
+  include ::Thor::Invocation
+  include ::Thor::Shell
+  extend ::Thor::Base::ClassMethods
+  extend ::Thor::Invocation::ClassMethods
 
   def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
 
@@ -66,7 +66,7 @@ class Thor
 end
 
 module Thor::Actions
-  mixes_in_class_methods(::Thor::Actions::ClassMethods)
+  mixes_in_class_methods ::Thor::Actions::ClassMethods
 
   def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil)); end
 
@@ -213,10 +213,7 @@ class Thor::Actions::InjectIntoFile < ::Thor::Actions::EmptyDirectory
 end
 
 Thor::Actions::WARNINGS = T.let(T.unsafe(nil), Hash)
-
-class Thor::AmbiguousCommandError < ::Thor::Error
-end
-
+class Thor::AmbiguousCommandError < ::Thor::Error; end
 Thor::AmbiguousTaskError = Thor::AmbiguousCommandError
 
 class Thor::Argument
@@ -272,10 +269,10 @@ end
 Thor::Arguments::NUMERIC = T.let(T.unsafe(nil), Regexp)
 
 module Thor::Base
-  include(::Thor::Invocation)
-  include(::Thor::Shell)
+  include ::Thor::Invocation
+  include ::Thor::Shell
 
-  mixes_in_class_methods(::Thor::Base::ClassMethods)
+  mixes_in_class_methods ::Thor::Base::ClassMethods
 
   def initialize(args = T.unsafe(nil), local_options = T.unsafe(nil), config = T.unsafe(nil)); end
 
@@ -382,9 +379,7 @@ class Thor::Command < ::Struct
 end
 
 Thor::Command::FILE_REGEXP = T.let(T.unsafe(nil), Regexp)
-
-module Thor::CoreExt
-end
+module Thor::CoreExt; end
 
 class Thor::CoreExt::HashWithIndifferentAccess < ::Hash
   def initialize(hash = T.unsafe(nil)); end
@@ -417,17 +412,14 @@ class Thor::DynamicCommand < ::Thor::Command
 end
 
 Thor::DynamicTask = Thor::DynamicCommand
-
-class Thor::Error < ::StandardError
-end
+class Thor::Error < ::StandardError; end
 
 class Thor::Group
-  include(::Thor::Base)
-  include(::Thor::Invocation)
-  include(::Thor::Shell)
-  extend(::Thor::Base::ClassMethods)
-  extend(::Thor::Invocation::ClassMethods)
-
+  include ::Thor::Base
+  include ::Thor::Invocation
+  include ::Thor::Shell
+  extend ::Thor::Base::ClassMethods
+  extend ::Thor::Invocation::ClassMethods
 
   protected
 
@@ -468,7 +460,7 @@ end
 Thor::HiddenTask = Thor::HiddenCommand
 
 module Thor::Invocation
-  mixes_in_class_methods(::Thor::Invocation::ClassMethods)
+  mixes_in_class_methods ::Thor::Invocation::ClassMethods
 
   def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil), &block); end
 
@@ -495,8 +487,7 @@ module Thor::Invocation::ClassMethods
   def prepare_for_invocation(key, name); end
 end
 
-class Thor::InvocationError < ::Thor::Error
-end
+class Thor::InvocationError < ::Thor::Error; end
 
 module Thor::LineEditor
   class << self
@@ -551,8 +542,7 @@ class Thor::LineEditor::Readline::PathCompletion
   def text; end
 end
 
-class Thor::MalformattedArgumentError < ::Thor::InvocationError
-end
+class Thor::MalformattedArgumentError < ::Thor::InvocationError; end
 
 class Thor::NestedContext
   def initialize; end
@@ -629,22 +619,13 @@ class Thor::Options < ::Thor::Arguments
 end
 
 Thor::Options::EQ_RE = T.let(T.unsafe(nil), Regexp)
-
 Thor::Options::LONG_RE = T.let(T.unsafe(nil), Regexp)
-
 Thor::Options::OPTS_END = T.let(T.unsafe(nil), String)
-
 Thor::Options::SHORT_NUM = T.let(T.unsafe(nil), Regexp)
-
 Thor::Options::SHORT_RE = T.let(T.unsafe(nil), Regexp)
-
 Thor::Options::SHORT_SQ_RE = T.let(T.unsafe(nil), Regexp)
-
-class Thor::RequiredArgumentMissingError < ::Thor::InvocationError
-end
-
-module Thor::Sandbox
-end
+class Thor::RequiredArgumentMissingError < ::Thor::InvocationError; end
+module Thor::Sandbox; end
 
 module Thor::Shell
   def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil)); end
@@ -734,39 +715,22 @@ class Thor::Shell::Color < ::Thor::Shell::Basic
 end
 
 Thor::Shell::Color::BLACK = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::BLUE = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::BOLD = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::CLEAR = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::CYAN = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::GREEN = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::MAGENTA = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::ON_BLACK = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::ON_BLUE = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::ON_CYAN = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::ON_GREEN = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::ON_MAGENTA = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::ON_RED = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::ON_WHITE = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::ON_YELLOW = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::RED = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::WHITE = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::YELLOW = T.let(T.unsafe(nil), String)
 
 class Thor::Shell::HTML < ::Thor::Shell::Basic
@@ -782,49 +746,29 @@ class Thor::Shell::HTML < ::Thor::Shell::Basic
 end
 
 Thor::Shell::HTML::BLACK = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::BLUE = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::BOLD = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::CYAN = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::GREEN = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::MAGENTA = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::ON_BLACK = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::ON_BLUE = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::ON_CYAN = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::ON_GREEN = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::ON_MAGENTA = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::ON_RED = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::ON_WHITE = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::ON_YELLOW = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::RED = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::WHITE = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::YELLOW = T.let(T.unsafe(nil), String)
-
 Thor::Shell::SHELL_DELEGATED_METHODS = T.let(T.unsafe(nil), Array)
-
 Thor::TEMPLATE_EXTNAME = T.let(T.unsafe(nil), String)
-
 Thor::THOR_RESERVED_WORDS = T.let(T.unsafe(nil), Array)
-
 Thor::Task = Thor::Command
 
 class Thor::UndefinedCommandError < ::Thor::Error
-  include(::DidYouMean::Correctable)
+  include ::DidYouMean::Correctable
 
   def initialize(command, all_commands, namespace); end
 
@@ -843,7 +787,7 @@ end
 Thor::UndefinedTaskError = Thor::UndefinedCommandError
 
 class Thor::UnknownArgumentError < ::Thor::Error
-  include(::DidYouMean::Correctable)
+  include ::DidYouMean::Correctable
 
   def initialize(switches, unknown); end
 
diff --git a/Library/Homebrew/sorbet/rbi/gems/tzinfo@2.0.4.rbi b/Library/Homebrew/sorbet/rbi/gems/tzinfo@2.0.4.rbi
index c9268f5d29..3284422436 100644
--- a/Library/Homebrew/sorbet/rbi/gems/tzinfo@2.0.4.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/tzinfo@2.0.4.rbi
@@ -1,13 +1,12 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `tzinfo` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-module TZInfo
-end
+module TZInfo; end
 
-class TZInfo::AbsoluteDayOfYearTransitionRule
+class TZInfo::AbsoluteDayOfYearTransitionRule < ::TZInfo::DayOfYearTransitionRule
   def initialize(day, transition_at = T.unsafe(nil)); end
 
   def ==(r); end
@@ -21,11 +20,30 @@ class TZInfo::AbsoluteDayOfYearTransitionRule
   def hash_args; end
 end
 
-class TZInfo::AmbiguousTime < ::StandardError
+class TZInfo::AmbiguousTime < ::StandardError; end
+
+class TZInfo::AnnualRules
+  def initialize(std_offset, dst_offset, dst_start_rule, dst_end_rule); end
+
+  def dst_end_rule; end
+  def dst_offset; end
+  def dst_start_rule; end
+  def std_offset; end
+  def transitions(year); end
+
+  private
+
+  def apply_rule(rule, from_offset, to_offset, year); end
+end
+
+class TZInfo::ConcurrentStringDeduper < ::TZInfo::StringDeduper
+  protected
+
+  def create_hash(&block); end
 end
 
 class TZInfo::Country
-  include(::Comparable)
+  include ::Comparable
 
   def initialize(info); end
 
@@ -55,6 +73,8 @@ class TZInfo::Country
   end
 end
 
+TZInfo::CountryIndexDefinition = TZInfo::Format1::CountryIndexDefinition
+
 class TZInfo::CountryTimezone
   def initialize(identifier, latitude, longitude, description = T.unsafe(nil)); end
 
@@ -106,11 +126,8 @@ class TZInfo::DataSource
   end
 end
 
-class TZInfo::DataSourceNotFound < ::StandardError
-end
-
-module TZInfo::DataSources
-end
+class TZInfo::DataSourceNotFound < ::StandardError; end
+module TZInfo::DataSources; end
 
 class TZInfo::DataSources::ConstantOffsetDataTimezoneInfo < ::TZInfo::DataSources::DataTimezoneInfo
   def initialize(identifier, constant_offset); end
@@ -145,11 +162,9 @@ class TZInfo::DataSources::DataTimezoneInfo < ::TZInfo::DataSources::TimezoneInf
   def raise_not_implemented(method_name); end
 end
 
-class TZInfo::DataSources::InvalidZoneinfoDirectory < ::StandardError
-end
-
-class TZInfo::DataSources::InvalidZoneinfoFile < ::StandardError
-end
+class TZInfo::DataSources::InvalidPosixTimeZone < ::StandardError; end
+class TZInfo::DataSources::InvalidZoneinfoDirectory < ::StandardError; end
+class TZInfo::DataSources::InvalidZoneinfoFile < ::StandardError; end
 
 class TZInfo::DataSources::LinkedTimezoneInfo < ::TZInfo::DataSources::TimezoneInfo
   def initialize(identifier, link_to_identifier); end
@@ -158,6 +173,19 @@ class TZInfo::DataSources::LinkedTimezoneInfo < ::TZInfo::DataSources::TimezoneI
   def link_to_identifier; end
 end
 
+class TZInfo::DataSources::PosixTimeZoneParser
+  def initialize(string_deduper); end
+
+  def parse(tz_string); end
+
+  private
+
+  def check_scan(s, pattern); end
+  def get_offset_from_hms(h, m, s); end
+  def get_seconds_after_midnight_from_hms(h, m, s); end
+  def parse_rule(s, type); end
+end
+
 class TZInfo::DataSources::RubyDataSource < ::TZInfo::DataSource
   def initialize; end
 
@@ -180,8 +208,7 @@ class TZInfo::DataSources::RubyDataSource < ::TZInfo::DataSource
   def version_info; end
 end
 
-class TZInfo::DataSources::TZInfoDataNotFound < ::StandardError
-end
+class TZInfo::DataSources::TZInfoDataNotFound < ::StandardError; end
 
 class TZInfo::DataSources::TimezoneInfo
   def initialize(identifier); end
@@ -246,9 +273,32 @@ class TZInfo::DataSources::ZoneinfoDataSource < ::TZInfo::DataSource
   end
 end
 
-class TZInfo::DataSources::ZoneinfoDirectoryNotFound < ::StandardError
+TZInfo::DataSources::ZoneinfoDataSource::DEFAULT_ALTERNATE_ISO3166_TAB_SEARCH_PATH = T.let(T.unsafe(nil), Array)
+TZInfo::DataSources::ZoneinfoDataSource::DEFAULT_SEARCH_PATH = T.let(T.unsafe(nil), Array)
+class TZInfo::DataSources::ZoneinfoDirectoryNotFound < ::StandardError; end
+
+class TZInfo::DataSources::ZoneinfoReader
+  def initialize(posix_tz_parser, string_deduper); end
+
+  def read(file_path); end
+
+  private
+
+  def apply_rules_with_transitions(file, transitions, offsets, rules); end
+  def apply_rules_without_transitions(file, first_offset, rules); end
+  def check_read(file, bytes); end
+  def derive_offsets(transitions, offsets); end
+  def find_existing_offset(offsets, offset); end
+  def make_signed_int32(long); end
+  def make_signed_int64(high, low); end
+  def offset_matches_rule?(offset, rule_offset); end
+  def parse(file); end
+  def replace_with_existing_offsets(offsets, annual_rules); end
+  def validate_and_fix_last_defined_transition_offset(file, last_defined, first_rule_offset); end
 end
 
+TZInfo::DataSources::ZoneinfoReader::GENERATE_UP_TO = T.let(T.unsafe(nil), Integer)
+
 class TZInfo::DataTimezone < ::TZInfo::InfoTimezone
   def canonical_zone; end
   def period_for(time); end
@@ -257,7 +307,7 @@ class TZInfo::DataTimezone < ::TZInfo::InfoTimezone
 end
 
 class TZInfo::DateTimeWithOffset < ::DateTime
-  include(::TZInfo::WithOffset)
+  include ::TZInfo::WithOffset
 
   def downto(min); end
   def england; end
@@ -276,6 +326,189 @@ class TZInfo::DateTimeWithOffset < ::DateTime
   def clear_timezone_offset; end
 end
 
+class TZInfo::DayOfMonthTransitionRule < ::TZInfo::DayOfWeekTransitionRule
+  def initialize(month, week, day_of_week, transition_at = T.unsafe(nil)); end
+
+  def ==(r); end
+  def eql?(r); end
+
+  protected
+
+  def get_day(offset, year); end
+  def hash_args; end
+  def offset_start; end
+end
+
+class TZInfo::DayOfWeekTransitionRule < ::TZInfo::TransitionRule
+  def initialize(month, day_of_week, transition_at); end
+
+  def ==(r); end
+  def eql?(r); end
+  def is_always_first_day_of_year?; end
+  def is_always_last_day_of_year?; end
+
+  protected
+
+  def day_of_week; end
+  def hash_args; end
+  def month; end
+end
+
+class TZInfo::DayOfYearTransitionRule < ::TZInfo::TransitionRule
+  def initialize(day, transition_at); end
+
+  def ==(r); end
+  def eql?(r); end
+
+  protected
+
+  def hash_args; end
+  def seconds; end
+end
+
+module TZInfo::Format1; end
+
+class TZInfo::Format1::CountryDefiner < ::TZInfo::Format2::CountryDefiner
+  def initialize(identifier_deduper, description_deduper); end
+end
+
+module TZInfo::Format1::CountryIndexDefinition
+  mixes_in_class_methods ::TZInfo::Format1::CountryIndexDefinition::ClassMethods
+
+  class << self
+    def append_features(base); end
+  end
+end
+
+module TZInfo::Format1::CountryIndexDefinition::ClassMethods
+  def countries; end
+
+  private
+
+  def country(code, name); end
+end
+
+class TZInfo::Format1::TimezoneDefiner < ::TZInfo::Format2::TimezoneDefiner
+  def offset(id, utc_offset, std_offset, abbreviation); end
+  def transition(year, month, offset_id, timestamp_value, datetime_numerator = T.unsafe(nil), datetime_denominator = T.unsafe(nil)); end
+end
+
+module TZInfo::Format1::TimezoneDefinition
+  mixes_in_class_methods ::TZInfo::Format1::TimezoneDefinition::ClassMethods
+
+  class << self
+    def append_features(base); end
+  end
+end
+
+module TZInfo::Format1::TimezoneDefinition::ClassMethods
+  private
+
+  def timezone_definer_class; end
+end
+
+module TZInfo::Format1::TimezoneIndexDefinition
+  mixes_in_class_methods ::TZInfo::Format1::TimezoneIndexDefinition::ClassMethods
+
+  class << self
+    def append_features(base); end
+  end
+end
+
+module TZInfo::Format1::TimezoneIndexDefinition::ClassMethods
+  def data_timezones; end
+  def linked_timezones; end
+
+  private
+
+  def linked_timezone(identifier); end
+  def timezone(identifier); end
+end
+
+module TZInfo::Format2; end
+
+class TZInfo::Format2::CountryDefiner
+  def initialize(shared_timezones, identifier_deduper, description_deduper); end
+
+  def timezone(identifier_or_reference, latitude_numerator = T.unsafe(nil), latitude_denominator = T.unsafe(nil), longitude_numerator = T.unsafe(nil), longitude_denominator = T.unsafe(nil), description = T.unsafe(nil)); end
+  def timezones; end
+end
+
+class TZInfo::Format2::CountryIndexDefiner
+  def initialize(identifier_deduper, description_deduper); end
+
+  def countries; end
+  def country(code, name); end
+  def timezone(reference, identifier, latitude_numerator, latitude_denominator, longitude_numerator, longitude_denominator, description = T.unsafe(nil)); end
+end
+
+module TZInfo::Format2::CountryIndexDefinition
+  mixes_in_class_methods ::TZInfo::Format2::CountryIndexDefinition::ClassMethods
+
+  class << self
+    def append_features(base); end
+  end
+end
+
+module TZInfo::Format2::CountryIndexDefinition::ClassMethods
+  def countries; end
+
+  private
+
+  def country_index; end
+end
+
+class TZInfo::Format2::TimezoneDefiner
+  def initialize(string_deduper); end
+
+  def first_offset; end
+  def offset(id, base_utc_offset, std_offset, abbreviation); end
+  def subsequent_rules(*args); end
+  def transition(offset_id, timestamp_value); end
+  def transitions; end
+end
+
+module TZInfo::Format2::TimezoneDefinition
+  mixes_in_class_methods ::TZInfo::Format2::TimezoneDefinition::ClassMethods
+
+  class << self
+    def append_features(base); end
+  end
+end
+
+module TZInfo::Format2::TimezoneDefinition::ClassMethods
+  def get; end
+
+  private
+
+  def linked_timezone(identifier, link_to_identifier); end
+  def timezone(identifier); end
+  def timezone_definer_class; end
+end
+
+class TZInfo::Format2::TimezoneIndexDefiner
+  def initialize(string_deduper); end
+
+  def data_timezone(identifier); end
+  def data_timezones; end
+  def linked_timezone(identifier); end
+  def linked_timezones; end
+end
+
+module TZInfo::Format2::TimezoneIndexDefinition
+  mixes_in_class_methods ::TZInfo::Format2::TimezoneIndexDefinition::ClassMethods
+
+  class << self
+    def append_features(base); end
+  end
+end
+
+module TZInfo::Format2::TimezoneIndexDefinition::ClassMethods
+  def data_timezones; end
+  def linked_timezones; end
+  def timezone_index; end
+end
+
 class TZInfo::InfoTimezone < ::TZInfo::Timezone
   def initialize(info); end
 
@@ -286,13 +519,36 @@ class TZInfo::InfoTimezone < ::TZInfo::Timezone
   def info; end
 end
 
-class TZInfo::InvalidCountryCode < ::StandardError
+class TZInfo::InvalidCountryCode < ::StandardError; end
+class TZInfo::InvalidDataSource < ::StandardError; end
+class TZInfo::InvalidTimezoneIdentifier < ::StandardError; end
+
+class TZInfo::JulianDayOfYearTransitionRule < ::TZInfo::DayOfYearTransitionRule
+  def initialize(day, transition_at = T.unsafe(nil)); end
+
+  def ==(r); end
+  def eql?(r); end
+  def is_always_first_day_of_year?; end
+  def is_always_last_day_of_year?; end
+
+  protected
+
+  def get_day(offset, year); end
+  def hash_args; end
 end
 
-class TZInfo::InvalidDataSource < ::StandardError
-end
+TZInfo::JulianDayOfYearTransitionRule::LEAP = T.let(T.unsafe(nil), Integer)
+TZInfo::JulianDayOfYearTransitionRule::YEAR = T.let(T.unsafe(nil), Integer)
 
-class TZInfo::InvalidTimezoneIdentifier < ::StandardError
+class TZInfo::LastDayOfMonthTransitionRule < ::TZInfo::DayOfWeekTransitionRule
+  def initialize(month, day_of_week, transition_at = T.unsafe(nil)); end
+
+  def ==(r); end
+  def eql?(r); end
+
+  protected
+
+  def get_day(offset, year); end
 end
 
 class TZInfo::LinkedTimezone < ::TZInfo::InfoTimezone
@@ -314,11 +570,24 @@ class TZInfo::OffsetTimezonePeriod < ::TZInfo::TimezonePeriod
   def start_transition; end
 end
 
-class TZInfo::PeriodNotFound < ::StandardError
+class TZInfo::PeriodNotFound < ::StandardError; end
+
+class TZInfo::StringDeduper
+  def initialize; end
+
+  def dedupe(string); end
+
+  protected
+
+  def create_hash(&block); end
+
+  class << self
+    def global; end
+  end
 end
 
 class TZInfo::TimeWithOffset < ::Time
-  include(::TZInfo::WithOffset)
+  include ::TZInfo::WithOffset
 
   def dst?; end
   def getlocal(*args); end
@@ -339,7 +608,7 @@ class TZInfo::TimeWithOffset < ::Time
 end
 
 class TZInfo::Timestamp
-  include(::Comparable)
+  include ::Comparable
 
   def initialize(value, sub_second = T.unsafe(nil), utc_offset = T.unsafe(nil)); end
 
@@ -386,8 +655,10 @@ class TZInfo::Timestamp
   end
 end
 
+TZInfo::Timestamp::JD_EPOCH = T.let(T.unsafe(nil), Integer)
+
 class TZInfo::TimestampWithOffset < ::TZInfo::Timestamp
-  include(::TZInfo::WithOffset)
+  include ::TZInfo::WithOffset
 
   def set_timezone_offset(timezone_offset); end
   def timezone_offset; end
@@ -400,7 +671,7 @@ class TZInfo::TimestampWithOffset < ::TZInfo::Timestamp
 end
 
 class TZInfo::Timezone
-  include(::Comparable)
+  include ::Comparable
 
   def <=>(tz); end
   def =~(regexp); end
@@ -464,6 +735,9 @@ class TZInfo::Timezone
   end
 end
 
+TZInfo::TimezoneDefinition = TZInfo::Format1::TimezoneDefinition
+TZInfo::TimezoneIndexDefinition = TZInfo::Format1::TimezoneIndexDefinition
+
 class TZInfo::TimezoneOffset
   def initialize(base_utc_offset, std_offset, abbreviation); end
 
@@ -541,6 +815,20 @@ class TZInfo::TimezoneTransition
   def timestamp_value; end
 end
 
+class TZInfo::TransitionRule
+  def initialize(transition_at); end
+
+  def ==(r); end
+  def at(offset, year); end
+  def eql?(r); end
+  def hash; end
+  def transition_at; end
+
+  protected
+
+  def hash_args; end
+end
+
 class TZInfo::TransitionsTimezonePeriod < ::TZInfo::TimezonePeriod
   def initialize(start_transition, end_transition); end
 
@@ -552,9 +840,11 @@ class TZInfo::TransitionsTimezonePeriod < ::TZInfo::TimezonePeriod
   def start_transition; end
 end
 
-class TZInfo::UnknownTimezone < ::StandardError
+class TZInfo::UnaryMinusGlobalStringDeduper
+  def dedupe(string); end
 end
 
+class TZInfo::UnknownTimezone < ::StandardError; end
 TZInfo::VERSION = T.let(T.unsafe(nil), String)
 
 module TZInfo::WithOffset
diff --git a/Library/Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi b/Library/Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi
index a2cfbfcffa..fad1d8d730 100644
--- a/Library/Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi
@@ -1,19 +1,18 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `unf` gem.
-# Please instead update this file by running `tapioca generate --exclude json`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-module UNF
-end
+module UNF; end
 
 class UNF::Normalizer
-  include(::Singleton)
-  extend(::Singleton::SingletonClassMethods)
+  include ::Singleton
+  extend ::Singleton::SingletonClassMethods
 
   def initialize; end
 
-  def normalize(_, _); end
+  def normalize(_arg0, _arg1); end
 
   class << self
     def instance; end
diff --git a/Library/Homebrew/sorbet/rbi/gems/unf_ext@0.0.7.7.rbi b/Library/Homebrew/sorbet/rbi/gems/unf_ext@0.0.7.7.rbi
index 97d63e9dd5..db94ac3ed3 100644
--- a/Library/Homebrew/sorbet/rbi/gems/unf_ext@0.0.7.7.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/unf_ext@0.0.7.7.rbi
@@ -1,7 +1,8 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `unf_ext` gem.
-# Please instead update this file by running `tapioca generate --exclude json`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
diff --git a/Library/Homebrew/sorbet/rbi/gems/unicode-display_width@2.0.0.rbi b/Library/Homebrew/sorbet/rbi/gems/unicode-display_width@2.0.0.rbi
index ed9e90f8ea..f52fda1358 100644
--- a/Library/Homebrew/sorbet/rbi/gems/unicode-display_width@2.0.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/unicode-display_width@2.0.0.rbi
@@ -1,11 +1,10 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `unicode-display_width` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-module Unicode
-end
+module Unicode; end
 
 class Unicode::DisplayWidth
   def initialize(ambiguous: T.unsafe(nil), overwrite: T.unsafe(nil), emoji: T.unsafe(nil)); end
@@ -20,13 +19,8 @@ class Unicode::DisplayWidth
 end
 
 Unicode::DisplayWidth::DATA_DIRECTORY = T.let(T.unsafe(nil), String)
-
 Unicode::DisplayWidth::DEPTHS = T.let(T.unsafe(nil), Array)
-
 Unicode::DisplayWidth::INDEX = T.let(T.unsafe(nil), Array)
-
 Unicode::DisplayWidth::INDEX_FILENAME = T.let(T.unsafe(nil), String)
-
 Unicode::DisplayWidth::UNICODE_VERSION = T.let(T.unsafe(nil), String)
-
 Unicode::DisplayWidth::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/uri_template@0.7.0.rbi b/Library/Homebrew/sorbet/rbi/gems/uri_template@0.7.0.rbi
index 230973de49..05a8b3136d 100644
--- a/Library/Homebrew/sorbet/rbi/gems/uri_template@0.7.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/uri_template@0.7.0.rbi
@@ -4,5 +4,492 @@
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module URITemplate
+  extend ::URITemplate::ClassMethods
+
+  mixes_in_class_methods ::URITemplate::ClassMethods
+
+  def +(other, *args, &block); end
+  def /(other, *args, &block); end
+  def ==(other, *args, &block); end
+  def >>(other, *args, &block); end
+  def absolute?; end
+  def concat(other, *args, &block); end
+  def concat_without_coercion(other); end
+  def eq(other, *args, &block); end
+  def eq_without_coercion(other); end
+  def expand(variables = T.unsafe(nil)); end
+  def expand_partial(variables = T.unsafe(nil)); end
+  def host?; end
+  def path_concat(other, *args, &block); end
+  def path_concat_without_coercion(other); end
+  def pattern; end
+  def relative?; end
+  def scheme?; end
+  def static_characters; end
+  def to_s; end
+  def tokens; end
+  def type; end
+  def variables; end
+
+  private
+
+  def normalize_variables(variables); end
+  def remove_double_slash(first_tokens, second_tokens); end
+  def scheme_and_host; end
+
+  class << self
+    def apply(a, method, b, *args); end
+    def coerce(a, b); end
+    def coerce_first_arg(meth); end
+    def new(*args); end
+    def resolve_class(*args); end
+  end
+end
+
+module URITemplate::ClassMethods
+  def convert(x); end
+  def included(base); end
+  def try_convert(x); end
+end
+
+class URITemplate::Colon
+  include ::URITemplate
+  extend ::URITemplate::ClassMethods
+
+  def initialize(pattern); end
+
+  def extract(uri); end
+  def pattern; end
+  def to_r; end
+  def tokens; end
+  def type; end
+
+  protected
+
+  def tokenize!; end
+
+  class << self
+    def try_convert(x); end
+  end
+end
+
+class URITemplate::Colon::InvalidValue < ::StandardError
+  include ::URITemplate::InvalidValue
+
+  def initialize(variable, value); end
+
+  def value; end
+  def variable; end
+
+  protected
+
+  def generate_message; end
+end
+
+class URITemplate::Colon::InvalidValue::SplatIsNotAnArray < ::URITemplate::Colon::InvalidValue; end
+class URITemplate::Colon::Token; end
+
+class URITemplate::Colon::Token::Splat < ::URITemplate::Colon::Token::Variable
+  def initialize(index); end
+
+  def expand(vars); end
+  def index; end
+  def to_r; end
+end
+
+URITemplate::Colon::Token::Splat::SPLAT = T.let(T.unsafe(nil), String)
+
+class URITemplate::Colon::Token::Static < ::URITemplate::Colon::Token
+  include ::URITemplate::Token
+  include ::URITemplate::Literal
+
+  def initialize(str); end
+
+  def expand(_); end
+  def to_r; end
+end
+
+class URITemplate::Colon::Token::Variable < ::URITemplate::Colon::Token
+  include ::URITemplate::Token
+  include ::URITemplate::Expression
+
+  def initialize(name); end
+
+  def expand(vars); end
+  def name; end
+  def to_r; end
+  def to_s; end
+end
+
+URITemplate::Colon::VAR = T.let(T.unsafe(nil), Regexp)
+
+module URITemplate::Expression
+  include ::URITemplate::Token
+
+  def expression?; end
+  def literal?; end
+  def variables; end
+end
+
+URITemplate::HOST_REGEX = T.let(T.unsafe(nil), Regexp)
+module URITemplate::Invalid; end
+module URITemplate::InvalidValue; end
+
+module URITemplate::Literal
+  include ::URITemplate::Token
+
+  def ends_with_slash?; end
+  def expand(_); end
+  def expand_partial(_); end
+  def expression?; end
+  def literal?; end
+  def size; end
+  def starts_with_slash?; end
+  def string; end
+  def to_s; end
+end
+
+URITemplate::Literal::SLASH = T.let(T.unsafe(nil), String)
+
+class URITemplate::RFC6570
+  include ::URITemplate
+  extend ::URITemplate::ClassMethods
+  extend ::Forwardable
+  extend ::URITemplate::RFC6570::ClassMethods
+
+  def initialize(pattern_or_tokens, options = T.unsafe(nil)); end
+
+  def ===(*args, &block); end
+  def extract(uri_or_match, post_processing = T.unsafe(nil)); end
+  def extract_simple(uri_or_match); end
+  def level; end
+  def match(*args, &block); end
+  def options; end
+  def to_r; end
+  def tokens; end
+  def type; end
+
+  protected
+
+  def extract_matchdata(matchdata, post_processing); end
+  def tokenize!; end
+end
+
+URITemplate::RFC6570::CHARACTER_CLASSES = T.let(T.unsafe(nil), Hash)
+URITemplate::RFC6570::CONVERT_RESULT = T.let(T.unsafe(nil), Array)
+URITemplate::RFC6570::CONVERT_VALUES = T.let(T.unsafe(nil), Array)
+
+module URITemplate::RFC6570::ClassMethods
+  def try_convert(x); end
+  def valid?(pattern); end
+end
+
+URITemplate::RFC6570::DEFAULT_PROCESSING = T.let(T.unsafe(nil), Array)
+URITemplate::RFC6570::EXPRESSION = T.let(T.unsafe(nil), Regexp)
+
+class URITemplate::RFC6570::Expression < ::URITemplate::RFC6570::Token
+  include ::URITemplate::Token
+  include ::URITemplate::Expression
+  extend ::URITemplate::RFC6570::Expression::ClassMethods
+
+  def initialize(vars); end
+
+  def arity; end
+  def expand(vars); end
+  def expand_partial(vars); end
+  def extract(position, matched); end
+  def level; end
+  def to_s; end
+  def variables; end
+
+  protected
+
+  def cut(str, chars); end
+  def decode(x, split = T.unsafe(nil)); end
+  def empty_literals?(list); end
+  def escape(x); end
+  def pair(key, value, max_length = T.unsafe(nil), &block); end
+  def regex_builder; end
+  def transform_array(name, ary, expand, max_length); end
+  def transform_hash(name, hsh, expand, max_length); end
+  def unescape(x); end
+
+  private
+
+  def expand_one(name, value, expand, max_length); end
+  def extracted_nil; end
+  def length_limited?(max_length); end
+end
+
+URITemplate::RFC6570::Expression::BASE_LEVEL = T.let(T.unsafe(nil), Integer)
+class URITemplate::RFC6570::Expression::Basic < ::URITemplate::RFC6570::Expression::Unnamed; end
+URITemplate::RFC6570::Expression::Basic::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::Basic
+URITemplate::RFC6570::Expression::Basic::FOLLOW_UP = URITemplate::RFC6570::Expression::Basic
+URITemplate::RFC6570::Expression::CHARACTER_CLASS = T.let(T.unsafe(nil), Hash)
+URITemplate::RFC6570::Expression::COMMA = T.let(T.unsafe(nil), String)
+
+module URITemplate::RFC6570::Expression::ClassMethods
+  def generate_hash_extractor(max_length); end
+  def hash_extractor(max_length); end
+  def hash_extractors; end
+  def regex_builder; end
+end
+
+class URITemplate::RFC6570::Expression::FormQuery < ::URITemplate::RFC6570::Expression::Named; end
+URITemplate::RFC6570::Expression::FormQuery::BASE_LEVEL = T.let(T.unsafe(nil), Integer)
+URITemplate::RFC6570::Expression::FormQuery::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::FormQueryContinuation
+URITemplate::RFC6570::Expression::FormQuery::FOLLOW_UP = URITemplate::RFC6570::Expression::Basic
+URITemplate::RFC6570::Expression::FormQuery::OPERATOR = T.let(T.unsafe(nil), String)
+URITemplate::RFC6570::Expression::FormQuery::PREFIX = T.let(T.unsafe(nil), String)
+URITemplate::RFC6570::Expression::FormQuery::SEPARATOR = T.let(T.unsafe(nil), String)
+class URITemplate::RFC6570::Expression::FormQueryContinuation < ::URITemplate::RFC6570::Expression::Named; end
+URITemplate::RFC6570::Expression::FormQueryContinuation::BASE_LEVEL = T.let(T.unsafe(nil), Integer)
+URITemplate::RFC6570::Expression::FormQueryContinuation::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::FormQueryContinuation
+URITemplate::RFC6570::Expression::FormQueryContinuation::FOLLOW_UP = URITemplate::RFC6570::Expression::Basic
+URITemplate::RFC6570::Expression::FormQueryContinuation::OPERATOR = T.let(T.unsafe(nil), String)
+URITemplate::RFC6570::Expression::FormQueryContinuation::PREFIX = T.let(T.unsafe(nil), String)
+URITemplate::RFC6570::Expression::FormQueryContinuation::SEPARATOR = T.let(T.unsafe(nil), String)
+
+class URITemplate::RFC6570::Expression::Fragment < ::URITemplate::RFC6570::Expression::Unnamed
+  def escape(x); end
+  def unescape(x); end
+end
+
+URITemplate::RFC6570::Expression::Fragment::BASE_LEVEL = T.let(T.unsafe(nil), Integer)
+URITemplate::RFC6570::Expression::Fragment::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::Reserved
+URITemplate::RFC6570::Expression::Fragment::CHARACTER_CLASS = T.let(T.unsafe(nil), Hash)
+URITemplate::RFC6570::Expression::Fragment::FOLLOW_UP = URITemplate::RFC6570::Expression::Reserved
+URITemplate::RFC6570::Expression::Fragment::OPERATOR = T.let(T.unsafe(nil), String)
+URITemplate::RFC6570::Expression::Fragment::PREFIX = T.let(T.unsafe(nil), String)
+URITemplate::RFC6570::Expression::LIST_CONNECTOR = T.let(T.unsafe(nil), String)
+class URITemplate::RFC6570::Expression::Label < ::URITemplate::RFC6570::Expression::Unnamed; end
+URITemplate::RFC6570::Expression::Label::BASE_LEVEL = T.let(T.unsafe(nil), Integer)
+URITemplate::RFC6570::Expression::Label::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::Label
+URITemplate::RFC6570::Expression::Label::FOLLOW_UP = URITemplate::RFC6570::Expression::Label
+URITemplate::RFC6570::Expression::Label::OPERATOR = T.let(T.unsafe(nil), String)
+URITemplate::RFC6570::Expression::Label::PREFIX = T.let(T.unsafe(nil), String)
+URITemplate::RFC6570::Expression::Label::SEPARATOR = T.let(T.unsafe(nil), String)
+
+class URITemplate::RFC6570::Expression::Named < ::URITemplate::RFC6570::Expression
+  def expand_partial(vars); end
+  def to_r_source; end
+
+  protected
+
+  def self_pair(key, value, max_length = T.unsafe(nil), &block); end
+
+  private
+
+  def after_expand(name, splitted); end
+  def extracted_nil; end
+end
+
+URITemplate::RFC6570::Expression::OPERATOR = T.let(T.unsafe(nil), String)
+URITemplate::RFC6570::Expression::PAIR_CONNECTOR = T.let(T.unsafe(nil), String)
+URITemplate::RFC6570::Expression::PAIR_IF_EMPTY = T.let(T.unsafe(nil), TrueClass)
+URITemplate::RFC6570::Expression::PREFIX = T.let(T.unsafe(nil), String)
+
+class URITemplate::RFC6570::Expression::Path < ::URITemplate::RFC6570::Expression::Unnamed
+  def starts_with_slash?; end
+end
+
+URITemplate::RFC6570::Expression::Path::BASE_LEVEL = T.let(T.unsafe(nil), Integer)
+URITemplate::RFC6570::Expression::Path::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::Path
+URITemplate::RFC6570::Expression::Path::FOLLOW_UP = URITemplate::RFC6570::Expression::Path
+URITemplate::RFC6570::Expression::Path::OPERATOR = T.let(T.unsafe(nil), String)
+URITemplate::RFC6570::Expression::Path::PREFIX = T.let(T.unsafe(nil), String)
+URITemplate::RFC6570::Expression::Path::SEPARATOR = T.let(T.unsafe(nil), String)
+class URITemplate::RFC6570::Expression::PathParameters < ::URITemplate::RFC6570::Expression::Named; end
+URITemplate::RFC6570::Expression::PathParameters::BASE_LEVEL = T.let(T.unsafe(nil), Integer)
+URITemplate::RFC6570::Expression::PathParameters::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::PathParameters
+URITemplate::RFC6570::Expression::PathParameters::FOLLOW_UP = URITemplate::RFC6570::Expression::PathParameters
+URITemplate::RFC6570::Expression::PathParameters::OPERATOR = T.let(T.unsafe(nil), String)
+URITemplate::RFC6570::Expression::PathParameters::PREFIX = T.let(T.unsafe(nil), String)
+URITemplate::RFC6570::Expression::PathParameters::SEPARATOR = T.let(T.unsafe(nil), String)
+
+class URITemplate::RFC6570::Expression::Reserved < ::URITemplate::RFC6570::Expression::Unnamed
+  def escape(x); end
+  def host?; end
+  def scheme?; end
+  def unescape(x); end
+end
+
+URITemplate::RFC6570::Expression::Reserved::BASE_LEVEL = T.let(T.unsafe(nil), Integer)
+URITemplate::RFC6570::Expression::Reserved::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::Reserved
+URITemplate::RFC6570::Expression::Reserved::CHARACTER_CLASS = T.let(T.unsafe(nil), Hash)
+URITemplate::RFC6570::Expression::Reserved::FOLLOW_UP = URITemplate::RFC6570::Expression::Reserved
+URITemplate::RFC6570::Expression::Reserved::OPERATOR = T.let(T.unsafe(nil), String)
+URITemplate::RFC6570::Expression::SEPARATOR = T.let(T.unsafe(nil), String)
+URITemplate::RFC6570::Expression::SPLITTER = T.let(T.unsafe(nil), Regexp)
+
+class URITemplate::RFC6570::Expression::Unnamed < ::URITemplate::RFC6570::Expression
+  def self_pair(_, value, max_length = T.unsafe(nil), &block); end
+  def to_r_source; end
+
+  private
+
+  def after_expand(name, splitted); end
+  def transform_array(name, ary, expand, max_length); end
+  def transform_hash(name, hsh, expand, max_length); end
+end
+
+class URITemplate::RFC6570::Invalid < ::StandardError
+  include ::URITemplate::Invalid
+
+  def initialize(source, position); end
+
+  def pattern; end
+  def position; end
+end
+
+URITemplate::RFC6570::LITERAL = T.let(T.unsafe(nil), Regexp)
+
+class URITemplate::RFC6570::Literal < ::URITemplate::RFC6570::Token
+  include ::URITemplate::Token
+  include ::URITemplate::Literal
+
+  def initialize(string); end
+
+  def level; end
+  def to_r_source(*_); end
+  def to_s; end
+end
+
+URITemplate::RFC6570::NO_PROCESSING = T.let(T.unsafe(nil), Array)
+URITemplate::RFC6570::OPERATORS = T.let(T.unsafe(nil), Hash)
+
+class URITemplate::RFC6570::RegexBuilder
+  def initialize(expression_class); end
+
+  def <<(arg); end
+  def capture(&block); end
+  def character_class(max_length = T.unsafe(nil), min = T.unsafe(nil)); end
+  def character_class_with_comma(max_length = T.unsafe(nil), min = T.unsafe(nil)); end
+  def escaped_pair_connector; end
+  def escaped_prefix; end
+  def escaped_separator; end
+  def group(capture = T.unsafe(nil)); end
+  def join; end
+  def length(*args); end
+  def lookahead; end
+  def negative_lookahead; end
+  def push(*args); end
+  def reluctant; end
+  def separated_list(first = T.unsafe(nil), length = T.unsafe(nil), min = T.unsafe(nil), &block); end
+
+  private
+
+  def format_length(len, min = T.unsafe(nil)); end
+end
+
+URITemplate::RFC6570::TYPE = T.let(T.unsafe(nil), Symbol)
+class URITemplate::RFC6570::Token; end
+
+class URITemplate::RFC6570::Tokenizer
+  include ::Enumerable
+
+  def initialize(source, ops); end
+
+  def each; end
+  def source; end
+end
+
+URITemplate::RFC6570::URI = T.let(T.unsafe(nil), Regexp)
+
+module URITemplate::RFC6570::Utils
+  include ::URITemplate::Utils::StringEncoding::Encode
+  include ::URITemplate::Utils::StringEncoding
+  include ::URITemplate::Utils::Escaping::Pure
+  include ::URITemplate::Utils
+  extend ::URITemplate::Utils::StringEncoding::Encode
+  extend ::URITemplate::Utils::StringEncoding
+  extend ::URITemplate::Utils::Escaping::Pure
+  extend ::URITemplate::Utils
+  extend ::URITemplate::RFC6570::Utils
+
+  def def?(value); end
+end
+
+URITemplate::RFC6570::VAR = T.let(T.unsafe(nil), Regexp)
+
+class URITemplate::RegexpEnumerator
+  include ::Enumerable
+
+  def initialize(regexp, options = T.unsafe(nil)); end
+
+  def each(str); end
+end
+
+URITemplate::SCHEME_REGEX = T.let(T.unsafe(nil), Regexp)
+
+module URITemplate::Token
+  def ends_with_slash?; end
+  def expand(variables); end
+  def expand_partial(variables); end
+  def host?; end
+  def scheme?; end
+  def size; end
+  def starts_with_slash?; end
+  def to_s; end
+  def variables; end
+end
+
+URITemplate::Token::EMPTY_ARRAY = T.let(T.unsafe(nil), Array)
+URITemplate::URI_SPLIT = T.let(T.unsafe(nil), Regexp)
+
+class URITemplate::Unconvertable < ::StandardError
+  def initialize(object); end
+
+  def object; end
+end
+
+module URITemplate::Utils
+  include ::URITemplate::Utils::StringEncoding::Encode
+  include ::URITemplate::Utils::StringEncoding
+  include ::URITemplate::Utils::Escaping::Pure
+  extend ::URITemplate::Utils::StringEncoding::Encode
+  extend ::URITemplate::Utils::StringEncoding
+  extend ::URITemplate::Utils::Escaping::Pure
+  extend ::URITemplate::Utils
+
+  def compact_regexp(rx); end
+  def object_to_param(object); end
+  def pair_array?(a); end
+  def pair_array_to_hash(x, careful = T.unsafe(nil)); end
+  def pair_array_to_hash2(x); end
+  def use_unicode?; end
+end
+
+module URITemplate::Utils::Escaping; end
+
+module URITemplate::Utils::Escaping::Pure
+  def escape_uri(s); end
+  def escape_url(s); end
+  def unescape_uri(s); end
+  def unescape_url(s); end
+  def using_escape_utils?; end
+end
+
+URITemplate::Utils::Escaping::Pure::PCT = T.let(T.unsafe(nil), Regexp)
+URITemplate::Utils::Escaping::Pure::URI_ESCAPED = T.let(T.unsafe(nil), Regexp)
+URITemplate::Utils::Escaping::Pure::URL_ESCAPED = T.let(T.unsafe(nil), Regexp)
+URITemplate::Utils::KCODE_UTF8 = T.let(T.unsafe(nil), Integer)
+
+module URITemplate::Utils::StringEncoding
+  include ::URITemplate::Utils::StringEncoding::Encode
+end
+
+module URITemplate::Utils::StringEncoding::Encode
+  def force_utf8(str); end
+  def to_ascii(str); end
+  def to_utf8(str); end
+end
+
+module URITemplate::Utils::StringEncoding::Fallback
+  def force_utf8(str); end
+  def to_ascii(str); end
+  def to_utf8(str); end
+end
+
+URITemplate::VERSIONS = T.let(T.unsafe(nil), Hash)
diff --git a/Library/Homebrew/sorbet/rbi/gems/warning@1.2.0.rbi b/Library/Homebrew/sorbet/rbi/gems/warning@1.2.0.rbi
index e75b6f9072..6862bf0650 100644
--- a/Library/Homebrew/sorbet/rbi/gems/warning@1.2.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/warning@1.2.0.rbi
@@ -1,8 +1,27 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `warning` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module Warning
+  extend ::Warning
+  extend ::Warning::Processor
+end
+
+module Warning::Processor
+  def clear; end
+  def dedup; end
+  def freeze; end
+  def ignore(regexp, path = T.unsafe(nil)); end
+  def process(path = T.unsafe(nil), actions = T.unsafe(nil), &block); end
+  def warn(str); end
+
+  private
+
+  def convert_regexp(regexp); end
+  def synchronize(&block); end
+end
+
+Warning::Processor::ACTION_PROC_MAP = T.let(T.unsafe(nil), Hash)
+Warning::Processor::IGNORE_MAP = T.let(T.unsafe(nil), Hash)
diff --git a/Library/Homebrew/sorbet/rbi/gems/webrick@1.7.0.rbi b/Library/Homebrew/sorbet/rbi/gems/webrick@1.7.0.rbi
index 7faa132a2b..143e644d1b 100644
--- a/Library/Homebrew/sorbet/rbi/gems/webrick@1.7.0.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/webrick@1.7.0.rbi
@@ -1,11 +1,490 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `webrick` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-module WEBrick::HTTPUtils
+module WEBrick::AccessLog
+  private
 
+  def escape(data); end
+  def format(format_string, params); end
+  def setup_params(config, req, res); end
+
+  class << self
+    def escape(data); end
+    def format(format_string, params); end
+    def setup_params(config, req, res); end
+  end
+end
+
+class WEBrick::BasicLog
+  def initialize(log_file = T.unsafe(nil), level = T.unsafe(nil)); end
+
+  def <<(obj); end
+  def close; end
+  def debug(msg); end
+  def debug?; end
+  def error(msg); end
+  def error?; end
+  def fatal(msg); end
+  def fatal?; end
+  def info(msg); end
+  def info?; end
+  def level; end
+  def level=(_arg0); end
+  def log(level, data); end
+  def warn(msg); end
+  def warn?; end
+
+  private
+
+  def format(arg); end
+end
+
+class WEBrick::GenericServer
+  def initialize(config = T.unsafe(nil), default = T.unsafe(nil)); end
+
+  def [](key); end
+  def config; end
+  def listen(address, port); end
+  def listeners; end
+  def logger; end
+  def run(sock); end
+  def shutdown; end
+  def start(&block); end
+  def status; end
+  def stop; end
+  def tokens; end
+
+  private
+
+  def accept_client(svr); end
+  def alarm_shutdown_pipe; end
+  def call_callback(callback_name, *args); end
+  def cleanup_listener; end
+  def cleanup_shutdown_pipe(shutdown_pipe); end
+  def setup_shutdown_pipe; end
+  def start_thread(sock, &block); end
+end
+
+module WEBrick::HTMLUtils
+  private
+
+  def escape(string); end
+
+  class << self
+    def escape(string); end
+  end
+end
+
+module WEBrick::HTTPAuth
+  private
+
+  def _basic_auth(req, res, realm, req_field, res_field, err_type, block); end
+  def basic_auth(req, res, realm, &block); end
+  def proxy_basic_auth(req, res, realm, &block); end
+
+  class << self
+    def _basic_auth(req, res, realm, req_field, res_field, err_type, block); end
+    def basic_auth(req, res, realm, &block); end
+    def proxy_basic_auth(req, res, realm, &block); end
+  end
+end
+
+module WEBrick::HTTPAuth::Authenticator
+  def logger; end
+  def realm; end
+  def userdb; end
+
+  private
+
+  def check_init(config); end
+  def check_scheme(req); end
+  def error(fmt, *args); end
+  def info(fmt, *args); end
+  def log(meth, fmt, *args); end
+end
+
+WEBrick::HTTPAuth::Authenticator::AuthException = WEBrick::HTTPStatus::Unauthorized
+
+class WEBrick::HTTPAuth::BasicAuth
+  include ::WEBrick::HTTPAuth::Authenticator
+
+  def initialize(config, default = T.unsafe(nil)); end
+
+  def authenticate(req, res); end
+  def challenge(req, res); end
+  def logger; end
+  def realm; end
+  def userdb; end
+
+  class << self
+    def make_passwd(realm, user, pass); end
+  end
+end
+
+class WEBrick::HTTPAuth::DigestAuth
+  include ::WEBrick::HTTPAuth::Authenticator
+
+  def initialize(config, default = T.unsafe(nil)); end
+
+  def algorithm; end
+  def authenticate(req, res); end
+  def challenge(req, res, stale = T.unsafe(nil)); end
+  def qop; end
+
+  private
+
+  def _authenticate(req, res); end
+  def check_nonce(req, auth_req); end
+  def check_opaque(opaque_struct, req, auth_req); end
+  def check_uri(req, auth_req); end
+  def generate_next_nonce(req); end
+  def generate_opaque(req); end
+  def hexdigest(*args); end
+  def split_param_value(string); end
+
+  class << self
+    def make_passwd(realm, user, pass); end
+  end
+end
+
+class WEBrick::HTTPAuth::DigestAuth::OpaqueInfo < ::Struct
+  def nc=(_); end
+  def nonce=(_); end
+  def time=(_); end
+end
+
+class WEBrick::HTTPAuth::Htdigest
+  include ::WEBrick::HTTPAuth::UserDB
+
+  def initialize(path); end
+
+  def delete_passwd(realm, user); end
+  def each; end
+  def flush(output = T.unsafe(nil)); end
+  def get_passwd(realm, user, reload_db); end
+  def reload; end
+  def set_passwd(realm, user, pass); end
+end
+
+class WEBrick::HTTPAuth::Htgroup
+  def initialize(path); end
+
+  def add(group, members); end
+  def flush(output = T.unsafe(nil)); end
+  def members(group); end
+  def reload; end
+end
+
+class WEBrick::HTTPAuth::Htpasswd
+  include ::WEBrick::HTTPAuth::UserDB
+
+  def initialize(path, password_hash: T.unsafe(nil)); end
+
+  def delete_passwd(realm, user); end
+  def each; end
+  def flush(output = T.unsafe(nil)); end
+  def get_passwd(realm, user, reload_db); end
+  def reload; end
+  def set_passwd(realm, user, pass); end
+end
+
+WEBrick::HTTPAuth::ProxyAuthenticator::AuthException = WEBrick::HTTPStatus::ProxyAuthenticationRequired
+
+class WEBrick::HTTPAuth::ProxyBasicAuth < ::WEBrick::HTTPAuth::BasicAuth
+  include ::WEBrick::HTTPAuth::ProxyAuthenticator
+end
+
+class WEBrick::HTTPAuth::ProxyDigestAuth < ::WEBrick::HTTPAuth::DigestAuth
+  include ::WEBrick::HTTPAuth::ProxyAuthenticator
+
+  private
+
+  def check_uri(req, auth_req); end
+end
+
+module WEBrick::HTTPAuth::UserDB
+  def auth_type; end
+  def auth_type=(_arg0); end
+  def get_passwd(realm, user, reload_db = T.unsafe(nil)); end
+  def make_passwd(realm, user, pass); end
+  def set_passwd(realm, user, pass); end
+end
+
+class WEBrick::HTTPRequest
+  def initialize(config); end
+
+  def [](header_name); end
+  def accept; end
+  def accept_charset; end
+  def accept_encoding; end
+  def accept_language; end
+  def addr; end
+  def attributes; end
+  def body(&block); end
+  def body_reader; end
+  def content_length; end
+  def content_type; end
+  def continue; end
+  def cookies; end
+  def each; end
+  def fixup; end
+  def header; end
+  def host; end
+  def http_version; end
+  def keep_alive; end
+  def keep_alive?; end
+  def meta_vars; end
+  def parse(socket = T.unsafe(nil)); end
+  def path; end
+  def path_info; end
+  def path_info=(_arg0); end
+  def peeraddr; end
+  def port; end
+  def query; end
+  def query_string; end
+  def query_string=(_arg0); end
+  def raw_header; end
+  def readpartial(size, buf = T.unsafe(nil)); end
+  def remote_ip; end
+  def request_line; end
+  def request_method; end
+  def request_time; end
+  def request_uri; end
+  def script_name; end
+  def script_name=(_arg0); end
+  def server_name; end
+  def ssl?; end
+  def to_s; end
+  def unparsed_uri; end
+  def user; end
+  def user=(_arg0); end
+
+  private
+
+  def _read_data(io, method, *arg); end
+  def parse_query; end
+  def parse_uri(str, scheme = T.unsafe(nil)); end
+  def read_body(socket, block); end
+  def read_chunk_size(socket); end
+  def read_chunked(socket, block); end
+  def read_data(io, size); end
+  def read_header(socket); end
+  def read_line(io, size = T.unsafe(nil)); end
+  def read_request_line(socket); end
+  def setup_forwarded_info; end
+end
+
+WEBrick::HTTPRequest::MAX_HEADER_LENGTH = T.let(T.unsafe(nil), Integer)
+
+class WEBrick::HTTPResponse
+  def initialize(config); end
+
+  def [](field); end
+  def []=(field, value); end
+  def _rack_setup_header; end
+  def body; end
+  def body=(_arg0); end
+  def chunked=(val); end
+  def chunked?; end
+  def config; end
+  def content_length; end
+  def content_length=(len); end
+  def content_type; end
+  def content_type=(type); end
+  def cookies; end
+  def each; end
+  def filename; end
+  def filename=(_arg0); end
+  def header; end
+  def http_version; end
+  def keep_alive; end
+  def keep_alive=(_arg0); end
+  def keep_alive?; end
+  def make_body_tempfile; end
+  def reason_phrase; end
+  def reason_phrase=(_arg0); end
+  def remove_body_tempfile; end
+  def request_http_version; end
+  def request_http_version=(_arg0); end
+  def request_method; end
+  def request_method=(_arg0); end
+  def request_uri; end
+  def request_uri=(_arg0); end
+  def send_body(socket); end
+  def send_header(socket); end
+  def send_response(socket); end
+  def sent_size; end
+  def set_error(ex, backtrace = T.unsafe(nil)); end
+  def set_redirect(status, url); end
+  def status; end
+  def status=(status); end
+  def status_line; end
+
+  private
+
+  def _write_data(socket, data); end
+  def check_header(header_value); end
+  def error_body(backtrace, ex, host, port); end
+  def send_body_io(socket); end
+  def send_body_proc(socket); end
+  def send_body_string(socket); end
+end
+
+class WEBrick::HTTPResponse::ChunkedWrapper
+  def initialize(socket, resp); end
+
+  def <<(*buf); end
+  def write(buf); end
+end
+
+class WEBrick::HTTPServer < ::WEBrick::GenericServer
+  def initialize(config = T.unsafe(nil), default = T.unsafe(nil)); end
+
+  def access_log(config, req, res); end
+  def create_request(with_webrick_config); end
+  def create_response(with_webrick_config); end
+  def do_OPTIONS(req, res); end
+  def lookup_server(req); end
+  def mount(dir, servlet, *options); end
+  def mount_proc(dir, proc = T.unsafe(nil), &block); end
+  def run(sock); end
+  def search_servlet(path); end
+  def service(req, res); end
+  def umount(dir); end
+  def unmount(dir); end
+  def virtual_host(server); end
+end
+
+class WEBrick::HTTPServer::MountTable
+  def initialize; end
+
+  def [](dir); end
+  def []=(dir, val); end
+  def delete(dir); end
+  def scan(path); end
+
+  private
+
+  def compile; end
+  def normalize(dir); end
+end
+
+class WEBrick::HTTPServlet::AbstractServlet
+  def initialize(server, *options); end
+
+  def do_GET(req, res); end
+  def do_HEAD(req, res); end
+  def do_OPTIONS(req, res); end
+  def service(req, res); end
+
+  private
+
+  def redirect_to_directory_uri(req, res); end
+
+  class << self
+    def get_instance(server, *options); end
+  end
+end
+
+class WEBrick::HTTPServlet::CGIHandler < ::WEBrick::HTTPServlet::AbstractServlet
+  def initialize(server, name); end
+
+  def do_GET(req, res); end
+  def do_POST(req, res); end
+end
+
+WEBrick::HTTPServlet::CGIHandler::CGIRunnerArray = T.let(T.unsafe(nil), Array)
+
+class WEBrick::HTTPServlet::DefaultFileHandler < ::WEBrick::HTTPServlet::AbstractServlet
+  def initialize(server, local_path); end
+
+  def do_GET(req, res); end
+  def make_partial_content(req, res, filename, filesize); end
+  def multipart_body(body, parts, boundary, mtype, filesize); end
+  def not_modified?(req, res, mtime, etag); end
+  def prepare_range(range, filesize); end
+end
+
+class WEBrick::HTTPServlet::ERBHandler < ::WEBrick::HTTPServlet::AbstractServlet
+  def initialize(server, name); end
+
+  def do_GET(req, res); end
+  def do_POST(req, res); end
+
+  private
+
+  def evaluate(erb, servlet_request, servlet_response); end
+end
+
+class WEBrick::HTTPServlet::FileHandler < ::WEBrick::HTTPServlet::AbstractServlet
+  def initialize(server, root, options = T.unsafe(nil), default = T.unsafe(nil)); end
+
+  def do_GET(req, res); end
+  def do_OPTIONS(req, res); end
+  def do_POST(req, res); end
+  def service(req, res); end
+  def set_filesystem_encoding(str); end
+
+  private
+
+  def call_callback(callback_name, req, res); end
+  def check_filename(req, res, name); end
+  def exec_handler(req, res); end
+  def get_handler(req, res); end
+  def nondisclosure_name?(name); end
+  def prevent_directory_traversal(req, res); end
+  def search_file(req, res, basename); end
+  def search_index_file(req, res); end
+  def set_dir_list(req, res); end
+  def set_filename(req, res); end
+  def shift_path_info(req, res, path_info, base = T.unsafe(nil)); end
+  def trailing_pathsep?(path); end
+  def windows_ambiguous_name?(name); end
+
+  class << self
+    def add_handler(suffix, handler); end
+    def remove_handler(suffix); end
+  end
+end
+
+module WEBrick::HTTPStatus
+  private
+
+  def client_error?(code); end
+  def error?(code); end
+  def info?(code); end
+  def reason_phrase(code); end
+  def redirect?(code); end
+  def server_error?(code); end
+  def success?(code); end
+
+  class << self
+    def [](code); end
+    def client_error?(code); end
+    def error?(code); end
+    def info?(code); end
+    def reason_phrase(code); end
+    def redirect?(code); end
+    def server_error?(code); end
+    def success?(code); end
+  end
+end
+
+class WEBrick::HTTPStatus::Status < ::StandardError
+  def code; end
+  def reason_phrase; end
+  def to_i; end
+
+  class << self
+    def code; end
+    def reason_phrase; end
+  end
+end
+
+module WEBrick::HTTPUtils
   private
 
   def _escape(str, regex); end
@@ -75,3 +554,48 @@ class WEBrick::HTTPUtils::FormData < ::String
 
   def next_data; end
 end
+
+module WEBrick::Utils
+  private
+
+  def create_listeners(address, port); end
+  def getservername; end
+  def random_string(len); end
+  def set_close_on_exec(io); end
+  def set_non_blocking(io); end
+  def su(user); end
+  def timeout(seconds, exception = T.unsafe(nil)); end
+
+  class << self
+    def create_listeners(address, port); end
+    def getservername; end
+    def random_string(len); end
+    def set_close_on_exec(io); end
+    def set_non_blocking(io); end
+    def su(user); end
+    def timeout(seconds, exception = T.unsafe(nil)); end
+  end
+end
+
+class WEBrick::Utils::TimeoutHandler
+  include ::Singleton
+  extend ::Singleton::SingletonClassMethods
+
+  def initialize; end
+
+  def cancel(thread, id); end
+  def interrupt(thread, id, exception); end
+  def register(thread, time, exception); end
+  def terminate; end
+
+  private
+
+  def watch; end
+  def watcher; end
+
+  class << self
+    def cancel(id); end
+    def register(seconds, exception); end
+    def terminate; end
+  end
+end
diff --git a/Library/Homebrew/sorbet/rbi/gems/webrobots@0.1.2.rbi b/Library/Homebrew/sorbet/rbi/gems/webrobots@0.1.2.rbi
index ce20390b7d..d0f499674f 100644
--- a/Library/Homebrew/sorbet/rbi/gems/webrobots@0.1.2.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/webrobots@0.1.2.rbi
@@ -1,6 +1,6 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `webrobots` gem.
-# Please instead update this file by running `tapioca generate --exclude json`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
@@ -23,10 +23,10 @@ class Nokogiri::HTML::Document < ::Nokogiri::XML::Document
   def set_metadata_element(element); end
 
   class << self
-    def new(*_); end
+    def new(*_arg0); end
     def parse(string_or_io, url = T.unsafe(nil), encoding = T.unsafe(nil), options = T.unsafe(nil)); end
-    def read_io(_, _, _, _); end
-    def read_memory(_, _, _, _); end
+    def read_io(_arg0, _arg1, _arg2, _arg3); end
+    def read_memory(_arg0, _arg1, _arg2, _arg3); end
   end
 end
 
@@ -56,8 +56,7 @@ class WebRobots
   def split_uri(url); end
 end
 
-class WebRobots::Error < ::StandardError
-end
+class WebRobots::Error < ::StandardError; end
 
 class WebRobots::ParseError < ::WebRobots::Error
   def initialize(message, site); end
@@ -73,7 +72,7 @@ class WebRobots::RobotsTxt
   def crawl_delay(user_agent = T.unsafe(nil)); end
   def error; end
   def error!; end
-  def error=(_); end
+  def error=(_arg0); end
   def options(user_agent = T.unsafe(nil)); end
   def site; end
   def sitemaps; end
@@ -114,8 +113,7 @@ class WebRobots::RobotsTxt::DisallowLine < ::WebRobots::RobotsTxt::AccessControl
   def allow?; end
 end
 
-class WebRobots::RobotsTxt::ExtentionLine < ::WebRobots::RobotsTxt::Line
-end
+class WebRobots::RobotsTxt::ExtentionLine < ::WebRobots::RobotsTxt::Line; end
 
 class WebRobots::RobotsTxt::Line
   def initialize(token, value); end
@@ -154,11 +152,8 @@ class WebRobots::RobotsTxt::Parser < ::Racc::Parser
 end
 
 WebRobots::RobotsTxt::Parser::KNOWN_TOKENS = T.let(T.unsafe(nil), Array)
-
 WebRobots::RobotsTxt::Parser::RE_KNOWN_TOKENS = T.let(T.unsafe(nil), Regexp)
-
 WebRobots::RobotsTxt::Parser::Racc_arg = T.let(T.unsafe(nil), Array)
-
 WebRobots::RobotsTxt::Parser::Racc_token_to_s_table = T.let(T.unsafe(nil), Array)
 
 class WebRobots::RobotsTxt::Record
@@ -171,7 +166,5 @@ class WebRobots::RobotsTxt::Record
   def options; end
 end
 
-module Webrobots
-end
-
+module Webrobots; end
 Webrobots::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/zeitwerk@2.4.2.rbi b/Library/Homebrew/sorbet/rbi/gems/zeitwerk@2.4.2.rbi
index 1843429730..929fa8a3b7 100644
--- a/Library/Homebrew/sorbet/rbi/gems/zeitwerk@2.4.2.rbi
+++ b/Library/Homebrew/sorbet/rbi/gems/zeitwerk@2.4.2.rbi
@@ -1,8 +1,175 @@
 # DO NOT EDIT MANUALLY
 # This is an autogenerated file for types exported from the `zeitwerk` gem.
-# Please instead update this file by running `tapioca sync`.
+# Please instead update this file by running `bin/tapioca sync`.
 
 # typed: true
 
-# THIS IS AN EMPTY RBI FILE.
-# see https://github.com/Shopify/tapioca/blob/master/README.md#manual-gem-requires
+module Kernel
+  extend ::Forwardable
+
+  private
+
+  def require(path); end
+
+  class << self
+    def require(path); end
+  end
+end
+
+module Zeitwerk; end
+class Zeitwerk::Error < ::StandardError; end
+
+module Zeitwerk::ExplicitNamespace
+  extend ::Zeitwerk::RealModName
+
+  class << self
+    def cpaths; end
+    def mutex; end
+    def register(cpath, loader); end
+    def tracer; end
+    def unregister(loader); end
+
+    private
+
+    def disable_tracer_if_unneeded; end
+    def tracepoint_class_callback(event); end
+  end
+end
+
+class Zeitwerk::GemInflector < ::Zeitwerk::Inflector
+  def initialize(root_file); end
+
+  def camelize(basename, abspath); end
+end
+
+class Zeitwerk::Inflector
+  def camelize(basename, _abspath); end
+  def inflect(inflections); end
+
+  private
+
+  def overrides; end
+end
+
+class Zeitwerk::Loader
+  include ::Zeitwerk::RealModName
+  include ::Zeitwerk::Loader::Callbacks
+
+  def initialize; end
+
+  def autoloaded_dirs; end
+  def autoloads; end
+  def collapse(*glob_patterns); end
+  def collapse_dirs; end
+  def collapse_glob_patterns; end
+  def dirs; end
+  def do_not_eager_load(*paths); end
+  def eager_load; end
+  def eager_load_exclusions; end
+  def enable_reloading; end
+  def ignore(*glob_patterns); end
+  def ignored_glob_patterns; end
+  def ignored_paths; end
+  def inflector; end
+  def inflector=(_arg0); end
+  def lazy_subdirs; end
+  def log!; end
+  def logger; end
+  def logger=(_arg0); end
+  def manages?(dir); end
+  def mutex; end
+  def mutex2; end
+  def on_load(cpath, &block); end
+  def on_load_callbacks; end
+  def preload(*paths); end
+  def preloads; end
+  def push_dir(path, namespace: T.unsafe(nil)); end
+  def reload; end
+  def reloading_enabled?; end
+  def root_dirs; end
+  def setup; end
+  def tag; end
+  def tag=(tag); end
+  def to_unload; end
+  def unload; end
+  def unloadable_cpath?(cpath); end
+  def unloadable_cpaths; end
+
+  private
+
+  def actual_root_dirs; end
+  def autoload_file(parent, cname, file); end
+  def autoload_for?(parent, cname); end
+  def autoload_subdir(parent, cname, subdir); end
+  def cdef?(parent, cname); end
+  def cpath(parent, cname); end
+  def dir?(path); end
+  def do_preload; end
+  def do_preload_abspath(abspath); end
+  def do_preload_dir(dir); end
+  def do_preload_file(file); end
+  def expand_glob_patterns(glob_patterns); end
+  def expand_paths(paths); end
+  def log(message); end
+  def ls(dir); end
+  def promote_namespace_from_implicit_to_explicit(dir:, file:, parent:, cname:); end
+  def raise_if_conflicting_directory(dir); end
+  def recompute_collapse_dirs; end
+  def recompute_ignored_paths; end
+  def register_explicit_namespace(cpath); end
+  def ruby?(path); end
+  def set_autoload(parent, cname, abspath); end
+  def set_autoloads_in_dir(dir, parent); end
+  def strict_autoload_path(parent, cname); end
+  def unload_autoload(parent, cname); end
+  def unload_cref(parent, cname); end
+
+  class << self
+    def all_dirs; end
+    def default_logger; end
+    def default_logger=(_arg0); end
+    def eager_load_all; end
+    def for_gem; end
+    def mutex; end
+    def mutex=(_arg0); end
+  end
+end
+
+module Zeitwerk::Loader::Callbacks
+  include ::Zeitwerk::RealModName
+
+  def on_dir_autoloaded(dir); end
+  def on_file_autoloaded(file); end
+  def on_namespace_loaded(namespace); end
+
+  private
+
+  def run_on_load_callbacks(cpath); end
+end
+
+class Zeitwerk::NameError < ::NameError; end
+
+module Zeitwerk::RealModName
+  def real_mod_name(mod); end
+end
+
+Zeitwerk::RealModName::UNBOUND_METHOD_MODULE_NAME = T.let(T.unsafe(nil), UnboundMethod)
+
+module Zeitwerk::Registry
+  class << self
+    def autoloads; end
+    def inception?(cpath); end
+    def inceptions; end
+    def loader_for(path); end
+    def loader_for_gem(root_file); end
+    def loaders; end
+    def loaders_managing_gems; end
+    def on_unload(loader); end
+    def register_autoload(loader, realpath); end
+    def register_inception(cpath, realpath, loader); end
+    def register_loader(loader); end
+    def unregister_autoload(realpath); end
+  end
+end
+
+class Zeitwerk::ReloadingDisabledError < ::Zeitwerk::Error; end
diff --git a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
index 2bce71f107..4d1b1c6eb3 100644
--- a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
+++ b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi
@@ -16,2690 +16,25 @@ module ActiveSupport
   def parse_json_times(); end
 
   def parse_json_times=(val); end
-
-  def test_order(); end
-
-  def test_order=(val); end
-end
-
-module ActiveSupport::ActionableError
-end
-
-module ActiveSupport::ActionableError::ClassMethods
-  def action(name, &block); end
-end
-
-module ActiveSupport::ActionableError::ClassMethods
-end
-
-class ActiveSupport::ActionableError::NonActionable
-end
-
-class ActiveSupport::ActionableError::NonActionable
-end
-
-module ActiveSupport::ActionableError
-  extend ::ActiveSupport::Concern
-  def self.actions(error); end
-
-  def self.dispatch(error, name); end
-end
-
-class ActiveSupport::ArrayInquirer
-  def any?(*candidates); end
-end
-
-class ActiveSupport::ArrayInquirer
-end
-
-module ActiveSupport::Autoload
-  def autoload(const_name, path=T.unsafe(nil)); end
-
-  def autoload_at(path); end
-
-  def autoload_under(path); end
-
-  def autoloads(); end
-
-  def eager_autoload(); end
-
-  def eager_load!(); end
-end
-
-module ActiveSupport::Autoload
-  def self.extended(base); end
-end
-
-class ActiveSupport::BacktraceCleaner
-  def add_filter(&block); end
-
-  def add_silencer(&block); end
-
-  def clean(backtrace, kind=T.unsafe(nil)); end
-
-  def filter(backtrace, kind=T.unsafe(nil)); end
-
-  def remove_filters!(); end
-
-  def remove_silencers!(); end
-  FORMATTED_GEMS_PATTERN = ::T.let(nil, ::T.untyped)
-end
-
-class ActiveSupport::BacktraceCleaner
-end
-
-module ActiveSupport::Benchmarkable
-  def benchmark(message=T.unsafe(nil), options=T.unsafe(nil)); end
-end
-
-module ActiveSupport::Benchmarkable
-end
-
-module ActiveSupport::Cache
-  UNIVERSAL_OPTIONS = ::T.let(nil, ::T.untyped)
-end
-
-class ActiveSupport::Cache::Entry
-  def bytesize(); end
-
-  def dup_value!(); end
-
-  def expired?(); end
-
-  def expires_at(); end
-
-  def expires_at=(value); end
-
-  def initialize(value, compress: T.unsafe(nil), compress_threshold: T.unsafe(nil), version: T.unsafe(nil), expires_in: T.unsafe(nil), **arg); end
-
-  def mismatched?(version); end
-
-  def value(); end
-
-  def version(); end
-  DEFAULT_COMPRESS_LIMIT = ::T.let(nil, ::T.untyped)
-end
-
-class ActiveSupport::Cache::Entry
-end
-
-class ActiveSupport::Cache::FileStore
-  include ::ActiveSupport::Cache::Strategy::LocalCache
-  def cache_path(); end
-
-  def initialize(cache_path, **options); end
-  DIR_FORMATTER = ::T.let(nil, ::T.untyped)
-  FILENAME_MAX_SIZE = ::T.let(nil, ::T.untyped)
-  FILEPATH_MAX_SIZE = ::T.let(nil, ::T.untyped)
-  GITKEEP_FILES = ::T.let(nil, ::T.untyped)
-end
-
-class ActiveSupport::Cache::FileStore
-  def self.supports_cache_versioning?(); end
-end
-
-class ActiveSupport::Cache::MemoryStore
-  def prune(target_size, max_time=T.unsafe(nil)); end
-
-  def pruning?(); end
-
-  def synchronize(&block); end
-  PER_ENTRY_OVERHEAD = ::T.let(nil, ::T.untyped)
-end
-
-ActiveSupport::Cache::MemoryStore::DEFAULT_CODER = ActiveSupport::Cache::MemoryStore::DupCoder
-
-module ActiveSupport::Cache::MemoryStore::DupCoder
-end
-
-module ActiveSupport::Cache::MemoryStore::DupCoder
-  def self.dump(entry); end
-
-  def self.load(entry); end
-end
-
-class ActiveSupport::Cache::MemoryStore
-  def self.supports_cache_versioning?(); end
-end
-
-module ActiveSupport::Cache::NullCoder
-end
-
-module ActiveSupport::Cache::NullCoder
-  def self.dump(entry); end
-
-  def self.load(payload); end
-end
-
-class ActiveSupport::Cache::NullStore
-  include ::ActiveSupport::Cache::Strategy::LocalCache
-end
-
-class ActiveSupport::Cache::NullStore
-  def self.supports_cache_versioning?(); end
-end
-
-class ActiveSupport::Cache::Store
-  def cleanup(options=T.unsafe(nil)); end
-
-  def clear(options=T.unsafe(nil)); end
-
-  def decrement(name, amount=T.unsafe(nil), options=T.unsafe(nil)); end
-
-  def delete(name, options=T.unsafe(nil)); end
-
-  def delete_matched(matcher, options=T.unsafe(nil)); end
-
-  def delete_multi(names, options=T.unsafe(nil)); end
-
-  def exist?(name, options=T.unsafe(nil)); end
-
-  def fetch(name, options=T.unsafe(nil), &block); end
-
-  def fetch_multi(*names); end
-
-  def increment(name, amount=T.unsafe(nil), options=T.unsafe(nil)); end
-
-  def initialize(options=T.unsafe(nil)); end
-
-  def logger(); end
-
-  def logger=(val); end
-
-  def mute(); end
-
-  def options(); end
-
-  def read(name, options=T.unsafe(nil)); end
-
-  def read_multi(*names); end
-
-  def silence(); end
-
-  def silence!(); end
-
-  def silence?(); end
-
-  def write(name, value, options=T.unsafe(nil)); end
-
-  def write_multi(hash, options=T.unsafe(nil)); end
-end
-
-ActiveSupport::Cache::Store::DEFAULT_CODER = Marshal
-
-class ActiveSupport::Cache::Store
-  def self.logger(); end
-
-  def self.logger=(val); end
-end
-
-module ActiveSupport::Cache::Strategy
-end
-
-module ActiveSupport::Cache::Strategy::LocalCache
-  def cleanup(**options); end
-
-  def clear(**options); end
-
-  def decrement(name, amount=T.unsafe(nil), **options); end
-
-  def delete_matched(matcher, options=T.unsafe(nil)); end
-
-  def increment(name, amount=T.unsafe(nil), **options); end
-
-  def middleware(); end
-
-  def with_local_cache(); end
-end
-
-module ActiveSupport::Cache::Strategy::LocalCache
-end
-
-module ActiveSupport::Cache::Strategy
-end
-
-module ActiveSupport::Cache
-  def self.expand_cache_key(key, namespace=T.unsafe(nil)); end
-
-  def self.lookup_store(store=T.unsafe(nil), *parameters); end
-end
-
-module ActiveSupport::Callbacks
-  def run_callbacks(kind); end
-  CALLBACK_FILTER_TYPES = ::T.let(nil, ::T.untyped)
-end
-
-class ActiveSupport::Callbacks::CallTemplate
-  def expand(target, value, block); end
-
-  def initialize(target, method, arguments, block); end
-
-  def inverted_lambda(); end
-
-  def make_lambda(); end
-end
-
-class ActiveSupport::Callbacks::CallTemplate
-  def self.build(filter, callback); end
-end
-
-class ActiveSupport::Callbacks::Callback
-  def apply(callback_sequence); end
-
-  def chain_config(); end
-
-  def current_scopes(); end
-
-  def duplicates?(other); end
-
-  def filter(); end
-
-  def initialize(name, filter, kind, options, chain_config); end
-
-  def kind(); end
-
-  def kind=(kind); end
-
-  def matches?(_kind, _filter); end
-
-  def merge_conditional_options(chain, if_option:, unless_option:); end
-
-  def name(); end
-
-  def name=(name); end
-
-  def raw_filter(); end
-end
-
-class ActiveSupport::Callbacks::Callback
-  def self.build(chain, filter, kind, options); end
-end
-
-class ActiveSupport::Callbacks::CallbackChain
-  include ::Enumerable
-  def append(*callbacks); end
-
-  def chain(); end
-
-  def clear(); end
-
-  def compile(); end
-
-  def config(); end
-
-  def delete(o); end
-
-  def each(&block); end
-
-  def empty?(); end
-
-  def index(o); end
-
-  def initialize(name, config); end
-
-  def insert(index, o); end
-
-  def name(); end
-
-  def prepend(*callbacks); end
-end
-
-class ActiveSupport::Callbacks::CallbackChain
-end
-
-class ActiveSupport::Callbacks::CallbackSequence
-  def after(&after); end
-
-  def around(call_template, user_conditions); end
-
-  def before(&before); end
-
-  def expand_call_template(arg, block); end
-
-  def final?(); end
-
-  def initialize(nested=T.unsafe(nil), call_template=T.unsafe(nil), user_conditions=T.unsafe(nil)); end
-
-  def invoke_after(arg); end
-
-  def invoke_before(arg); end
-
-  def nested(); end
-
-  def skip?(arg); end
-end
-
-class ActiveSupport::Callbacks::CallbackSequence
-end
-
-module ActiveSupport::Callbacks::ClassMethods
-  def __update_callbacks(name); end
-
-  def define_callbacks(*names); end
-
-  def get_callbacks(name); end
-
-  def normalize_callback_params(filters, block); end
-
-  def reset_callbacks(name); end
-
-  def set_callback(name, *filter_list, &block); end
-
-  def set_callbacks(name, callbacks); end
-
-  def skip_callback(name, *filter_list, &block); end
-end
-
-module ActiveSupport::Callbacks::ClassMethods
-end
-
-module ActiveSupport::Callbacks::Conditionals
-end
-
-class ActiveSupport::Callbacks::Conditionals::Value
-  def call(target, value); end
-
-  def initialize(&block); end
-end
-
-class ActiveSupport::Callbacks::Conditionals::Value
-end
-
-module ActiveSupport::Callbacks::Conditionals
-end
-
-module ActiveSupport::Callbacks::Filters
-end
-
-class ActiveSupport::Callbacks::Filters::After
-end
-
-class ActiveSupport::Callbacks::Filters::After
-  def self.build(callback_sequence, user_callback, user_conditions, chain_config); end
-end
-
-class ActiveSupport::Callbacks::Filters::Before
-end
-
-class ActiveSupport::Callbacks::Filters::Before
-  def self.build(callback_sequence, user_callback, user_conditions, chain_config, filter, name); end
-end
-
-class ActiveSupport::Callbacks::Filters::Environment
-  def halted(); end
-
-  def halted=(_); end
-
-  def target(); end
-
-  def target=(_); end
-
-  def value(); end
-
-  def value=(_); end
-end
-
-class ActiveSupport::Callbacks::Filters::Environment
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-module ActiveSupport::Callbacks::Filters
-end
-
-module ActiveSupport::Callbacks
-  extend ::ActiveSupport::Concern
-end
-
-module ActiveSupport::Concern
-  def append_features(base); end
-
-  def class_methods(&class_methods_module_definition); end
-
-  def included(base=T.unsafe(nil), &block); end
-
-  def prepend_features(base); end
-
-  def prepended(base=T.unsafe(nil), &block); end
-end
-
-class ActiveSupport::Concern::MultipleIncludedBlocks
-  def initialize(); end
-end
-
-class ActiveSupport::Concern::MultipleIncludedBlocks
-end
-
-class ActiveSupport::Concern::MultiplePrependBlocks
-  def initialize(); end
-end
-
-class ActiveSupport::Concern::MultiplePrependBlocks
-end
-
-module ActiveSupport::Concern
-  def self.extended(base); end
-end
-
-module ActiveSupport::Concurrency
-end
-
-class ActiveSupport::Concurrency::ShareLock
-  include ::MonitorMixin
-  def exclusive(purpose: T.unsafe(nil), compatible: T.unsafe(nil), after_compatible: T.unsafe(nil), no_wait: T.unsafe(nil)); end
-
-  def initialize(); end
-
-  def raw_state(); end
-
-  def sharing(); end
-
-  def start_exclusive(purpose: T.unsafe(nil), compatible: T.unsafe(nil), no_wait: T.unsafe(nil)); end
-
-  def start_sharing(); end
-
-  def stop_exclusive(compatible: T.unsafe(nil)); end
-
-  def stop_sharing(); end
-
-  def yield_shares(purpose: T.unsafe(nil), compatible: T.unsafe(nil), block_share: T.unsafe(nil)); end
-end
-
-class ActiveSupport::Concurrency::ShareLock
-end
-
-module ActiveSupport::Concurrency
-end
-
-module ActiveSupport::Configurable
-  def config(); end
-end
-
-module ActiveSupport::Configurable::ClassMethods
-  def config(); end
-
-  def configure(); end
-end
-
-module ActiveSupport::Configurable::ClassMethods
-end
-
-class ActiveSupport::Configurable::Configuration
-  def compile_methods!(); end
-end
-
-class ActiveSupport::Configurable::Configuration
-  def self.compile_methods!(keys); end
-end
-
-module ActiveSupport::Configurable
-  extend ::ActiveSupport::Concern
-end
-
-class ActiveSupport::ConfigurationFile
-  def initialize(content_path); end
-
-  def parse(context: T.unsafe(nil), **options); end
-end
-
-class ActiveSupport::ConfigurationFile::FormatError
-end
-
-class ActiveSupport::ConfigurationFile::FormatError
-end
-
-class ActiveSupport::ConfigurationFile
-  def self.parse(content_path, **options); end
-end
-
-class ActiveSupport::CurrentAttributes
-  include ::ActiveSupport::Callbacks
-  def __callbacks(); end
-
-  def __callbacks?(); end
-
-  def _reset_callbacks(); end
-
-  def _run_reset_callbacks(&block); end
-
-  def attributes(); end
-
-  def attributes=(attributes); end
-
-  def reset(); end
-
-  def set(set_attributes); end
-end
-
-class ActiveSupport::CurrentAttributes
-  extend ::ActiveSupport::Callbacks::ClassMethods
-  extend ::ActiveSupport::DescendantsTracker
-  def self.__callbacks(); end
-
-  def self.__callbacks=(value); end
-
-  def self.__callbacks?(); end
-
-  def self._reset_callbacks(); end
-
-  def self._reset_callbacks=(value); end
-
-  def self.after_reset(&block); end
-
-  def self.attribute(*names); end
-
-  def self.before_reset(&block); end
-
-  def self.clear_all(); end
-
-  def self.instance(); end
-
-  def self.reset(*args, &block); end
-
-  def self.reset_all(); end
-
-  def self.resets(&block); end
-
-  def self.set(*args, &block); end
-end
-
-module ActiveSupport::Dependencies
-  def _eager_load_paths(); end
-
-  def _eager_load_paths=(val); end
-
-  def autoload_module!(into, const_name, qualified_name, path_suffix); end
-
-  def autoload_once_paths(); end
-
-  def autoload_once_paths=(val); end
-
-  def autoload_paths(); end
-
-  def autoload_paths=(val); end
-
-  def autoloadable_module?(path_suffix); end
-
-  def autoloaded?(desc); end
-
-  def autoloaded_constants(); end
-
-  def autoloaded_constants=(val); end
-
-  def clear(); end
-
-  def constant_watch_stack(); end
-
-  def constant_watch_stack=(val); end
-
-  def constantize(name); end
-
-  def depend_on(file_name, message=T.unsafe(nil)); end
-
-  def explicitly_unloadable_constants(); end
-
-  def explicitly_unloadable_constants=(val); end
-
-  def history(); end
-
-  def history=(val); end
-
-  def hook!(); end
-
-  def interlock(); end
-
-  def interlock=(val); end
-
-  def load?(); end
-
-  def load_file(path, const_paths=T.unsafe(nil)); end
-
-  def load_missing_constant(from_mod, const_name); end
-
-  def load_once_path?(path); end
-
-  def loadable_constants_for_path(path, bases=T.unsafe(nil)); end
-
-  def loaded(); end
-
-  def loaded=(val); end
-
-  def loading(); end
-
-  def loading=(val); end
-
-  def log(message); end
-
-  def logger(); end
-
-  def logger=(val); end
-
-  def mark_for_unload(const_desc); end
-
-  def mechanism(); end
-
-  def mechanism=(val); end
-
-  def new_constants_in(*descs); end
-
-  def qualified_const_defined?(path); end
-
-  def qualified_name_for(mod, name); end
-
-  def reference(klass); end
-
-  def remove_constant(const); end
-
-  def remove_unloadable_constants!(); end
-
-  def require_or_load(file_name, const_path=T.unsafe(nil)); end
-
-  def safe_constantize(name); end
-
-  def search_for_file(path_suffix); end
-
-  def to_constant_name(desc); end
-
-  def unhook!(); end
-
-  def verbose(); end
-
-  def verbose=(val); end
-
-  def warnings_on_first_load(); end
-
-  def warnings_on_first_load=(val); end
-
-  def will_unload?(const_desc); end
-  Reference = ::T.let(nil, ::T.untyped)
-end
-
-module ActiveSupport::Dependencies::Blamable
-  def blame_file!(file); end
-
-  def blamed_files(); end
-
-  def copy_blame!(exc); end
-
-  def describe_blame(); end
-end
-
-module ActiveSupport::Dependencies::Blamable
-end
-
-class ActiveSupport::Dependencies::ClassCache
-  def [](key); end
-
-  def clear!(); end
-
-  def empty?(); end
-
-  def get(key); end
-
-  def key?(key); end
-
-  def safe_get(key); end
-
-  def store(klass); end
-end
-
-class ActiveSupport::Dependencies::ClassCache
-end
-
-class ActiveSupport::Dependencies::Interlock
-  def done_running(); end
-
-  def done_unloading(); end
-
-  def loading(); end
-
-  def permit_concurrent_loads(); end
-
-  def raw_state(&block); end
-
-  def running(); end
-
-  def start_running(); end
-
-  def start_unloading(); end
-
-  def unloading(); end
-end
-
-class ActiveSupport::Dependencies::Interlock
-end
-
-module ActiveSupport::Dependencies::Loadable
-  def load_dependency(file); end
-
-  def require_dependency(file_name, message=T.unsafe(nil)); end
-
-  def require_or_load(file_name); end
-
-  def unloadable(const_desc); end
-end
-
-module ActiveSupport::Dependencies::Loadable
-  def self.exclude_from(base); end
-
-  def self.include_into(base); end
-end
-
-module ActiveSupport::Dependencies::ModuleConstMissing
-  def const_missing(const_name); end
-
-  def guess_for_anonymous(const_name); end
-
-  def unloadable(const_desc=T.unsafe(nil)); end
-end
-
-module ActiveSupport::Dependencies::ModuleConstMissing
-  def self.append_features(base); end
-
-  def self.exclude_from(base); end
-
-  def self.include_into(base); end
-end
-
-class ActiveSupport::Dependencies::WatchStack
-  include ::Enumerable
-  def each(&block); end
-
-  def new_constants(); end
-
-  def watch_namespaces(namespaces); end
-
-  def watching(); end
-
-  def watching?(); end
-end
-
-class ActiveSupport::Dependencies::WatchStack
-end
-
-module ActiveSupport::Dependencies
-  extend ::ActiveSupport::Dependencies
-  def self.load_interlock(); end
-
-  def self.run_interlock(); end
-
-  def self.unload_interlock(); end
 end
 
 class ActiveSupport::Deprecation
-  include ::Singleton
-  include ::ActiveSupport::Deprecation::InstanceDelegator
-  include ::ActiveSupport::Deprecation::Behavior
-  include ::ActiveSupport::Deprecation::Reporting
-  include ::ActiveSupport::Deprecation::Disallowed
-  include ::ActiveSupport::Deprecation::MethodWrapper
-  def deprecation_horizon(); end
-
-  def deprecation_horizon=(deprecation_horizon); end
-
-  def initialize(deprecation_horizon=T.unsafe(nil), gem_name=T.unsafe(nil)); end
-  DEFAULT_BEHAVIORS = ::T.let(nil, ::T.untyped)
-end
-
-module ActiveSupport::Deprecation::Behavior
-  def behavior(); end
-
-  def behavior=(behavior); end
-
-  def debug(); end
-
-  def debug=(debug); end
-
-  def disallowed_behavior(); end
-
-  def disallowed_behavior=(behavior); end
-end
-
-module ActiveSupport::Deprecation::Behavior
-end
-
-module ActiveSupport::Deprecation::DeprecatedConstantAccessor
-end
-
-module ActiveSupport::Deprecation::DeprecatedConstantAccessor
-  def self.included(base); end
-end
-
-class ActiveSupport::Deprecation::DeprecatedConstantProxy
-  def hash(*args, &block); end
-
-  def initialize(old_const, new_const, deprecator=T.unsafe(nil), message: T.unsafe(nil)); end
-
-  def instance_methods(*args, &block); end
-
-  def name(*args, &block); end
-
-  def respond_to?(*args, &block); end
-end
-
-class ActiveSupport::Deprecation::DeprecatedConstantProxy
-  def self.new(*args, **options, &block); end
-end
-
-class ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy
-  def initialize(instance, method, var=T.unsafe(nil), deprecator=T.unsafe(nil)); end
-end
-
-class ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy
-end
-
-class ActiveSupport::Deprecation::DeprecatedObjectProxy
-  def initialize(object, message, deprecator=T.unsafe(nil)); end
-end
-
-class ActiveSupport::Deprecation::DeprecatedObjectProxy
-end
-
-class ActiveSupport::Deprecation::DeprecationProxy
-end
-
-class ActiveSupport::Deprecation::DeprecationProxy
-  def self.new(*args, &block); end
-end
-
-module ActiveSupport::Deprecation::Disallowed
-  def disallowed_warnings(); end
-
-  def disallowed_warnings=(disallowed_warnings); end
-end
-
-module ActiveSupport::Deprecation::Disallowed
-end
-
-module ActiveSupport::Deprecation::InstanceDelegator
-end
-
-module ActiveSupport::Deprecation::InstanceDelegator::ClassMethods
-  def include(included_module); end
-
-  def method_added(method_name); end
-end
-
-module ActiveSupport::Deprecation::InstanceDelegator::ClassMethods
-end
-
-module ActiveSupport::Deprecation::InstanceDelegator::OverrideDelegators
-  def deprecation_warning(deprecated_method_name, message=T.unsafe(nil), caller_backtrace=T.unsafe(nil)); end
-
-  def warn(message=T.unsafe(nil), callstack=T.unsafe(nil)); end
-end
-
-module ActiveSupport::Deprecation::InstanceDelegator::OverrideDelegators
-end
-
-module ActiveSupport::Deprecation::InstanceDelegator
-  def self.included(base); end
-end
-
-module ActiveSupport::Deprecation::MethodWrapper
-  def deprecate_methods(target_module, *method_names); end
-end
-
-module ActiveSupport::Deprecation::MethodWrapper
-end
-
-module ActiveSupport::Deprecation::Reporting
-  def allow(allowed_warnings=T.unsafe(nil), if: T.unsafe(nil), &block); end
-
-  def deprecation_warning(deprecated_method_name, message=T.unsafe(nil), caller_backtrace=T.unsafe(nil)); end
-
-  def gem_name(); end
-
-  def gem_name=(gem_name); end
-
-  def silence(&block); end
-
-  def silenced(); end
-
-  def silenced=(silenced); end
-
-  def warn(message=T.unsafe(nil), callstack=T.unsafe(nil)); end
-  RAILS_GEM_ROOT = ::T.let(nil, ::T.untyped)
-end
-
-module ActiveSupport::Deprecation::Reporting
-end
-
-class ActiveSupport::Deprecation
-  extend ::Singleton::SingletonClassMethods
-  extend ::ActiveSupport::Deprecation::InstanceDelegator::ClassMethods
-  extend ::ActiveSupport::Deprecation::InstanceDelegator::OverrideDelegators
-  def self.allow(*args, &block); end
-
-  def self.behavior(*args, &block); end
-
-  def self.behavior=(arg); end
-
-  def self.debug(*args, &block); end
-
-  def self.debug=(arg); end
-
-  def self.deprecate_methods(*args, &block); end
-
-  def self.deprecation_horizon(*args, &block); end
-
-  def self.deprecation_horizon=(arg); end
-
   def self.deprecation_warning(*args, &block); end
 
-  def self.disallowed_behavior(*args, &block); end
-
-  def self.disallowed_behavior=(arg); end
-
-  def self.disallowed_warnings(*args, &block); end
-
-  def self.disallowed_warnings=(arg); end
-
-  def self.gem_name(*args, &block); end
-
-  def self.gem_name=(arg); end
-
   def self.initialize(*args, &block); end
 
-  def self.instance(); end
-
-  def self.silence(*args, &block); end
-
-  def self.silenced(*args, &block); end
-
-  def self.silenced=(arg); end
-
   def self.warn(*args, &block); end
 end
 
-module ActiveSupport::DescendantsTracker
-  def descendants(); end
-
-  def direct_descendants(); end
-
-  def inherited(base); end
-
-  def subclasses(); end
-end
-
-class ActiveSupport::DescendantsTracker::DescendantsArray
-  include ::Enumerable
-  def <<(klass); end
-
-  def cleanup!(); end
-
-  def each(&blk); end
-
-  def refs_size(); end
-
-  def reject!(); end
-end
-
-class ActiveSupport::DescendantsTracker::DescendantsArray
-end
-
-module ActiveSupport::DescendantsTracker
-  def self.clear(); end
-
-  def self.descendants(klass); end
-
-  def self.direct_descendants(klass); end
-
-  def self.store_inherited(klass, descendant); end
-
-  def self.subclasses(klass); end
-end
-
-class ActiveSupport::Digest
-end
-
-class ActiveSupport::Digest
-  def self.hash_digest_class(); end
-
-  def self.hash_digest_class=(klass); end
-
-  def self.hexdigest(arg); end
-end
-
-class ActiveSupport::Duration
-  def %(other); end
-
-  def *(other); end
-
-  def +(other); end
-
-  def +@(); end
-
-  def -(other); end
-
-  def -@(); end
-
-  def /(other); end
-
-  def ==(other); end
-
-  def after(time=T.unsafe(nil)); end
-
-  def ago(time=T.unsafe(nil)); end
-
-  def before(time=T.unsafe(nil)); end
-
-  def coerce(other); end
-
-  def encode_with(coder); end
-
-  def eql?(other); end
-
-  def from_now(time=T.unsafe(nil)); end
-
-  def in_days(); end
-
-  def in_hours(); end
-
-  def in_minutes(); end
-
-  def in_months(); end
-
-  def in_seconds(); end
-
-  def in_weeks(); end
-
-  def in_years(); end
-
-  def init_with(coder); end
-
-  def initialize(value, parts); end
-
-  def instance_of?(klass); end
-
-  def is_a?(klass); end
-
-  def iso8601(precision: T.unsafe(nil)); end
-
-  def kind_of?(klass); end
-
-  def parts(); end
-
-  def parts=(parts); end
-
-  def since(time=T.unsafe(nil)); end
-
-  def to_i(); end
-
-  def until(time=T.unsafe(nil)); end
-
-  def value(); end
-
-  def value=(value); end
-  PARTS = ::T.let(nil, ::T.untyped)
-  PARTS_IN_SECONDS = ::T.let(nil, ::T.untyped)
-  SECONDS_PER_DAY = ::T.let(nil, ::T.untyped)
-  SECONDS_PER_HOUR = ::T.let(nil, ::T.untyped)
-  SECONDS_PER_MINUTE = ::T.let(nil, ::T.untyped)
-  SECONDS_PER_MONTH = ::T.let(nil, ::T.untyped)
-  SECONDS_PER_WEEK = ::T.let(nil, ::T.untyped)
-  SECONDS_PER_YEAR = ::T.let(nil, ::T.untyped)
-end
-
-class ActiveSupport::Duration::ISO8601Parser
-  def initialize(string); end
-
-  def mode(); end
-
-  def mode=(mode); end
-
-  def parse!(); end
-
-  def parts(); end
-
-  def scanner(); end
-
-  def sign(); end
-
-  def sign=(sign); end
-  COMMA = ::T.let(nil, ::T.untyped)
-  DATE_COMPONENT = ::T.let(nil, ::T.untyped)
-  DATE_COMPONENTS = ::T.let(nil, ::T.untyped)
-  DATE_MARKER = ::T.let(nil, ::T.untyped)
-  DATE_TO_PART = ::T.let(nil, ::T.untyped)
-  PERIOD = ::T.let(nil, ::T.untyped)
-  PERIOD_OR_COMMA = ::T.let(nil, ::T.untyped)
-  SIGN_MARKER = ::T.let(nil, ::T.untyped)
-  TIME_COMPONENT = ::T.let(nil, ::T.untyped)
-  TIME_COMPONENTS = ::T.let(nil, ::T.untyped)
-  TIME_MARKER = ::T.let(nil, ::T.untyped)
-  TIME_TO_PART = ::T.let(nil, ::T.untyped)
-end
-
-class ActiveSupport::Duration::ISO8601Parser::ParsingError
-end
-
-class ActiveSupport::Duration::ISO8601Parser::ParsingError
-end
-
-class ActiveSupport::Duration::ISO8601Parser
-end
-
-class ActiveSupport::Duration::ISO8601Serializer
-  def initialize(duration, precision: T.unsafe(nil)); end
-
-  def serialize(); end
-  DATE_COMPONENTS = ::T.let(nil, ::T.untyped)
-end
-
-class ActiveSupport::Duration::ISO8601Serializer
-end
-
-class ActiveSupport::Duration::Scalar
-  def %(other); end
-
-  def *(other); end
-
-  def +(other); end
-
-  def -(other); end
-
-  def /(other); end
-
-  def coerce(other); end
-
-  def initialize(value); end
-
-  def to_f(*args, &block); end
-
-  def to_i(*args, &block); end
-
-  def to_s(*args, &block); end
-
-  def value(); end
-end
-
-class ActiveSupport::Duration::Scalar
-end
-
-class ActiveSupport::Duration
-  def self.===(other); end
-
-  def self.build(value); end
-
-  def self.days(value); end
-
-  def self.hours(value); end
-
-  def self.minutes(value); end
-
-  def self.months(value); end
-
-  def self.parse(iso8601duration); end
-
-  def self.seconds(value); end
-
-  def self.weeks(value); end
-
-  def self.years(value); end
-end
-
-class ActiveSupport::EnvironmentInquirer
-  def development?(); end
-
-  def initialize(env); end
-
-  def production?(); end
-
-  def test?(); end
-  DEFAULT_ENVIRONMENTS = ::T.let(nil, ::T.untyped)
-end
-
-class ActiveSupport::EnvironmentInquirer
-end
-
-class ActiveSupport::ExecutionWrapper
-  include ::ActiveSupport::Callbacks
-  def __callbacks(); end
-
-  def __callbacks?(); end
-
-  def _complete_callbacks(); end
-
-  def _run_callbacks(); end
-
-  def _run_complete_callbacks(&block); end
-
-  def _run_run_callbacks(&block); end
-
-  def complete!(); end
-
-  def run!(); end
-  Null = ::T.let(nil, ::T.untyped)
-end
-
-class ActiveSupport::ExecutionWrapper::CompleteHook
-  def after(target); end
-
-  def before(target); end
-
-  def hook(); end
-
-  def hook=(_); end
-end
-
-class ActiveSupport::ExecutionWrapper::CompleteHook
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class ActiveSupport::ExecutionWrapper::RunHook
-  def before(target); end
-
-  def hook(); end
-
-  def hook=(_); end
-end
-
-class ActiveSupport::ExecutionWrapper::RunHook
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class ActiveSupport::ExecutionWrapper
-  extend ::ActiveSupport::Callbacks::ClassMethods
-  extend ::ActiveSupport::DescendantsTracker
-  def self.__callbacks(); end
-
-  def self.__callbacks=(value); end
-
-  def self.__callbacks?(); end
-
-  def self._complete_callbacks(); end
-
-  def self._complete_callbacks=(value); end
-
-  def self._run_callbacks(); end
-
-  def self._run_callbacks=(value); end
-
-  def self.active(); end
-
-  def self.active=(active); end
-
-  def self.active?(); end
-
-  def self.inherited(other); end
-
-  def self.register_hook(hook, outer: T.unsafe(nil)); end
-
-  def self.run!(); end
-
-  def self.to_complete(*args, &block); end
-
-  def self.to_run(*args, &block); end
-
-  def self.wrap(); end
-end
-
-class ActiveSupport::Executor
-end
-
-class ActiveSupport::Executor
-end
-
-class ActiveSupport::FileUpdateChecker
-  def execute(); end
-
-  def execute_if_updated(); end
-
-  def initialize(files, dirs=T.unsafe(nil), &block); end
-
-  def updated?(); end
-end
-
-class ActiveSupport::FileUpdateChecker
-end
-
-module ActiveSupport::ForkTracker
-end
-
-module ActiveSupport::ForkTracker::CoreExt
-  def fork(*arg); end
-end
-
-module ActiveSupport::ForkTracker::CoreExt
-end
-
 module ActiveSupport::ForkTracker::CoreExtPrivate
   include ::ActiveSupport::ForkTracker::CoreExt
 end
 
-module ActiveSupport::ForkTracker::CoreExtPrivate
-end
-
-module ActiveSupport::ForkTracker
-  def self.after_fork(&block); end
-
-  def self.check!(); end
-
-  def self.hook!(); end
-
-  def self.unregister(callback); end
-end
-
-module ActiveSupport::Gzip
-end
-
-class ActiveSupport::Gzip::Stream
-end
-
-class ActiveSupport::Gzip::Stream
-end
-
-module ActiveSupport::Gzip
-  def self.compress(source, level=T.unsafe(nil), strategy=T.unsafe(nil)); end
-
-  def self.decompress(source); end
-end
-
-class ActiveSupport::InheritableOptions
-  def inheritable_copy(); end
-
-  def initialize(parent=T.unsafe(nil)); end
-end
-
-class ActiveSupport::InheritableOptions
-end
-
-class ActiveSupport::KeyGenerator
-  def generate_key(salt, key_size=T.unsafe(nil)); end
-
-  def initialize(secret, options=T.unsafe(nil)); end
-end
-
-class ActiveSupport::KeyGenerator
-end
-
-class ActiveSupport::LogSubscriber
-  def colorize_logging(); end
-
-  def colorize_logging=(val); end
-
-  def debug(progname=T.unsafe(nil), &block); end
-
-  def error(progname=T.unsafe(nil), &block); end
-
-  def fatal(progname=T.unsafe(nil), &block); end
-
-  def info(progname=T.unsafe(nil), &block); end
-
-  def logger(); end
-
-  def unknown(progname=T.unsafe(nil), &block); end
-
-  def warn(progname=T.unsafe(nil), &block); end
-  BLACK = ::T.let(nil, ::T.untyped)
-  BLUE = ::T.let(nil, ::T.untyped)
-  BOLD = ::T.let(nil, ::T.untyped)
-  CLEAR = ::T.let(nil, ::T.untyped)
-  CYAN = ::T.let(nil, ::T.untyped)
-  GREEN = ::T.let(nil, ::T.untyped)
-  MAGENTA = ::T.let(nil, ::T.untyped)
-  RED = ::T.let(nil, ::T.untyped)
-  WHITE = ::T.let(nil, ::T.untyped)
-  YELLOW = ::T.let(nil, ::T.untyped)
-end
-
-class ActiveSupport::LogSubscriber
-  def self.colorize_logging(); end
-
-  def self.colorize_logging=(val); end
-
-  def self.flush_all!(); end
-
-  def self.log_subscribers(); end
-
-  def self.logger(); end
-
-  def self.logger=(logger); end
-end
-
-class ActiveSupport::Logger
-  include ::ActiveSupport::LoggerSilence
-  include ::ActiveSupport::LoggerThreadSafeLevel
-  def initialize(*args, **kwargs); end
-
-  def silencer(); end
-
-  def silencer=(val); end
-end
-
-class ActiveSupport::Logger::SimpleFormatter
-  def call(severity, timestamp, progname, msg); end
-end
-
-class ActiveSupport::Logger::SimpleFormatter
-end
-
-class ActiveSupport::Logger
-  def self.broadcast(logger); end
-
-  def self.local_levels(); end
-
-  def self.local_levels=(val); end
-
-  def self.logger_outputs_to?(logger, *sources); end
-
-  def self.silencer(); end
-
-  def self.silencer=(val); end
-end
-
-module ActiveSupport::LoggerSilence
-  def silence(severity=T.unsafe(nil)); end
-end
-
-module ActiveSupport::LoggerSilence
-  extend ::ActiveSupport::Concern
-end
-
-module ActiveSupport::LoggerThreadSafeLevel
-  def add(severity, message=T.unsafe(nil), progname=T.unsafe(nil), &block); end
-
-  def debug?(); end
-
-  def error?(); end
-
-  def fatal?(); end
-
-  def info?(); end
-
-  def level(); end
-
-  def local_level(); end
-
-  def local_level=(level); end
-
-  def local_log_id(); end
-
-  def log_at(level); end
-
-  def unknown?(); end
-
-  def warn?(); end
-end
-
-module ActiveSupport::LoggerThreadSafeLevel
-  extend ::ActiveSupport::Concern
-end
-
-class ActiveSupport::MessageEncryptor
-  include ::ActiveSupport::Messages::Rotator::Encryptor
-  include ::ActiveSupport::Messages::Rotator
-  def encrypt_and_sign(value, expires_at: T.unsafe(nil), expires_in: T.unsafe(nil), purpose: T.unsafe(nil)); end
-end
-
-class ActiveSupport::MessageEncryptor::InvalidMessage
-end
-
-class ActiveSupport::MessageEncryptor::InvalidMessage
-end
-
-module ActiveSupport::MessageEncryptor::NullSerializer
-end
-
-module ActiveSupport::MessageEncryptor::NullSerializer
-  def self.dump(value); end
-
-  def self.load(value); end
-end
-
-module ActiveSupport::MessageEncryptor::NullVerifier
-end
-
-module ActiveSupport::MessageEncryptor::NullVerifier
-  def self.generate(value); end
-
-  def self.verify(value); end
-end
-
-ActiveSupport::MessageEncryptor::OpenSSLCipherError = OpenSSL::Cipher::CipherError
-
-class ActiveSupport::MessageEncryptor
-  def self.default_cipher(); end
-
-  def self.key_len(cipher=T.unsafe(nil)); end
-
-  def self.use_authenticated_message_encryption(); end
-
-  def self.use_authenticated_message_encryption=(val); end
-end
-
-class ActiveSupport::MessageVerifier
-  include ::ActiveSupport::Messages::Rotator::Verifier
-  include ::ActiveSupport::Messages::Rotator
-  def generate(value, expires_at: T.unsafe(nil), expires_in: T.unsafe(nil), purpose: T.unsafe(nil)); end
-
-  def valid_message?(signed_message); end
-
-  def verify(*args, **options); end
-end
-
-class ActiveSupport::MessageVerifier::InvalidSignature
-end
-
-class ActiveSupport::MessageVerifier::InvalidSignature
-end
-
-class ActiveSupport::MessageVerifier
-end
-
-module ActiveSupport::Messages::Rotator
-  def initialize(*secrets, on_rotation: T.unsafe(nil), **options); end
-
-  def rotate(*secrets, **options); end
-end
-
-module ActiveSupport::Messages::Rotator::Encryptor
-  include ::ActiveSupport::Messages::Rotator
-  def decrypt_and_verify(*args, on_rotation: T.unsafe(nil), **options); end
-end
-
-module ActiveSupport::Messages::Rotator::Encryptor
-end
-
-module ActiveSupport::Messages::Rotator::Verifier
-  include ::ActiveSupport::Messages::Rotator
-  def verified(*args, on_rotation: T.unsafe(nil), **options); end
-end
-
-module ActiveSupport::Messages::Rotator::Verifier
-end
-
-module ActiveSupport::Messages::Rotator
-end
-
-module ActiveSupport::Notifications
-end
-
-class ActiveSupport::Notifications::Event
-  def <<(event); end
-
-  def allocations(); end
-
-  def children(); end
-
-  def cpu_time(); end
-
-  def duration(); end
-
-  def end(); end
-
-  def finish!(); end
-
-  def idle_time(); end
-
-  def initialize(name, start, ending, transaction_id, payload); end
-
-  def name(); end
-
-  def parent_of?(event); end
-
-  def payload(); end
-
-  def payload=(payload); end
-
-  def start!(); end
-
-  def time(); end
-
-  def transaction_id(); end
-end
-
-class ActiveSupport::Notifications::Event
-end
-
-class ActiveSupport::Notifications::Fanout
-  include ::Mutex_m
-  def finish(name, id, payload, listeners=T.unsafe(nil)); end
-
-  def initialize(); end
-
-  def listeners_for(name); end
-
-  def listening?(name); end
-
-  def lock(); end
-
-  def locked?(); end
-
-  def publish(name, *args); end
-
-  def start(name, id, payload); end
-
-  def subscribe(pattern=T.unsafe(nil), callable=T.unsafe(nil), monotonic: T.unsafe(nil), &block); end
-
-  def synchronize(&block); end
-
-  def try_lock(); end
-
-  def unlock(); end
-
-  def unsubscribe(subscriber_or_name); end
-
-  def wait(); end
-end
-
-module ActiveSupport::Notifications::Fanout::Subscribers
-end
-
-class ActiveSupport::Notifications::Fanout::Subscribers::AllMessages
-  def finish(name, id, payload); end
-
-  def initialize(delegate); end
-
-  def matches?(arg); end
-
-  def publish(name, *args); end
-
-  def start(name, id, payload); end
-
-  def subscribed_to?(name); end
-
-  def unsubscribe!(*arg); end
-end
-
-class ActiveSupport::Notifications::Fanout::Subscribers::AllMessages
-end
-
-class ActiveSupport::Notifications::Fanout::Subscribers::EventObject
-end
-
-class ActiveSupport::Notifications::Fanout::Subscribers::EventObject
-end
-
-class ActiveSupport::Notifications::Fanout::Subscribers::Evented
-  def finish(name, id, payload); end
-
-  def initialize(pattern, delegate); end
-
-  def matches?(name); end
-
-  def pattern(); end
-
-  def publish(name, *args); end
-
-  def start(name, id, payload); end
-
-  def subscribed_to?(name); end
-
-  def unsubscribe!(name); end
-end
-
-class ActiveSupport::Notifications::Fanout::Subscribers::Evented
-end
-
-class ActiveSupport::Notifications::Fanout::Subscribers::Matcher
-  def ===(name); end
-
-  def exclusions(); end
-
-  def initialize(pattern); end
-
-  def pattern(); end
-
-  def unsubscribe!(name); end
-end
-
-class ActiveSupport::Notifications::Fanout::Subscribers::Matcher
-  def self.wrap(pattern); end
-end
-
-class ActiveSupport::Notifications::Fanout::Subscribers::MonotonicTimed
-end
-
-class ActiveSupport::Notifications::Fanout::Subscribers::MonotonicTimed
-end
-
-class ActiveSupport::Notifications::Fanout::Subscribers::Timed
-end
-
-class ActiveSupport::Notifications::Fanout::Subscribers::Timed
-end
-
-module ActiveSupport::Notifications::Fanout::Subscribers
-  def self.new(pattern, listener, monotonic); end
-
-  def self.wrap_all(pattern, subscriber); end
-end
-
-class ActiveSupport::Notifications::Fanout
-end
-
-class ActiveSupport::Notifications::InstrumentationRegistry
-  def instrumenter_for(notifier); end
-end
-
-class ActiveSupport::Notifications::InstrumentationRegistry
-end
-
-class ActiveSupport::Notifications::Instrumenter
-  def finish(name, payload); end
-
-  def finish_with_state(listeners_state, name, payload); end
-
-  def id(); end
-
-  def initialize(notifier); end
-
-  def instrument(name, payload=T.unsafe(nil)); end
-
-  def start(name, payload); end
-end
-
-class ActiveSupport::Notifications::Instrumenter
-end
-
-module ActiveSupport::Notifications
-  def self.instrument(name, payload=T.unsafe(nil)); end
-
-  def self.instrumenter(); end
-
-  def self.monotonic_subscribe(pattern=T.unsafe(nil), callback=T.unsafe(nil), &block); end
-
-  def self.notifier(); end
-
-  def self.notifier=(notifier); end
-
-  def self.publish(name, *args); end
-
-  def self.subscribe(pattern=T.unsafe(nil), callback=T.unsafe(nil), &block); end
-
-  def self.subscribed(callback, pattern=T.unsafe(nil), monotonic: T.unsafe(nil), &block); end
-
-  def self.unsubscribe(subscriber_or_name); end
-end
-
-module ActiveSupport::NumberHelper
-  def number_to_currency(number, options=T.unsafe(nil)); end
-
-  def number_to_delimited(number, options=T.unsafe(nil)); end
-
-  def number_to_human(number, options=T.unsafe(nil)); end
-
-  def number_to_human_size(number, options=T.unsafe(nil)); end
-
-  def number_to_percentage(number, options=T.unsafe(nil)); end
-
-  def number_to_phone(number, options=T.unsafe(nil)); end
-
-  def number_to_rounded(number, options=T.unsafe(nil)); end
-end
-
-class ActiveSupport::NumberHelper::NumberConverter
-  def execute(); end
-
-  def initialize(number, options); end
-
-  def namespace(); end
-
-  def namespace=(namespace); end
-
-  def namespace?(); end
-
-  def number(); end
-
-  def opts(); end
-
-  def validate_float(); end
-
-  def validate_float=(validate_float); end
-
-  def validate_float?(); end
-  DEFAULTS = ::T.let(nil, ::T.untyped)
-end
-
-class ActiveSupport::NumberHelper::NumberConverter
-  def self.convert(number, options); end
-
-  def self.namespace(); end
-
-  def self.namespace=(value); end
-
-  def self.namespace?(); end
-
-  def self.validate_float(); end
-
-  def self.validate_float=(value); end
-
-  def self.validate_float?(); end
-end
-
-class ActiveSupport::NumberHelper::NumberToCurrencyConverter
-  def convert(); end
-end
-
-class ActiveSupport::NumberHelper::NumberToCurrencyConverter
-end
-
-class ActiveSupport::NumberHelper::NumberToDelimitedConverter
-  def convert(); end
-  DEFAULT_DELIMITER_REGEX = ::T.let(nil, ::T.untyped)
-end
-
-class ActiveSupport::NumberHelper::NumberToDelimitedConverter
-end
-
-class ActiveSupport::NumberHelper::NumberToHumanConverter
-  def convert(); end
-  DECIMAL_UNITS = ::T.let(nil, ::T.untyped)
-  INVERTED_DECIMAL_UNITS = ::T.let(nil, ::T.untyped)
-end
-
-class ActiveSupport::NumberHelper::NumberToHumanConverter
-end
-
-class ActiveSupport::NumberHelper::NumberToHumanSizeConverter
-  def convert(); end
-  STORAGE_UNITS = ::T.let(nil, ::T.untyped)
-end
-
-class ActiveSupport::NumberHelper::NumberToHumanSizeConverter
-end
-
-class ActiveSupport::NumberHelper::NumberToPercentageConverter
-  def convert(); end
-end
-
-class ActiveSupport::NumberHelper::NumberToPercentageConverter
-end
-
-class ActiveSupport::NumberHelper::NumberToPhoneConverter
-  def convert(); end
-end
-
-class ActiveSupport::NumberHelper::NumberToPhoneConverter
-end
-
-class ActiveSupport::NumberHelper::NumberToRoundedConverter
-  def convert(); end
-end
-
-class ActiveSupport::NumberHelper::NumberToRoundedConverter
-end
-
-class ActiveSupport::NumberHelper::RoundingHelper
-  def digit_count(number); end
-
-  def initialize(options); end
-
-  def options(); end
-
-  def round(number); end
-end
-
-class ActiveSupport::NumberHelper::RoundingHelper
-end
-
-module ActiveSupport::NumberHelper
-  extend ::ActiveSupport::Autoload
-  extend ::ActiveSupport::NumberHelper
-end
-
-class ActiveSupport::OptionMerger
-  def initialize(context, options); end
-end
-
-class ActiveSupport::OptionMerger
-end
-
-class ActiveSupport::OrderedHash
-  def encode_with(coder); end
-
-  def nested_under_indifferent_access(); end
-
-  def reject(*args, &block); end
-
-  def select(*args, &block); end
-
-  def to_yaml_type(); end
-end
-
-class ActiveSupport::OrderedHash
-end
-
-class ActiveSupport::OrderedOptions
-  def [](key); end
-
-  def []=(key, value); end
-
-  def _get(arg); end
-
-  def method_missing(name, *args); end
-end
-
-class ActiveSupport::OrderedOptions
-end
-
-class ActiveSupport::ProxyObject
-  def raise(*args); end
-end
-
-class ActiveSupport::ProxyObject
-end
-
-class ActiveSupport::Reloader
-  def _class_unload_callbacks(); end
-
-  def _prepare_callbacks(); end
-
-  def _run_class_unload_callbacks(&block); end
-
-  def _run_prepare_callbacks(&block); end
-
-  def check(); end
-
-  def check=(check); end
-
-  def check?(); end
-
-  def class_unload!(&block); end
-
-  def executor(); end
-
-  def executor=(executor); end
-
-  def executor?(); end
-
-  def release_unload_lock!(); end
-
-  def require_unload_lock!(); end
-end
-
-class ActiveSupport::Reloader
-  def self._class_unload_callbacks(); end
-
-  def self._class_unload_callbacks=(value); end
-
-  def self._prepare_callbacks(); end
-
-  def self._prepare_callbacks=(value); end
-
-  def self.after_class_unload(*args, &block); end
-
-  def self.before_class_unload(*args, &block); end
-
-  def self.check(); end
-
-  def self.check!(); end
-
-  def self.check=(value); end
-
-  def self.check?(); end
-
-  def self.executor(); end
-
-  def self.executor=(value); end
-
-  def self.executor?(); end
-
-  def self.prepare!(); end
-
-  def self.reload!(); end
-
-  def self.reloaded!(); end
-
-  def self.to_prepare(*args, &block); end
-end
-
-module ActiveSupport::Rescuable
-  def handler_for_rescue(exception); end
-
-  def rescue_with_handler(exception); end
-end
-
-module ActiveSupport::Rescuable::ClassMethods
-  def handler_for_rescue(exception, object: T.unsafe(nil)); end
-
-  def rescue_from(*klasses, with: T.unsafe(nil), &block); end
-
-  def rescue_with_handler(exception, object: T.unsafe(nil), visited_exceptions: T.unsafe(nil)); end
-end
-
-module ActiveSupport::Rescuable::ClassMethods
-end
-
-module ActiveSupport::Rescuable
-  extend ::ActiveSupport::Concern
-end
-
-class ActiveSupport::SafeBuffer
-  def %(args); end
-
-  def *(*arg); end
-
-  def +(other); end
-
-  def <<(value); end
-
-  def [](*args); end
-
-  def []=(*args); end
-
-  def capitalize(*args, &block); end
-
-  def capitalize!(*args); end
-
-  def chomp(*args, &block); end
-
-  def chomp!(*args); end
-
-  def chop(*args, &block); end
-
-  def chop!(*args); end
-
-  def clone_empty(); end
-
-  def concat(value); end
-
-  def delete(*args, &block); end
-
-  def delete!(*args); end
-
-  def delete_prefix(*args, &block); end
-
-  def delete_prefix!(*args); end
-
-  def delete_suffix(*args, &block); end
-
-  def delete_suffix!(*args); end
-
-  def downcase(*args, &block); end
-
-  def downcase!(*args); end
-
-  def encode_with(coder); end
-
-  def gsub(*args, &block); end
-
-  def gsub!(*args, &block); end
-
-  def initialize(str=T.unsafe(nil)); end
-
-  def insert(index, value); end
-
-  def lstrip(*args, &block); end
-
-  def lstrip!(*args); end
-
-  def next(*args, &block); end
-
-  def next!(*args); end
-
-  def prepend(value); end
-
-  def replace(value); end
-
-  def reverse(*args, &block); end
-
-  def reverse!(*args); end
-
-  def rstrip(*args, &block); end
-
-  def rstrip!(*args); end
-
-  def safe_concat(value); end
-
-  def scrub(*args, &block); end
-
-  def scrub!(*args); end
-
-  def slice(*args, &block); end
-
-  def slice!(*args); end
-
-  def squeeze(*args, &block); end
-
-  def squeeze!(*args); end
-
-  def strip(*args, &block); end
-
-  def strip!(*args); end
-
-  def sub(*args, &block); end
-
-  def sub!(*args, &block); end
-
-  def succ(*args, &block); end
-
-  def succ!(*args); end
-
-  def swapcase(*args, &block); end
-
-  def swapcase!(*args); end
-
-  def tr(*args, &block); end
-
-  def tr!(*args); end
-
-  def tr_s(*args, &block); end
-
-  def tr_s!(*args); end
-
-  def unicode_normalize(*args, &block); end
-
-  def unicode_normalize!(*args); end
-
-  def upcase(*args, &block); end
-
-  def upcase!(*args); end
-  UNSAFE_STRING_METHODS = ::T.let(nil, ::T.untyped)
-  UNSAFE_STRING_METHODS_WITH_BACKREF = ::T.let(nil, ::T.untyped)
-end
-
-class ActiveSupport::SafeBuffer::SafeConcatError
-  def initialize(); end
-end
-
-class ActiveSupport::SafeBuffer::SafeConcatError
-end
-
-class ActiveSupport::SafeBuffer
-end
-
-class ActiveSupport::SecureCompareRotator
-  include ::ActiveSupport::SecurityUtils
-  include ::ActiveSupport::Messages::Rotator
-  def secure_compare!(other_value, on_rotation: T.unsafe(nil)); end
-end
-
-class ActiveSupport::SecureCompareRotator::InvalidMatch
-end
-
-class ActiveSupport::SecureCompareRotator::InvalidMatch
-end
-
-class ActiveSupport::SecureCompareRotator
-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
-
-class ActiveSupport::StringInquirer
-end
-
-class ActiveSupport::Subscriber
-  def finish(name, id, payload); end
-
-  def patterns(); end
-
-  def start(name, id, payload); end
-end
-
-class ActiveSupport::Subscriber
-  def self.attach_to(namespace, subscriber=T.unsafe(nil), notifier=T.unsafe(nil), inherit_all: T.unsafe(nil)); end
-
-  def self.detach_from(namespace, notifier=T.unsafe(nil)); end
-
-  def self.method_added(event); end
-
-  def self.subscribers(); end
-end
-
-module ActiveSupport::TaggedLogging
-  def clear_tags!(*args, &block); end
-
-  def flush(); end
-
-  def pop_tags(*args, &block); end
-
-  def push_tags(*args, &block); end
-
-  def tagged(*tags); end
-end
-
-module ActiveSupport::TaggedLogging::Formatter
-  def call(severity, timestamp, progname, msg); end
-
-  def clear_tags!(); end
-
-  def current_tags(); end
-
-  def pop_tags(size=T.unsafe(nil)); end
-
-  def push_tags(*tags); end
-
-  def tagged(*tags); end
-
-  def tags_text(); end
-end
-
-module ActiveSupport::TaggedLogging::Formatter
-end
-
-module ActiveSupport::TaggedLogging::LocalTagStorage
-  def current_tags(); end
-
-  def current_tags=(current_tags); end
-end
-
-module ActiveSupport::TaggedLogging::LocalTagStorage
-  def self.extended(base); end
-end
-
-module ActiveSupport::TaggedLogging
-  def self.new(logger); end
-end
-
-class ActiveSupport::TestCase
-  include ::ActiveSupport::Testing::TaggedLogging
-  include ::ActiveSupport::Callbacks
-  include ::ActiveSupport::Testing::Assertions
-  include ::ActiveSupport::Testing::Deprecation
-  include ::ActiveSupport::Testing::TimeHelpers
-  include ::ActiveSupport::Testing::FileFixtures
-  include ::ActiveSupport::Testing::SetupAndTeardown
-  def __callbacks(); end
-
-  def __callbacks?(); end
-
-  def _run_setup_callbacks(&block); end
-
-  def _run_teardown_callbacks(&block); end
-
-  def _setup_callbacks(); end
-
-  def _teardown_callbacks(); end
-
-  def assert_no_match(matcher, obj, msg=T.unsafe(nil)); end
-
-  def assert_not_empty(obj, msg=T.unsafe(nil)); end
-
-  def assert_not_equal(exp, act, msg=T.unsafe(nil)); end
-
-  def assert_not_in_delta(exp, act, delta=T.unsafe(nil), msg=T.unsafe(nil)); end
-
-  def assert_not_in_epsilon(a, b, epsilon=T.unsafe(nil), msg=T.unsafe(nil)); end
-
-  def assert_not_includes(collection, obj, msg=T.unsafe(nil)); end
-
-  def assert_not_instance_of(cls, obj, msg=T.unsafe(nil)); end
-
-  def assert_not_kind_of(cls, obj, msg=T.unsafe(nil)); end
-
-  def assert_not_nil(obj, msg=T.unsafe(nil)); end
-
-  def assert_not_operator(o1, op, o2=T.unsafe(nil), msg=T.unsafe(nil)); end
-
-  def assert_not_predicate(o1, op, msg=T.unsafe(nil)); end
-
-  def assert_not_respond_to(obj, meth, msg=T.unsafe(nil)); end
-
-  def assert_not_same(exp, act, msg=T.unsafe(nil)); end
-
-  def assert_raise(*exp); end
-
-  def file_fixture_path(); end
-
-  def file_fixture_path?(); end
-
-  def method_name(); end
-end
-
-ActiveSupport::TestCase::Assertion = Minitest::Assertion
-
-class ActiveSupport::TestCase
-  extend ::ActiveSupport::Callbacks::ClassMethods
-  extend ::ActiveSupport::DescendantsTracker
-  def self.__callbacks(); end
-
-  def self.__callbacks=(value); end
-
-  def self.__callbacks?(); end
-
-  def self._setup_callbacks(); end
-
-  def self._setup_callbacks=(value); end
-
-  def self._teardown_callbacks(); end
-
-  def self._teardown_callbacks=(value); end
-
-  def self.file_fixture_path(); end
-
-  def self.file_fixture_path=(value); end
-
-  def self.file_fixture_path?(); end
-
-  def self.parallelize(workers: T.unsafe(nil), with: T.unsafe(nil)); end
-
-  def self.parallelize_setup(&block); end
-
-  def self.parallelize_teardown(&block); end
-
-  def self.test_order=(new_order); end
-end
-
-module ActiveSupport::Testing::Assertions
-  def assert_changes(expression, message=T.unsafe(nil), from: T.unsafe(nil), to: T.unsafe(nil), &block); end
-
-  def assert_difference(expression, *args, &block); end
-
-  def assert_no_changes(expression, message=T.unsafe(nil), &block); end
-
-  def assert_no_difference(expression, message=T.unsafe(nil), &block); end
-
-  def assert_not(object, message=T.unsafe(nil)); end
-
-  def assert_nothing_raised(); end
-  UNTRACKED = ::T.let(nil, ::T.untyped)
-end
-
-module ActiveSupport::Testing::Assertions
-end
-
-module ActiveSupport::Testing::Deprecation
-  def assert_deprecated(match=T.unsafe(nil), deprecator=T.unsafe(nil), &block); end
-
-  def assert_not_deprecated(deprecator=T.unsafe(nil), &block); end
-
-  def collect_deprecations(deprecator=T.unsafe(nil)); end
-end
-
-module ActiveSupport::Testing::Deprecation
-end
-
-module ActiveSupport::Testing::FileFixtures
-  def file_fixture(fixture_name); end
-end
-
-module ActiveSupport::Testing::FileFixtures
-  extend ::ActiveSupport::Concern
-end
-
-module ActiveSupport::Testing::SetupAndTeardown
-  def after_teardown(); end
-
-  def before_setup(); end
-end
-
-module ActiveSupport::Testing::SetupAndTeardown
-  def self.prepended(klass); end
-end
-
-module ActiveSupport::Testing::TaggedLogging
-  def before_setup(); end
-
-  def tagged_logger=(tagged_logger); end
-end
-
-module ActiveSupport::Testing::TaggedLogging
-end
-
-module ActiveSupport::Testing::TimeHelpers
-  def after_teardown(); end
-
-  def freeze_time(&block); end
-
-  def travel(duration, &block); end
-
-  def travel_back(); end
-
-  def travel_to(date_or_time); end
-
-  def unfreeze_time(); end
-end
-
-module ActiveSupport::Testing::TimeHelpers
-end
-
-class ActiveSupport::TimeWithZone
-  include ::DateAndTime::Compatibility
-  include ::Comparable
-  def +(other); end
-
-  def -(other); end
-
-  def acts_like_time?(); end
-
-  def advance(options); end
-
-  def after?(arg); end
-
-  def ago(other); end
-
-  def before?(arg); end
-
-  def between?(min, max); end
-
-  def change(options); end
-
-  def comparable_time(); end
-
-  def day(); end
-
-  def dst?(); end
-
-  def encode_with(coder); end
-
-  def eql?(other); end
-
-  def formatted_offset(colon=T.unsafe(nil), alternate_utc_string=T.unsafe(nil)); end
-
-  def future?(); end
-
-  def getgm(); end
-
-  def getlocal(utc_offset=T.unsafe(nil)); end
-
-  def getutc(); end
-
-  def gmt?(); end
-
-  def gmt_offset(); end
-
-  def gmtime(); end
-
-  def gmtoff(); end
-
-  def hour(); end
-
-  def httpdate(); end
-
-  def in(other); end
-
-  def in_time_zone(new_zone=T.unsafe(nil)); end
-
-  def init_with(coder); end
-
-  def initialize(utc_time, time_zone, local_time=T.unsafe(nil), period=T.unsafe(nil)); end
-
-  def is_a?(klass); end
-
-  def isdst(); end
-
-  def iso8601(fraction_digits=T.unsafe(nil)); end
-
-  def kind_of?(klass); end
-
-  def localtime(utc_offset=T.unsafe(nil)); end
-
-  def marshal_dump(); end
-
-  def marshal_load(variables); end
-
-  def mday(); end
-
-  def method_missing(sym, *args, &block); end
-
-  def min(); end
-
-  def mon(); end
-
-  def month(); end
-
-  def next_day?(); end
-
-  def nsec(); end
-
-  def past?(); end
-
-  def period(); end
-
-  def prev_day?(); end
-
-  def respond_to?(sym, include_priv=T.unsafe(nil)); end
-
-  def rfc2822(); end
-
-  def rfc3339(fraction_digits=T.unsafe(nil)); end
-
-  def rfc822(); end
-
-  def sec(); end
-
-  def since(other); end
-
-  def strftime(format); end
-
-  def time(); end
-
-  def time_zone(); end
-
-  def to_a(); end
-
-  def to_date(); end
-
-  def to_datetime(); end
-
-  def to_f(); end
-
-  def to_formatted_s(format=T.unsafe(nil)); end
-
-  def to_i(); end
-
-  def to_r(); end
-
-  def to_s(format=T.unsafe(nil)); end
-
-  def to_time(); end
-
-  def today?(); end
-
-  def tomorrow?(); end
-
-  def tv_sec(); end
-
-  def usec(); end
-
-  def utc(); end
-
-  def utc?(); end
-
-  def utc_offset(); end
-
-  def wday(); end
-
-  def xmlschema(fraction_digits=T.unsafe(nil)); end
-
-  def yday(); end
-
-  def year(); end
-
-  def yesterday?(); end
-
-  def zone(); end
-  PRECISIONS = ::T.let(nil, ::T.untyped)
-  SECONDS_PER_DAY = ::T.let(nil, ::T.untyped)
-end
-
-class ActiveSupport::TimeWithZone
-end
-
-module ActiveSupport::Tryable
-  def try(method_name=T.unsafe(nil), *args, &b); end
-
-  def try!(method_name=T.unsafe(nil), *args, &b); end
-end
-
-module ActiveSupport::Tryable
-end
-
-module ActiveSupport::VERSION
-  MAJOR = ::T.let(nil, ::T.untyped)
-  MINOR = ::T.let(nil, ::T.untyped)
-  PRE = ::T.let(nil, ::T.untyped)
-  STRING = ::T.let(nil, ::T.untyped)
-  TINY = ::T.let(nil, ::T.untyped)
-end
-
-module ActiveSupport::VERSION
-end
-
-module ActiveSupport::XmlMini
-  def backend(); end
-
-  def backend=(name); end
-
-  def depth(); end
-
-  def depth=(depth); end
-
-  def parse(*args, &block); end
-
-  def rename_key(key, options=T.unsafe(nil)); end
-
-  def to_tag(key, value, options); end
-
-  def with_backend(name); end
-  DEFAULT_ENCODINGS = ::T.let(nil, ::T.untyped)
-  FORMATTING = ::T.let(nil, ::T.untyped)
-  PARSING = ::T.let(nil, ::T.untyped)
-  TYPE_NAMES = ::T.let(nil, ::T.untyped)
-end
-
-module ActiveSupport::XmlMini::FileLike
-  def content_type(); end
-
-  def content_type=(content_type); end
-
-  def original_filename(); end
-
-  def original_filename=(original_filename); end
-end
-
-module ActiveSupport::XmlMini::FileLike
-end
-
-module ActiveSupport::XmlMini
-  extend ::ActiveSupport::XmlMini
-end
-
-module ActiveSupport::XmlMini_REXML
-  def parse(data); end
-  CONTENT_KEY = ::T.let(nil, ::T.untyped)
-end
-
-module ActiveSupport::XmlMini_REXML
-  extend ::ActiveSupport::XmlMini_REXML
-end
-
 module ActiveSupport
-  extend ::ActiveSupport::Autoload
   def self.escape_html_entities_in_json(*args, &block); end
 
   def self.escape_html_entities_in_json=(arg); end
 
-  def self.gem_version(); end
-
   def self.json_encoder(*args, &block); end
 
   def self.json_encoder=(arg); end
@@ -2708,123 +43,13 @@ module ActiveSupport
 
   def self.parse_json_times=(val); end
 
-  def self.test_order(); end
-
-  def self.test_order=(val); end
-
   def self.time_precision(*args, &block); end
 
   def self.time_precision=(arg); end
 
-  def self.to_time_preserves_timezone(); end
-
-  def self.to_time_preserves_timezone=(value); end
-
   def self.use_standard_json_time_format(*args, &block); end
 
   def self.use_standard_json_time_format=(arg); end
-
-  def self.utc_to_local_returns_utc_offset_times(); end
-
-  def self.utc_to_local_returns_utc_offset_times=(value); end
-
-  def self.version(); end
-end
-
-class Addressable::Template
-  def ==(template); end
-
-  def eql?(template); end
-
-  def expand(mapping, processor=T.unsafe(nil), normalize_values=T.unsafe(nil)); end
-
-  def extract(uri, processor=T.unsafe(nil)); end
-
-  def initialize(pattern); end
-
-  def keys(); end
-
-  def match(uri, processor=T.unsafe(nil)); end
-
-  def named_captures(); end
-
-  def names(); end
-
-  def partial_expand(mapping, processor=T.unsafe(nil), normalize_values=T.unsafe(nil)); end
-
-  def pattern(); end
-
-  def source(); end
-
-  def to_regexp(); end
-
-  def variable_defaults(); end
-
-  def variables(); end
-  EXPRESSION = ::T.let(nil, ::T.untyped)
-  JOINERS = ::T.let(nil, ::T.untyped)
-  LEADERS = ::T.let(nil, ::T.untyped)
-  RESERVED = ::T.let(nil, ::T.untyped)
-  UNRESERVED = ::T.let(nil, ::T.untyped)
-  VARIABLE_LIST = ::T.let(nil, ::T.untyped)
-  VARNAME = ::T.let(nil, ::T.untyped)
-  VARSPEC = ::T.let(nil, ::T.untyped)
-end
-
-class Addressable::Template::InvalidTemplateOperatorError
-end
-
-class Addressable::Template::InvalidTemplateOperatorError
-end
-
-class Addressable::Template::InvalidTemplateValueError
-end
-
-class Addressable::Template::InvalidTemplateValueError
-end
-
-class Addressable::Template::MatchData
-  def [](key, len=T.unsafe(nil)); end
-
-  def captures(); end
-
-  def initialize(uri, template, mapping); end
-
-  def keys(); end
-
-  def mapping(); end
-
-  def names(); end
-
-  def post_match(); end
-
-  def pre_match(); end
-
-  def string(); end
-
-  def template(); end
-
-  def to_a(); end
-
-  def uri(); end
-
-  def values(); end
-
-  def values_at(*indexes); end
-
-  def variables(); end
-end
-
-class Addressable::Template::MatchData
-end
-
-class Addressable::Template::TemplateOperatorAbortedError
-end
-
-class Addressable::Template::TemplateOperatorAbortedError
-end
-
-class Addressable::Template
 end
 
 class Addrinfo
@@ -2837,13 +62,8 @@ class Archive
 end
 
 class Array
-  include ::MessagePack::CoreExt
   def abbrev(pattern=T.unsafe(nil)); end
 
-  def compact_blank!(); end
-
-  def extract_options!(); end
-
   def fifth(); end
 
   def forty_two(); end
@@ -2866,26 +86,16 @@ class Array
 
   def to_default_s(); end
 
-  def to_formatted_s(format=T.unsafe(nil)); end
-
   def to_h(); end
-
-  def to_sentence(options=T.unsafe(nil)); end
-
-  def to_xml(options=T.unsafe(nil)); end
 end
 
 class Array
   def self.parse(string); end
 
   def self.try_convert(arg); end
-
-  def self.wrap(object); end
 end
 
 class BasicObject
-  def __binding__(); end
-
   def as_null_object(); end
 
   def null_object?(); end
@@ -2941,295 +151,8 @@ class Binding
   def irb(); end
 end
 
-module Blank
-end
-
-module Blank
-  def self.included(base); end
-end
-
-module Bootsnap
-  def bundler?(); end
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
-module Bootsnap::CompileCache
-end
-
-class Bootsnap::CompileCache::Error
-end
-
-class Bootsnap::CompileCache::Error
-end
-
-class Bootsnap::CompileCache::PermissionError
-end
-
-class Bootsnap::CompileCache::PermissionError
-end
-
-module Bootsnap::CompileCache
-  def self.permission_error(path); end
-
-  def self.setup(cache_dir:, iseq:, yaml:); end
-
-  def self.supported?(); end
-end
-
-module Bootsnap::ExplicitRequire
-  ARCHDIR = ::T.let(nil, ::T.untyped)
-  DLEXT = ::T.let(nil, ::T.untyped)
-  RUBYLIBDIR = ::T.let(nil, ::T.untyped)
-end
-
-module Bootsnap::ExplicitRequire
-  def self.from_archdir(feature); end
-
-  def self.from_rubylibdir(feature); end
-
-  def self.from_self(feature); end
-
-  def self.with_gems(*gems); end
-end
-
-class Bootsnap::InvalidConfiguration
-end
-
-class Bootsnap::InvalidConfiguration
-end
-
 module Bootsnap::LoadPathCache
-  CACHED_EXTENSIONS = ::T.let(nil, ::T.untyped)
-  DLEXT = ::T.let(nil, ::T.untyped)
   DLEXT2 = ::T.let(nil, ::T.untyped)
-  DL_EXTENSIONS = ::T.let(nil, ::T.untyped)
-  DOT_RB = ::T.let(nil, ::T.untyped)
-  DOT_SO = ::T.let(nil, ::T.untyped)
-  ERROR_TAG_IVAR = ::T.let(nil, ::T.untyped)
-  SLASH = ::T.let(nil, ::T.untyped)
-end
-
-class Bootsnap::LoadPathCache::Cache
-  def absolute_path?(path); end
-
-  def find(feature); end
-
-  def initialize(store, path_obj, development_mode: T.unsafe(nil)); end
-
-  def load_dir(dir); end
-
-  def push_paths(sender, *paths); end
-
-  def reinitialize(path_obj=T.unsafe(nil)); end
-
-  def unshift_paths(sender, *paths); end
-  AGE_THRESHOLD = ::T.let(nil, ::T.untyped)
-  BUILTIN_FEATURES = ::T.let(nil, ::T.untyped)
-end
-
-class Bootsnap::LoadPathCache::Cache
-end
-
-module Bootsnap::LoadPathCache::ChangeObserver
-end
-
-module Bootsnap::LoadPathCache::ChangeObserver::ArrayMixin
-  def <<(entry); end
-
-  def []=(*args, &block); end
-
-  def append(*entries); end
-
-  def clear(*args, &block); end
-
-  def collect!(*args, &block); end
-
-  def compact!(*args, &block); end
-
-  def concat(entries); end
-
-  def delete(*args, &block); end
-
-  def delete_at(*args, &block); end
-
-  def delete_if(*args, &block); end
-
-  def fill(*args, &block); end
-
-  def flatten!(*args, &block); end
-
-  def insert(*args, &block); end
-
-  def keep_if(*args, &block); end
-
-  def map!(*args, &block); end
-
-  def pop(*args, &block); end
-
-  def prepend(*entries); end
-
-  def push(*entries); end
-
-  def reject!(*args, &block); end
-
-  def replace(*args, &block); end
-
-  def reverse!(*args, &block); end
-
-  def rotate!(*args, &block); end
-
-  def select!(*args, &block); end
-
-  def shift(*args, &block); end
-
-  def shuffle!(*args, &block); end
-
-  def slice!(*args, &block); end
-
-  def sort!(*args, &block); end
-
-  def sort_by!(*args, &block); end
-
-  def uniq!(*args); end
-
-  def unshift(*entries); end
-end
-
-module Bootsnap::LoadPathCache::ChangeObserver::ArrayMixin
-end
-
-module Bootsnap::LoadPathCache::ChangeObserver
-  def self.register(observer, arr); end
-end
-
-class Bootsnap::LoadPathCache::FallbackScan
-end
-
-class Bootsnap::LoadPathCache::FallbackScan
-end
-
-class Bootsnap::LoadPathCache::LoadedFeaturesIndex
-  def key?(feature); end
-
-  def purge(feature); end
-
-  def purge_multi(features); end
-
-  def register(short, long=T.unsafe(nil)); end
-end
-
-class Bootsnap::LoadPathCache::LoadedFeaturesIndex
-end
-
-class Bootsnap::LoadPathCache::Path
-  def entries_and_dirs(store); end
-
-  def expanded_path(); end
-
-  def initialize(path); end
-
-  def non_directory?(); end
-
-  def path(); end
-
-  def relative?(); end
-
-  def stable?(); end
-
-  def volatile?(); end
-  RUBY_LIBDIR = ::T.let(nil, ::T.untyped)
-  RUBY_SITEDIR = ::T.let(nil, ::T.untyped)
-  STABLE = ::T.let(nil, ::T.untyped)
-  VOLATILE = ::T.let(nil, ::T.untyped)
-end
-
-class Bootsnap::LoadPathCache::Path
-end
-
-module Bootsnap::LoadPathCache::PathScanner
-  ALTERNATIVE_NATIVE_EXTENSIONS_PATTERN = ::T.let(nil, ::T.untyped)
-  BUNDLE_PATH = ::T.let(nil, ::T.untyped)
-  NORMALIZE_NATIVE_EXTENSIONS = ::T.let(nil, ::T.untyped)
-  REQUIRABLE_EXTENSIONS = ::T.let(nil, ::T.untyped)
-end
-
-module Bootsnap::LoadPathCache::PathScanner
-  def self.call(path); end
-
-  def self.os_path(path); end
-
-  def self.walk(absolute_dir_path, relative_dir_path, &block); end
-end
-
-class Bootsnap::LoadPathCache::RealpathCache
-  def call(*key); end
-end
-
-class Bootsnap::LoadPathCache::RealpathCache
-end
-
-class Bootsnap::LoadPathCache::ReturnFalse
-end
-
-class Bootsnap::LoadPathCache::ReturnFalse
-end
-
-class Bootsnap::LoadPathCache::Store
-  def fetch(key); end
-
-  def get(key); end
-
-  def initialize(store_path); end
-
-  def set(key, value); end
-
-  def transaction(); end
-end
-
-class Bootsnap::LoadPathCache::Store::NestedTransactionError
-end
-
-class Bootsnap::LoadPathCache::Store::NestedTransactionError
-end
-
-class Bootsnap::LoadPathCache::Store::SetOutsideTransactionNotAllowed
-end
-
-class Bootsnap::LoadPathCache::Store::SetOutsideTransactionNotAllowed
-end
-
-class Bootsnap::LoadPathCache::Store
-end
-
-module Bootsnap::LoadPathCache
-  def self.load_path_cache(); end
-
-  def self.loaded_features_index(); end
-
-  def self.realpath_cache(); end
-
-  def self.setup(cache_path:, development_mode:); end
-
-  def self.supported?(); end
-end
-
-module Bootsnap
-  extend ::Bootsnap
-  def self._instrument(event, path); end
-
-  def self.default_setup(); end
-
-  def self.instrumentation=(callback); end
-
-  def self.iseq_cache_supported?(); end
-
-  def self.log!(); end
-
-  def self.logger(); end
-
-  def self.logger=(logger); end
-
-  def self.setup(cache_dir:, development_mode: T.unsafe(nil), load_path_cache: T.unsafe(nil), autoload_paths_cache: T.unsafe(nil), disable_trace: T.unsafe(nil), compile_cache_iseq: T.unsafe(nil), compile_cache_yaml: T.unsafe(nil)); end
 end
 
 class BottleSpecification
@@ -5886,8 +2809,6 @@ end
 class Class
   def any_instance(); end
 
-  def class_attribute(*attrs, instance_accessor: T.unsafe(nil), instance_reader: T.unsafe(nil), instance_writer: T.unsafe(nil), instance_predicate: T.unsafe(nil), default: T.unsafe(nil)); end
-
   def json_creatable?(); end
 end
 
@@ -5896,732 +2817,6 @@ class Cleaner
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
-module CodeRay
-  CODERAY_PATH = ::T.let(nil, ::T.untyped)
-  TokenKinds = ::T.let(nil, ::T.untyped)
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
-class CodeRay::Duo
-  def call(code, options=T.unsafe(nil)); end
-
-  def encode(code, options=T.unsafe(nil)); end
-
-  def encoder(); end
-
-  def format(); end
-
-  def format=(format); end
-
-  def highlight(code, options=T.unsafe(nil)); end
-
-  def initialize(lang=T.unsafe(nil), format=T.unsafe(nil), options=T.unsafe(nil)); end
-
-  def lang(); end
-
-  def lang=(lang); end
-
-  def options(); end
-
-  def options=(options); end
-
-  def scanner(); end
-end
-
-class CodeRay::Duo
-  def self.[](*arg); end
-end
-
-module CodeRay::Encoders
-end
-
-class CodeRay::Encoders::Encoder
-  def <<(token); end
-
-  def begin_group(kind); end
-
-  def begin_line(kind); end
-
-  def compile(tokens, options=T.unsafe(nil)); end
-
-  def encode(code, lang, options=T.unsafe(nil)); end
-
-  def encode_tokens(tokens, options=T.unsafe(nil)); end
-
-  def end_group(kind); end
-
-  def end_line(kind); end
-
-  def file_extension(); end
-
-  def finish(options); end
-
-  def get_output(options); end
-
-  def highlight(code, lang, options=T.unsafe(nil)); end
-
-  def initialize(options=T.unsafe(nil)); end
-
-  def options(); end
-
-  def options=(options); end
-
-  def output(data); end
-
-  def scanner(); end
-
-  def scanner=(scanner); end
-
-  def setup(options); end
-
-  def text_token(text, kind); end
-
-  def token(content, kind); end
-
-  def tokens(tokens, options=T.unsafe(nil)); end
-  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
-end
-
-CodeRay::Encoders::Encoder::PLUGIN_HOST = CodeRay::Encoders
-
-class CodeRay::Encoders::Encoder
-  extend ::CodeRay::Plugin
-  def self.const_missing(sym); end
-
-  def self.file_extension(); end
-end
-
-class CodeRay::Encoders::Terminal
-  TOKEN_COLORS = ::T.let(nil, ::T.untyped)
-end
-
-class CodeRay::Encoders::Terminal
-end
-
-module CodeRay::Encoders
-  extend ::CodeRay::PluginHost
-end
-
-module CodeRay::FileType
-  TypeFromExt = ::T.let(nil, ::T.untyped)
-  TypeFromName = ::T.let(nil, ::T.untyped)
-  TypeFromShebang = ::T.let(nil, ::T.untyped)
-end
-
-class CodeRay::FileType::UnknownFileType
-end
-
-class CodeRay::FileType::UnknownFileType
-end
-
-module CodeRay::FileType
-  def self.[](filename, read_shebang=T.unsafe(nil)); end
-
-  def self.fetch(filename, default=T.unsafe(nil), read_shebang=T.unsafe(nil)); end
-
-  def self.type_from_shebang(filename); end
-end
-
-module CodeRay::Plugin
-  def aliases(); end
-
-  def plugin_host(host=T.unsafe(nil)); end
-
-  def plugin_id(); end
-
-  def register_for(id); end
-
-  def title(title=T.unsafe(nil)); end
-end
-
-module CodeRay::Plugin
-end
-
-module CodeRay::PluginHost
-  def [](id, *args, &blk); end
-
-  def all_plugins(); end
-
-  def const_missing(const); end
-
-  def default(id=T.unsafe(nil)); end
-
-  def list(); end
-
-  def load(id, *args, &blk); end
-
-  def load_all(); end
-
-  def load_plugin_map(); end
-
-  def make_plugin_hash(); end
-
-  def map(hash); end
-
-  def path_to(plugin_id); end
-
-  def plugin_hash(); end
-
-  def plugin_path(*args); end
-
-  def register(plugin, id); end
-
-  def validate_id(id); end
-  PLUGIN_HOSTS = ::T.let(nil, ::T.untyped)
-  PLUGIN_HOSTS_BY_ID = ::T.let(nil, ::T.untyped)
-end
-
-class CodeRay::PluginHost::HostNotFound
-end
-
-class CodeRay::PluginHost::HostNotFound
-end
-
-class CodeRay::PluginHost::PluginNotFound
-end
-
-class CodeRay::PluginHost::PluginNotFound
-end
-
-module CodeRay::PluginHost
-  def self.extended(mod); end
-end
-
-module CodeRay::Scanners
-end
-
-class CodeRay::Scanners::Scanner
-  include ::Enumerable
-  def binary_string(); end
-
-  def column(pos=T.unsafe(nil)); end
-
-  def each(&block); end
-
-  def file_extension(); end
-
-  def initialize(code=T.unsafe(nil), options=T.unsafe(nil)); end
-
-  def lang(); end
-
-  def line(pos=T.unsafe(nil)); end
-
-  def raise_inspect(message, tokens, state=T.unsafe(nil), ambit=T.unsafe(nil), backtrace=T.unsafe(nil)); end
-
-  def raise_inspect_arguments(message, tokens, state, ambit); end
-
-  def reset_instance(); end
-
-  def scan_rest(); end
-
-  def scan_tokens(tokens, options); end
-
-  def scanner_state_info(state); end
-
-  def set_string_from_source(source); end
-
-  def set_tokens_from_options(options); end
-
-  def setup(); end
-
-  def state(); end
-
-  def state=(state); end
-
-  def string=(code); end
-
-  def tokenize(source=T.unsafe(nil), options=T.unsafe(nil)); end
-
-  def tokens(); end
-
-  def tokens_last(tokens, n); end
-
-  def tokens_size(tokens); end
-  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
-  KINDS_NOT_LOC = ::T.let(nil, ::T.untyped)
-  SCANNER_STATE_INFO = ::T.let(nil, ::T.untyped)
-  SCAN_ERROR_MESSAGE = ::T.let(nil, ::T.untyped)
-end
-
-CodeRay::Scanners::Scanner::PLUGIN_HOST = CodeRay::Scanners
-
-class CodeRay::Scanners::Scanner::ScanError
-end
-
-class CodeRay::Scanners::Scanner::ScanError
-end
-
-class CodeRay::Scanners::Scanner
-  extend ::CodeRay::Plugin
-  def self.encode_with_encoding(code, target_encoding); end
-
-  def self.encoding(name=T.unsafe(nil)); end
-
-  def self.file_extension(extension=T.unsafe(nil)); end
-
-  def self.guess_encoding(s); end
-
-  def self.lang(); end
-
-  def self.normalize(code); end
-
-  def self.to_unix(code); end
-end
-
-module CodeRay::Scanners
-  extend ::CodeRay::PluginHost
-end
-
-module CodeRay::Styles
-end
-
-class CodeRay::Styles::Style
-  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
-end
-
-CodeRay::Styles::Style::PLUGIN_HOST = CodeRay::Styles
-
-class CodeRay::Styles::Style
-  extend ::CodeRay::Plugin
-end
-
-module CodeRay::Styles
-  extend ::CodeRay::PluginHost
-end
-
-class CodeRay::Tokens
-  def begin_group(kind); end
-
-  def begin_line(kind); end
-
-  def count(); end
-
-  def encode(encoder, options=T.unsafe(nil)); end
-
-  def end_group(kind); end
-
-  def end_line(kind); end
-
-  def method_missing(meth, options=T.unsafe(nil)); end
-
-  def scanner(); end
-
-  def scanner=(scanner); end
-
-  def split_into_parts(*sizes); end
-
-  def text_token(*arg); end
-
-  def to_s(); end
-
-  def tokens(*arg); end
-end
-
-class CodeRay::Tokens
-end
-
-class CodeRay::TokensProxy
-  def block(); end
-
-  def block=(block); end
-
-  def each(*args, &blk); end
-
-  def encode(encoder, options=T.unsafe(nil)); end
-
-  def initialize(input, lang, options=T.unsafe(nil), block=T.unsafe(nil)); end
-
-  def input(); end
-
-  def input=(input); end
-
-  def lang(); end
-
-  def lang=(lang); end
-
-  def method_missing(method, *args, &blk); end
-
-  def options(); end
-
-  def options=(options); end
-
-  def scanner(); end
-
-  def tokens(); end
-end
-
-class CodeRay::TokensProxy
-end
-
-module CodeRay
-  def self.coderay_path(*path); end
-
-  def self.encode(code, lang, format, options=T.unsafe(nil)); end
-
-  def self.encode_file(filename, format, options=T.unsafe(nil)); end
-
-  def self.encode_tokens(tokens, format, options=T.unsafe(nil)); end
-
-  def self.encoder(format, options=T.unsafe(nil)); end
-
-  def self.get_scanner_options(options); end
-
-  def self.highlight(code, lang, options=T.unsafe(nil), format=T.unsafe(nil)); end
-
-  def self.highlight_file(filename, options=T.unsafe(nil), format=T.unsafe(nil)); end
-
-  def self.scan(code, lang, options=T.unsafe(nil), &block); end
-
-  def self.scan_file(filename, lang=T.unsafe(nil), options=T.unsafe(nil), &block); end
-
-  def self.scanner(lang, options=T.unsafe(nil), &block); end
-end
-
-module Commander
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
-class Commander::Command
-  def action(*args, &block); end
-
-  def call(args=T.unsafe(nil)); end
-
-  def description(); end
-
-  def description=(description); end
-
-  def example(description, command); end
-
-  def examples(); end
-
-  def examples=(examples); end
-
-  def global_options(); end
-
-  def initialize(name); end
-
-  def name(); end
-
-  def name=(name); end
-
-  def option(*args, &block); end
-
-  def option_proc(switches); end
-
-  def options(); end
-
-  def options=(options); end
-
-  def parse_options_and_call_procs(*args); end
-
-  def proxy_option_struct(); end
-
-  def proxy_options(); end
-
-  def proxy_options=(proxy_options); end
-
-  def run(*args); end
-
-  def summary(); end
-
-  def summary=(summary); end
-
-  def syntax(); end
-
-  def syntax=(syntax); end
-
-  def when_called(*args, &block); end
-end
-
-class Commander::Command::Options
-  include ::Blank
-  def __hash__(); end
-
-  def default(defaults=T.unsafe(nil)); end
-
-  def method_missing(meth, *args); end
-end
-
-class Commander::Command::Options
-end
-
-class Commander::Command
-end
-
-module Commander::Delegates
-  def add_command(*args, &block); end
-
-  def alias_command(*args, &block); end
-
-  def always_trace!(*args, &block); end
-
-  def command(*args, &block); end
-
-  def default_command(*args, &block); end
-
-  def defined_commands(*args, &block); end
-
-  def global_option(*args, &block); end
-
-  def never_trace!(*args, &block); end
-
-  def program(*args, &block); end
-
-  def run!(*args, &block); end
-end
-
-module Commander::Delegates
-end
-
-module Commander::HelpFormatter
-end
-
-class Commander::HelpFormatter::Base
-  def initialize(runner); end
-
-  def render(); end
-
-  def render_command(command); end
-end
-
-class Commander::HelpFormatter::Base
-end
-
-class Commander::HelpFormatter::Context
-  def decorate_binding(_bind); end
-
-  def initialize(target); end
-end
-
-class Commander::HelpFormatter::Context
-end
-
-class Commander::HelpFormatter::ProgramContext
-  def decorate_binding(bind); end
-
-  def max_aliases_length(bind); end
-
-  def max_command_length(bind); end
-
-  def max_key_length(hash, default=T.unsafe(nil)); end
-end
-
-class Commander::HelpFormatter::ProgramContext
-end
-
-class Commander::HelpFormatter::Terminal
-  def template(name); end
-end
-
-class Commander::HelpFormatter::Terminal
-end
-
-class Commander::HelpFormatter::TerminalCompact
-end
-
-class Commander::HelpFormatter::TerminalCompact
-end
-
-module Commander::HelpFormatter
-  def self.indent(amount, text); end
-end
-
-module Commander::Methods
-  include ::Commander::UI
-  include ::Commander::UI::AskForClass
-  include ::Commander::Delegates
-end
-
-module Commander::Methods
-end
-
-module Commander::Platform
-end
-
-module Commander::Platform
-  def self.jruby?(); end
-end
-
-class Commander::Runner
-  def active_command(); end
-
-  def add_command(command); end
-
-  def alias?(name); end
-
-  def alias_command(alias_name, name, *args); end
-
-  def always_trace!(); end
-
-  def args_without_command_name(); end
-
-  def command(name, &block); end
-
-  def command_exists?(name); end
-
-  def command_name_from_args(); end
-
-  def commands(); end
-
-  def create_default_commands(); end
-
-  def default_command(name); end
-
-  def expand_optionally_negative_switches(switches); end
-
-  def global_option(*args, &block); end
-
-  def global_option_proc(switches, &block); end
-
-  def help_formatter(); end
-
-  def help_formatter_alias_defaults(); end
-
-  def help_formatter_aliases(); end
-
-  def initialize(args=T.unsafe(nil)); end
-
-  def never_trace!(); end
-
-  def options(); end
-
-  def parse_global_options(); end
-
-  def program(key, *args, &block); end
-
-  def program_defaults(); end
-
-  def remove_global_options(options, args); end
-
-  def require_program(*keys); end
-
-  def require_valid_command(command=T.unsafe(nil)); end
-
-  def run!(); end
-
-  def run_active_command(); end
-
-  def say(*args); end
-
-  def valid_command_names_from(*args); end
-
-  def version(); end
-end
-
-class Commander::Runner::CommandError
-end
-
-class Commander::Runner::CommandError
-end
-
-class Commander::Runner::InvalidCommandError
-end
-
-class Commander::Runner::InvalidCommandError
-end
-
-class Commander::Runner
-  def self.instance(); end
-
-  def self.separate_switches_from_description(*args); end
-
-  def self.switch_to_sym(switch); end
-end
-
-module Commander::UI
-end
-
-module Commander::UI::AskForClass
-  def ask_for_array(prompt); end
-
-  def ask_for_file(prompt); end
-
-  def ask_for_float(prompt); end
-
-  def ask_for_integer(prompt); end
-
-  def ask_for_pathname(prompt); end
-
-  def ask_for_regexp(prompt); end
-
-  def ask_for_string(prompt); end
-
-  def ask_for_symbol(prompt); end
-
-  def method_missing(method_name, *arguments, &block); end
-  DEPRECATED_CONSTANTS = ::T.let(nil, ::T.untyped)
-end
-
-module Commander::UI::AskForClass
-end
-
-class Commander::UI::ProgressBar
-  def completed?(); end
-
-  def erase_line(); end
-
-  def finished?(); end
-
-  def generate_tokens(); end
-
-  def increment(tokens=T.unsafe(nil)); end
-
-  def initialize(total, options=T.unsafe(nil)); end
-
-  def percent_complete(); end
-
-  def progress_bar(); end
-
-  def show(); end
-
-  def steps_remaining(); end
-
-  def time_elapsed(); end
-
-  def time_remaining(); end
-end
-
-class Commander::UI::ProgressBar
-end
-
-module Commander::UI
-  def self.applescript(script); end
-
-  def self.ask_editor(input=T.unsafe(nil), preferred_editor=T.unsafe(nil)); end
-
-  def self.available_editor(preferred=T.unsafe(nil)); end
-
-  def self.choose(message=T.unsafe(nil), *choices, &block); end
-
-  def self.color(*args); end
-
-  def self.converse(prompt, responses=T.unsafe(nil)); end
-
-  def self.enable_paging(); end
-
-  def self.io(input=T.unsafe(nil), output=T.unsafe(nil), &block); end
-
-  def self.log(action, *args); end
-
-  def self.password(message=T.unsafe(nil), mask=T.unsafe(nil)); end
-
-  def self.progress(arr, options=T.unsafe(nil)); end
-
-  def self.replace_tokens(str, hash); end
-
-  def self.say_error(*args); end
-
-  def self.say_ok(*args); end
-
-  def self.say_warning(*args); end
-
-  def self.speak(message, voice=T.unsafe(nil), rate=T.unsafe(nil)); end
-end
-
-module Commander
-  def self.configure(*configuration_opts, &configuration_block); end
-end
-
 class CompilerSelector::Compiler
   def self.[](*arg); end
 
@@ -6849,57 +3044,14 @@ DRbObject = DRb::DRbObject
 DRbUndumped = DRb::DRbUndumped
 
 class Date
-  include ::DateAndTime::Calculations
-  def acts_like_date?(); end
-
-  def advance(options); end
-
-  def ago(seconds); end
-
-  def at_beginning_of_day(); end
-
-  def at_end_of_day(); end
-
-  def at_midday(); end
-
-  def at_middle_of_day(); end
-
-  def at_midnight(); end
-
-  def at_noon(); end
-
-  def beginning_of_day(); end
-
-  def change(options); end
-
-  def compare_with_coercion(other); end
-
   def compare_without_coercion(arg); end
 
   def default_inspect(); end
 
-  def end_of_day(); end
-
-  def in(seconds); end
-
-  def midday(); end
-
-  def middle_of_day(); end
-
-  def midnight(); end
-
-  def minus_with_duration(other); end
-
   def minus_without_duration(arg); end
 
-  def noon(); end
-
-  def plus_with_duration(other); end
-
   def plus_without_duration(arg); end
 
-  def since(seconds); end
-
   def to_default_s(); end
 end
 
@@ -6907,163 +3059,6 @@ class Date::Infinity
   def initialize(d=T.unsafe(nil)); end
 end
 
-class Date
-  def self.beginning_of_week(); end
-
-  def self.beginning_of_week=(week_start); end
-
-  def self.beginning_of_week_default(); end
-
-  def self.beginning_of_week_default=(beginning_of_week_default); end
-
-  def self.current(); end
-
-  def self.find_beginning_of_week!(week_start); end
-
-  def self.tomorrow(); end
-
-  def self.yesterday(); end
-end
-
-module DateAndTime::Calculations
-  def after?(date_or_time); end
-
-  def all_day(); end
-
-  def all_month(); end
-
-  def all_quarter(); end
-
-  def all_week(start_day=T.unsafe(nil)); end
-
-  def all_year(); end
-
-  def at_beginning_of_month(); end
-
-  def at_beginning_of_quarter(); end
-
-  def at_beginning_of_week(start_day=T.unsafe(nil)); end
-
-  def at_beginning_of_year(); end
-
-  def at_end_of_month(); end
-
-  def at_end_of_quarter(); end
-
-  def at_end_of_week(start_day=T.unsafe(nil)); end
-
-  def at_end_of_year(); end
-
-  def before?(date_or_time); end
-
-  def beginning_of_month(); end
-
-  def beginning_of_quarter(); end
-
-  def beginning_of_week(start_day=T.unsafe(nil)); end
-
-  def beginning_of_year(); end
-
-  def days_ago(days); end
-
-  def days_since(days); end
-
-  def days_to_week_start(start_day=T.unsafe(nil)); end
-
-  def end_of_month(); end
-
-  def end_of_quarter(); end
-
-  def end_of_week(start_day=T.unsafe(nil)); end
-
-  def end_of_year(); end
-
-  def future?(); end
-
-  def last_month(); end
-
-  def last_quarter(); end
-
-  def last_week(start_day=T.unsafe(nil), same_time: T.unsafe(nil)); end
-
-  def last_weekday(); end
-
-  def last_year(); end
-
-  def monday(); end
-
-  def months_ago(months); end
-
-  def months_since(months); end
-
-  def next_day?(); end
-
-  def next_occurring(day_of_week); end
-
-  def next_quarter(); end
-
-  def next_week(given_day_in_next_week=T.unsafe(nil), same_time: T.unsafe(nil)); end
-
-  def next_weekday(); end
-
-  def on_weekday?(); end
-
-  def on_weekend?(); end
-
-  def past?(); end
-
-  def prev_day?(); end
-
-  def prev_occurring(day_of_week); end
-
-  def prev_quarter(); end
-
-  def prev_week(start_day=T.unsafe(nil), same_time: T.unsafe(nil)); end
-
-  def prev_weekday(); end
-
-  def sunday(); end
-
-  def today?(); end
-
-  def tomorrow(); end
-
-  def tomorrow?(); end
-
-  def weeks_ago(weeks); end
-
-  def weeks_since(weeks); end
-
-  def years_ago(years); end
-
-  def years_since(years); end
-
-  def yesterday(); end
-
-  def yesterday?(); end
-  DAYS_INTO_WEEK = ::T.let(nil, ::T.untyped)
-  WEEKEND_DAYS = ::T.let(nil, ::T.untyped)
-end
-
-module DateAndTime::Calculations
-end
-
-module DateAndTime::Compatibility
-  def preserve_timezone(); end
-
-  def utc_to_local_returns_utc_offset_times(); end
-end
-
-module DateAndTime::Compatibility
-  def self.preserve_timezone(); end
-
-  def self.preserve_timezone=(val); end
-
-  def self.utc_to_local_returns_utc_offset_times(); end
-
-  def self.utc_to_local_returns_utc_offset_times=(val); end
-end
-
 class Debrew::Menu::Entry
   def self.[](*arg); end
 
@@ -7115,143 +3110,6 @@ class DevelopmentTools
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
-class DidYouMean::ClassNameChecker
-  def class_name(); end
-
-  def class_names(); end
-
-  def corrections(); end
-
-  def initialize(exception); end
-
-  def scopes(); end
-end
-
-module DidYouMean::Correctable
-  def corrections(); end
-
-  def original_message(); end
-
-  def spell_checker(); end
-
-  def to_s(); end
-end
-
-module DidYouMean::Jaro
-  def self.distance(str1, str2); end
-end
-
-module DidYouMean::JaroWinkler
-  def self.distance(str1, str2); end
-end
-
-class DidYouMean::KeyErrorChecker
-  def corrections(); end
-
-  def initialize(key_error); end
-end
-
-class DidYouMean::KeyErrorChecker
-end
-
-module DidYouMean::Levenshtein
-  def self.distance(str1, str2); end
-
-  def self.min3(a, b, c); end
-end
-
-class DidYouMean::MethodNameChecker
-  def corrections(); end
-
-  def initialize(exception); end
-
-  def method_name(); end
-
-  def method_names(); end
-
-  def names_to_exclude(); end
-
-  def receiver(); end
-  RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped)
-end
-
-class DidYouMean::NullChecker
-  def corrections(); end
-
-  def initialize(*arg); end
-end
-
-class DidYouMean::PlainFormatter
-  def message_for(corrections); end
-end
-
-class DidYouMean::PlainFormatter
-end
-
-class DidYouMean::RequirePathChecker
-  def corrections(); end
-
-  def initialize(exception); end
-
-  def path(); end
-end
-
-class DidYouMean::RequirePathChecker
-  def self.requireables(); end
-end
-
-class DidYouMean::TreeSpellChecker
-  def augment(); end
-
-  def correct(input); end
-
-  def dictionary(); end
-
-  def dictionary_without_leaves(); end
-
-  def dimensions(); end
-
-  def find_leaves(path); end
-
-  def initialize(dictionary:, separator: T.unsafe(nil), augment: T.unsafe(nil)); end
-
-  def plausible_dimensions(input); end
-
-  def possible_paths(states); end
-
-  def separator(); end
-
-  def tree_depth(); end
-end
-
-class DidYouMean::TreeSpellChecker
-end
-
-class DidYouMean::VariableNameChecker
-  def corrections(); end
-
-  def cvar_names(); end
-
-  def initialize(exception); end
-
-  def ivar_names(); end
-
-  def lvar_names(); end
-
-  def method_names(); end
-
-  def name(); end
-  RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped)
-end
-
-module DidYouMean
-  def self.correct_error(error_class, spell_checker); end
-
-  def self.formatter(); end
-
-  def self.formatter=(formatter); end
-end
-
 class Dir
   def children(); end
 
@@ -7267,58 +3125,6 @@ module DiskUsageExtension
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
-module Docile
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
-module Docile::BacktraceFilter
-  def backtrace(); end
-
-  def backtrace_locations(); end
-  FILTER_PATTERN = ::T.let(nil, ::T.untyped)
-end
-
-module Docile::BacktraceFilter
-end
-
-class Docile::ChainingFallbackContextProxy
-end
-
-class Docile::ChainingFallbackContextProxy
-end
-
-module Docile::Execution
-end
-
-module Docile::Execution
-  def self.exec_in_proxy_context(dsl, proxy_type, *args, &block); end
-end
-
-class Docile::FallbackContextProxy
-  def initialize(receiver, fallback); end
-
-  def method_missing(method, *args, &block); end
-  NON_FALLBACK_METHODS = ::T.let(nil, ::T.untyped)
-  NON_PROXIED_INSTANCE_VARIABLES = ::T.let(nil, ::T.untyped)
-  NON_PROXIED_METHODS = ::T.let(nil, ::T.untyped)
-end
-
-class Docile::FallbackContextProxy
-end
-
-module Docile
-  extend ::Docile::Execution
-  def self.dsl_eval(dsl, *args, &block); end
-
-  def self.dsl_eval_immutable(dsl, *args, &block); end
-
-  def self.dsl_eval_with_block_return(dsl, *args, &block); end
-end
-
-module ELFTools
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
 class ELFTools::Structs::ELF32_PhdrBe
 end
 
@@ -7450,31 +3256,6 @@ class ERB::Compiler::Scanner
   DEFAULT_STAGS = ::T.let(nil, ::T.untyped)
 end
 
-module ERB::Util
-  HTML_ESCAPE = ::T.let(nil, ::T.untyped)
-  HTML_ESCAPE_ONCE_REGEXP = ::T.let(nil, ::T.untyped)
-  JSON_ESCAPE = ::T.let(nil, ::T.untyped)
-  JSON_ESCAPE_REGEXP = ::T.let(nil, ::T.untyped)
-end
-
-module ERB::Util
-  def self.html_escape_once(s); end
-
-  def self.json_escape(s); end
-
-  def self.unwrapped_html_escape(s); end
-end
-
-module EcmaReValidator
-  INVALID_REGEXP = ::T.let(nil, ::T.untyped)
-  INVALID_TOKENS = ::T.let(nil, ::T.untyped)
-  UNICODE_CHARACTERS = ::T.let(nil, ::T.untyped)
-end
-
-module EcmaReValidator
-  def self.valid?(input); end
-end
-
 class EmbeddedPatch
   extend ::T::Private::Methods::MethodHooks
   extend ::T::Private::Methods::SingletonMethodHooks
@@ -7494,27 +3275,6 @@ end
 
 module Enumerable
   include ::ActiveSupport::ToJsonWithActiveSupportEncoder
-  def compact_blank(); end
-
-  def exclude?(object); end
-
-  def excluding(*elements); end
-
-  def including(*elements); end
-
-  def index_by(); end
-
-  def index_with(default=T.unsafe(nil)); end
-
-  def many?(); end
-
-  def pick(*keys); end
-
-  def pluck(*keys); end
-
-  def sum(identity=T.unsafe(nil), &block); end
-
-  def without(*elements); end
 end
 
 class Enumerator
@@ -7764,7 +3524,6 @@ class Etc::Passwd
 end
 
 class Exception
-  include ::ActiveSupport::Dependencies::Blamable
   def __bb_context(); end
 
   def to_json(*args); end
@@ -7813,10 +3572,6 @@ class ExternalPatch
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
-class FalseClass
-  include ::MessagePack::CoreExt
-end
-
 class Fiber
   def transfer(*arg); end
 end
@@ -7878,10 +3633,6 @@ module FileUtils
   extend ::FileUtils::StreamUtils_
 end
 
-class Float
-  include ::MessagePack::CoreExt
-end
-
 module FormulaCellarChecks
   extend ::T::Private::Methods::MethodHooks
   extend ::T::Private::Methods::SingletonMethodHooks
@@ -8565,110 +4316,6 @@ class HTTP::Cookie
   def self.parse(set_cookie, origin, options=T.unsafe(nil), &block); end
 end
 
-module Hana
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
-class Hana::Patch
-  def apply(doc); end
-
-  def initialize(is); end
-  FROM = ::T.let(nil, ::T.untyped)
-  VALID = ::T.let(nil, ::T.untyped)
-  VALUE = ::T.let(nil, ::T.untyped)
-end
-
-class Hana::Patch::Exception
-end
-
-class Hana::Patch::Exception
-end
-
-class Hana::Patch::FailedTestException
-  def initialize(path, value); end
-
-  def path(); end
-
-  def path=(path); end
-
-  def value(); end
-
-  def value=(value); end
-end
-
-class Hana::Patch::FailedTestException
-end
-
-class Hana::Patch::IndexError
-end
-
-class Hana::Patch::IndexError
-end
-
-class Hana::Patch::InvalidObjectOperationException
-end
-
-class Hana::Patch::InvalidObjectOperationException
-end
-
-class Hana::Patch::InvalidPath
-end
-
-class Hana::Patch::InvalidPath
-end
-
-class Hana::Patch::MissingTargetException
-end
-
-class Hana::Patch::MissingTargetException
-end
-
-class Hana::Patch::ObjectOperationOnArrayException
-end
-
-class Hana::Patch::ObjectOperationOnArrayException
-end
-
-class Hana::Patch::OutOfBoundsException
-end
-
-class Hana::Patch::OutOfBoundsException
-end
-
-class Hana::Patch
-end
-
-class Hana::Pointer
-  include ::Enumerable
-  def each(&block); end
-
-  def eval(object); end
-
-  def initialize(path); end
-  ESC = ::T.let(nil, ::T.untyped)
-end
-
-class Hana::Pointer::Exception
-end
-
-class Hana::Pointer::Exception
-end
-
-class Hana::Pointer::FormatError
-end
-
-class Hana::Pointer::FormatError
-end
-
-class Hana::Pointer
-  def self.eval(list, object); end
-
-  def self.parse(path); end
-end
-
-module Hana
-end
-
 class Hardware::CPU
   extend ::T::Private::Methods::SingletonMethodHooks
   def self.lm?(); end
@@ -8679,1093 +4326,10 @@ module Hardware
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
-class Hash
-  include ::MessagePack::CoreExt
-  def assert_valid_keys(*valid_keys); end
-
-  def compact_blank!(); end
-
-  def deep_stringify_keys(); end
-
-  def deep_stringify_keys!(); end
-
-  def deep_symbolize_keys(); end
-
-  def deep_symbolize_keys!(); end
-
-  def deep_transform_keys(&block); end
-
-  def deep_transform_keys!(&block); end
-
-  def extractable_options?(); end
-
-  def stringify_keys(); end
-
-  def stringify_keys!(); end
-
-  def symbolize_keys(); end
-
-  def symbolize_keys!(); end
-
-  def to_options(); end
-
-  def to_options!(); end
-
-  def to_param(namespace=T.unsafe(nil)); end
-
-  def to_query(namespace=T.unsafe(nil)); end
-end
-
 class Hash
   def self.try_convert(arg); end
 end
 
-class HighLine
-  include ::HighLine::BuiltinStyles
-  include ::HighLine::CustomErrors
-  def agree(yes_or_no_question, character=T.unsafe(nil)); end
-
-  def ask(template_or_question, answer_type=T.unsafe(nil), &details); end
-
-  def choose(*items, &details); end
-
-  def color(string, *colors); end
-
-  def color_code(*colors); end
-
-  def get_response_character_mode(question); end
-
-  def get_response_getc_mode(question); end
-
-  def get_response_line_mode(question); end
-
-  def indent(increase=T.unsafe(nil), statement=T.unsafe(nil), multiline=T.unsafe(nil)); end
-
-  def indent_level(); end
-
-  def indent_level=(indent_level); end
-
-  def indent_size(); end
-
-  def indent_size=(indent_size); end
-
-  def indentation(); end
-
-  def initialize(input=T.unsafe(nil), output=T.unsafe(nil), wrap_at=T.unsafe(nil), page_at=T.unsafe(nil), indent_size=T.unsafe(nil), indent_level=T.unsafe(nil)); end
-
-  def input(); end
-
-  def key(); end
-
-  def key=(key); end
-
-  def list(items, mode=T.unsafe(nil), option=T.unsafe(nil)); end
-
-  def multi_indent(); end
-
-  def multi_indent=(multi_indent); end
-
-  def new_scope(); end
-
-  def newline(); end
-
-  def output(); end
-
-  def output_cols(); end
-
-  def output_rows(); end
-
-  def page_at(); end
-
-  def page_at=(setting); end
-
-  def puts(*args); end
-
-  def render_statement(statement); end
-
-  def reset_use_color(); end
-
-  def say(statement); end
-
-  def shell_style_lambda(menu); end
-
-  def terminal(); end
-
-  def track_eof(); end
-
-  def track_eof=(track_eof); end
-
-  def track_eof?(); end
-
-  def uncolor(string); end
-
-  def use_color(); end
-
-  def use_color=(use_color); end
-
-  def use_color?(); end
-
-  def wrap_at(); end
-
-  def wrap_at=(setting); end
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
-module HighLine::BuiltinStyles
-  BASIC_COLORS = ::T.let(nil, ::T.untyped)
-  BLACK = ::T.let(nil, ::T.untyped)
-  BLACK_STYLE = ::T.let(nil, ::T.untyped)
-  BLINK = ::T.let(nil, ::T.untyped)
-  BLINK_STYLE = ::T.let(nil, ::T.untyped)
-  BLUE = ::T.let(nil, ::T.untyped)
-  BLUE_STYLE = ::T.let(nil, ::T.untyped)
-  BOLD = ::T.let(nil, ::T.untyped)
-  BOLD_STYLE = ::T.let(nil, ::T.untyped)
-  BRIGHT_BLACK = ::T.let(nil, ::T.untyped)
-  BRIGHT_BLACK_STYLE = ::T.let(nil, ::T.untyped)
-  BRIGHT_BLUE = ::T.let(nil, ::T.untyped)
-  BRIGHT_BLUE_STYLE = ::T.let(nil, ::T.untyped)
-  BRIGHT_CYAN = ::T.let(nil, ::T.untyped)
-  BRIGHT_CYAN_STYLE = ::T.let(nil, ::T.untyped)
-  BRIGHT_GRAY = ::T.let(nil, ::T.untyped)
-  BRIGHT_GRAY_STYLE = ::T.let(nil, ::T.untyped)
-  BRIGHT_GREEN = ::T.let(nil, ::T.untyped)
-  BRIGHT_GREEN_STYLE = ::T.let(nil, ::T.untyped)
-  BRIGHT_GREY = ::T.let(nil, ::T.untyped)
-  BRIGHT_GREY_STYLE = ::T.let(nil, ::T.untyped)
-  BRIGHT_MAGENTA = ::T.let(nil, ::T.untyped)
-  BRIGHT_MAGENTA_STYLE = ::T.let(nil, ::T.untyped)
-  BRIGHT_NONE = ::T.let(nil, ::T.untyped)
-  BRIGHT_NONE_STYLE = ::T.let(nil, ::T.untyped)
-  BRIGHT_RED = ::T.let(nil, ::T.untyped)
-  BRIGHT_RED_STYLE = ::T.let(nil, ::T.untyped)
-  BRIGHT_WHITE = ::T.let(nil, ::T.untyped)
-  BRIGHT_WHITE_STYLE = ::T.let(nil, ::T.untyped)
-  BRIGHT_YELLOW = ::T.let(nil, ::T.untyped)
-  BRIGHT_YELLOW_STYLE = ::T.let(nil, ::T.untyped)
-  CLEAR = ::T.let(nil, ::T.untyped)
-  CLEAR_STYLE = ::T.let(nil, ::T.untyped)
-  COLORS = ::T.let(nil, ::T.untyped)
-  COLOR_LIST = ::T.let(nil, ::T.untyped)
-  CONCEALED = ::T.let(nil, ::T.untyped)
-  CONCEALED_STYLE = ::T.let(nil, ::T.untyped)
-  CYAN = ::T.let(nil, ::T.untyped)
-  CYAN_STYLE = ::T.let(nil, ::T.untyped)
-  DARK = ::T.let(nil, ::T.untyped)
-  DARK_STYLE = ::T.let(nil, ::T.untyped)
-  ERASE_CHAR = ::T.let(nil, ::T.untyped)
-  ERASE_CHAR_STYLE = ::T.let(nil, ::T.untyped)
-  ERASE_LINE = ::T.let(nil, ::T.untyped)
-  ERASE_LINE_STYLE = ::T.let(nil, ::T.untyped)
-  GRAY = ::T.let(nil, ::T.untyped)
-  GRAY_STYLE = ::T.let(nil, ::T.untyped)
-  GREEN = ::T.let(nil, ::T.untyped)
-  GREEN_STYLE = ::T.let(nil, ::T.untyped)
-  GREY = ::T.let(nil, ::T.untyped)
-  GREY_STYLE = ::T.let(nil, ::T.untyped)
-  LIGHT_BLACK = ::T.let(nil, ::T.untyped)
-  LIGHT_BLACK_STYLE = ::T.let(nil, ::T.untyped)
-  LIGHT_BLUE = ::T.let(nil, ::T.untyped)
-  LIGHT_BLUE_STYLE = ::T.let(nil, ::T.untyped)
-  LIGHT_CYAN = ::T.let(nil, ::T.untyped)
-  LIGHT_CYAN_STYLE = ::T.let(nil, ::T.untyped)
-  LIGHT_GRAY = ::T.let(nil, ::T.untyped)
-  LIGHT_GRAY_STYLE = ::T.let(nil, ::T.untyped)
-  LIGHT_GREEN = ::T.let(nil, ::T.untyped)
-  LIGHT_GREEN_STYLE = ::T.let(nil, ::T.untyped)
-  LIGHT_GREY = ::T.let(nil, ::T.untyped)
-  LIGHT_GREY_STYLE = ::T.let(nil, ::T.untyped)
-  LIGHT_MAGENTA = ::T.let(nil, ::T.untyped)
-  LIGHT_MAGENTA_STYLE = ::T.let(nil, ::T.untyped)
-  LIGHT_NONE = ::T.let(nil, ::T.untyped)
-  LIGHT_NONE_STYLE = ::T.let(nil, ::T.untyped)
-  LIGHT_RED = ::T.let(nil, ::T.untyped)
-  LIGHT_RED_STYLE = ::T.let(nil, ::T.untyped)
-  LIGHT_WHITE = ::T.let(nil, ::T.untyped)
-  LIGHT_WHITE_STYLE = ::T.let(nil, ::T.untyped)
-  LIGHT_YELLOW = ::T.let(nil, ::T.untyped)
-  LIGHT_YELLOW_STYLE = ::T.let(nil, ::T.untyped)
-  MAGENTA = ::T.let(nil, ::T.untyped)
-  MAGENTA_STYLE = ::T.let(nil, ::T.untyped)
-  NONE = ::T.let(nil, ::T.untyped)
-  NONE_STYLE = ::T.let(nil, ::T.untyped)
-  ON_BLACK = ::T.let(nil, ::T.untyped)
-  ON_BLACK_STYLE = ::T.let(nil, ::T.untyped)
-  ON_BLUE = ::T.let(nil, ::T.untyped)
-  ON_BLUE_STYLE = ::T.let(nil, ::T.untyped)
-  ON_BRIGHT_BLACK = ::T.let(nil, ::T.untyped)
-  ON_BRIGHT_BLACK_STYLE = ::T.let(nil, ::T.untyped)
-  ON_BRIGHT_BLUE = ::T.let(nil, ::T.untyped)
-  ON_BRIGHT_BLUE_STYLE = ::T.let(nil, ::T.untyped)
-  ON_BRIGHT_CYAN = ::T.let(nil, ::T.untyped)
-  ON_BRIGHT_CYAN_STYLE = ::T.let(nil, ::T.untyped)
-  ON_BRIGHT_GRAY = ::T.let(nil, ::T.untyped)
-  ON_BRIGHT_GRAY_STYLE = ::T.let(nil, ::T.untyped)
-  ON_BRIGHT_GREEN = ::T.let(nil, ::T.untyped)
-  ON_BRIGHT_GREEN_STYLE = ::T.let(nil, ::T.untyped)
-  ON_BRIGHT_GREY = ::T.let(nil, ::T.untyped)
-  ON_BRIGHT_GREY_STYLE = ::T.let(nil, ::T.untyped)
-  ON_BRIGHT_MAGENTA = ::T.let(nil, ::T.untyped)
-  ON_BRIGHT_MAGENTA_STYLE = ::T.let(nil, ::T.untyped)
-  ON_BRIGHT_NONE = ::T.let(nil, ::T.untyped)
-  ON_BRIGHT_NONE_STYLE = ::T.let(nil, ::T.untyped)
-  ON_BRIGHT_RED = ::T.let(nil, ::T.untyped)
-  ON_BRIGHT_RED_STYLE = ::T.let(nil, ::T.untyped)
-  ON_BRIGHT_WHITE = ::T.let(nil, ::T.untyped)
-  ON_BRIGHT_WHITE_STYLE = ::T.let(nil, ::T.untyped)
-  ON_BRIGHT_YELLOW = ::T.let(nil, ::T.untyped)
-  ON_BRIGHT_YELLOW_STYLE = ::T.let(nil, ::T.untyped)
-  ON_CYAN = ::T.let(nil, ::T.untyped)
-  ON_CYAN_STYLE = ::T.let(nil, ::T.untyped)
-  ON_GRAY = ::T.let(nil, ::T.untyped)
-  ON_GRAY_STYLE = ::T.let(nil, ::T.untyped)
-  ON_GREEN = ::T.let(nil, ::T.untyped)
-  ON_GREEN_STYLE = ::T.let(nil, ::T.untyped)
-  ON_GREY = ::T.let(nil, ::T.untyped)
-  ON_GREY_STYLE = ::T.let(nil, ::T.untyped)
-  ON_LIGHT_BLACK = ::T.let(nil, ::T.untyped)
-  ON_LIGHT_BLACK_STYLE = ::T.let(nil, ::T.untyped)
-  ON_LIGHT_BLUE = ::T.let(nil, ::T.untyped)
-  ON_LIGHT_BLUE_STYLE = ::T.let(nil, ::T.untyped)
-  ON_LIGHT_CYAN = ::T.let(nil, ::T.untyped)
-  ON_LIGHT_CYAN_STYLE = ::T.let(nil, ::T.untyped)
-  ON_LIGHT_GRAY = ::T.let(nil, ::T.untyped)
-  ON_LIGHT_GRAY_STYLE = ::T.let(nil, ::T.untyped)
-  ON_LIGHT_GREEN = ::T.let(nil, ::T.untyped)
-  ON_LIGHT_GREEN_STYLE = ::T.let(nil, ::T.untyped)
-  ON_LIGHT_GREY = ::T.let(nil, ::T.untyped)
-  ON_LIGHT_GREY_STYLE = ::T.let(nil, ::T.untyped)
-  ON_LIGHT_MAGENTA = ::T.let(nil, ::T.untyped)
-  ON_LIGHT_MAGENTA_STYLE = ::T.let(nil, ::T.untyped)
-  ON_LIGHT_NONE = ::T.let(nil, ::T.untyped)
-  ON_LIGHT_NONE_STYLE = ::T.let(nil, ::T.untyped)
-  ON_LIGHT_RED = ::T.let(nil, ::T.untyped)
-  ON_LIGHT_RED_STYLE = ::T.let(nil, ::T.untyped)
-  ON_LIGHT_WHITE = ::T.let(nil, ::T.untyped)
-  ON_LIGHT_WHITE_STYLE = ::T.let(nil, ::T.untyped)
-  ON_LIGHT_YELLOW = ::T.let(nil, ::T.untyped)
-  ON_LIGHT_YELLOW_STYLE = ::T.let(nil, ::T.untyped)
-  ON_MAGENTA = ::T.let(nil, ::T.untyped)
-  ON_MAGENTA_STYLE = ::T.let(nil, ::T.untyped)
-  ON_NONE = ::T.let(nil, ::T.untyped)
-  ON_NONE_STYLE = ::T.let(nil, ::T.untyped)
-  ON_RED = ::T.let(nil, ::T.untyped)
-  ON_RED_STYLE = ::T.let(nil, ::T.untyped)
-  ON_WHITE = ::T.let(nil, ::T.untyped)
-  ON_WHITE_STYLE = ::T.let(nil, ::T.untyped)
-  ON_YELLOW = ::T.let(nil, ::T.untyped)
-  ON_YELLOW_STYLE = ::T.let(nil, ::T.untyped)
-  RED = ::T.let(nil, ::T.untyped)
-  RED_STYLE = ::T.let(nil, ::T.untyped)
-  RESET = ::T.let(nil, ::T.untyped)
-  RESET_STYLE = ::T.let(nil, ::T.untyped)
-  REVERSE = ::T.let(nil, ::T.untyped)
-  REVERSE_STYLE = ::T.let(nil, ::T.untyped)
-  STYLES = ::T.let(nil, ::T.untyped)
-  STYLE_LIST = ::T.let(nil, ::T.untyped)
-  UNDERLINE = ::T.let(nil, ::T.untyped)
-  UNDERLINE_STYLE = ::T.let(nil, ::T.untyped)
-  UNDERSCORE = ::T.let(nil, ::T.untyped)
-  UNDERSCORE_STYLE = ::T.let(nil, ::T.untyped)
-  WHITE = ::T.let(nil, ::T.untyped)
-  WHITE_STYLE = ::T.let(nil, ::T.untyped)
-  YELLOW = ::T.let(nil, ::T.untyped)
-  YELLOW_STYLE = ::T.let(nil, ::T.untyped)
-end
-
-module HighLine::BuiltinStyles::ClassMethods
-  def const_missing(name); end
-  RGB_COLOR_PATTERN = ::T.let(nil, ::T.untyped)
-end
-
-module HighLine::BuiltinStyles::ClassMethods
-end
-
-module HighLine::BuiltinStyles
-  def self.included(base); end
-end
-
-class HighLine::ColorScheme
-  def [](color_tag); end
-
-  def []=(color_tag, constants); end
-
-  def definition(color_tag); end
-
-  def include?(color_tag); end
-
-  def initialize(h=T.unsafe(nil)); end
-
-  def keys(); end
-
-  def load_from_hash(h); end
-
-  def to_hash(); end
-end
-
-class HighLine::ColorScheme
-end
-
-module HighLine::CustomErrors
-end
-
-class HighLine::CustomErrors::ExplainableError
-  def explanation_key(); end
-end
-
-class HighLine::CustomErrors::ExplainableError
-end
-
-class HighLine::CustomErrors::NoAutoCompleteMatch
-end
-
-class HighLine::CustomErrors::NoAutoCompleteMatch
-end
-
-class HighLine::CustomErrors::NoConfirmationQuestionError
-end
-
-class HighLine::CustomErrors::NoConfirmationQuestionError
-end
-
-class HighLine::CustomErrors::NotInRangeQuestionError
-end
-
-class HighLine::CustomErrors::NotInRangeQuestionError
-end
-
-class HighLine::CustomErrors::NotValidQuestionError
-end
-
-class HighLine::CustomErrors::NotValidQuestionError
-end
-
-class HighLine::CustomErrors::QuestionError
-end
-
-class HighLine::CustomErrors::QuestionError
-end
-
-module HighLine::CustomErrors
-end
-
-class HighLine::List
-  def col_down(); end
-
-  def col_down_mode(); end
-
-  def cols(); end
-
-  def cols=(cols); end
-
-  def initialize(items, options=T.unsafe(nil)); end
-
-  def items(); end
-
-  def list(); end
-
-  def row_join_str_size(); end
-
-  def row_join_string(); end
-
-  def row_join_string=(row_join_string); end
-
-  def slice_by_cols(); end
-
-  def slice_by_rows(); end
-
-  def to_a(); end
-
-  def transpose(); end
-
-  def transpose_mode(); end
-end
-
-class HighLine::List
-end
-
-class HighLine::ListRenderer
-  def highline(); end
-
-  def initialize(items, mode=T.unsafe(nil), option=T.unsafe(nil), highline); end
-
-  def items(); end
-
-  def mode(); end
-
-  def option(); end
-
-  def render(); end
-end
-
-class HighLine::ListRenderer
-end
-
-class HighLine::Menu
-  def add_item(item); end
-
-  def all_items(); end
-
-  def build_item(*args); end
-
-  def choice(name, help=T.unsafe(nil), text=T.unsafe(nil), &action); end
-
-  def choices(*names, &action); end
-
-  def decorate_index(index); end
-
-  def decorate_item(text, ix); end
-
-  def find_item_from_selection(items, selection); end
-
-  def flow(); end
-
-  def flow=(flow); end
-
-  def gather_selected(highline_context, selections, details=T.unsafe(nil)); end
-
-  def get_item_by_letter(items, selection); end
-
-  def get_item_by_number(items, selection); end
-
-  def header(); end
-
-  def header=(header); end
-
-  def help(topic, help); end
-
-  def hidden(name, help=T.unsafe(nil), &action); end
-
-  def index(); end
-
-  def index=(style); end
-
-  def index_color(); end
-
-  def index_color=(index_color); end
-
-  def index_suffix(); end
-
-  def index_suffix=(index_suffix); end
-
-  def init_help(); end
-
-  def initialize(); end
-
-  def layout(); end
-
-  def layout=(new_layout); end
-
-  def list_option(); end
-
-  def list_option=(list_option); end
-
-  def map_items_by_index(); end
-
-  def map_items_by_name(); end
-
-  def mark_for_decoration(text, ix); end
-
-  def nil_on_handled(); end
-
-  def nil_on_handled=(nil_on_handled); end
-
-  def options(); end
-
-  def parse_list(); end
-
-  def prompt(); end
-
-  def prompt=(prompt); end
-
-  def select(highline_context, selection, details=T.unsafe(nil)); end
-
-  def select_by(); end
-
-  def select_by=(select_by); end
-
-  def shell(); end
-
-  def shell=(shell); end
-
-  def show_default_if_any(); end
-
-  def to_ary(); end
-
-  def update_responses(); end
-
-  def value_for_array_selections(items, selections, details); end
-
-  def value_for_hash_selections(items, selections, details); end
-
-  def value_for_selected_item(item, details); end
-end
-
-class HighLine::Menu::Item
-  def action(); end
-
-  def help(); end
-
-  def initialize(name, attributes); end
-
-  def item_help(); end
-
-  def name(); end
-
-  def text(); end
-end
-
-class HighLine::Menu::Item
-end
-
-class HighLine::Menu
-  def self.index_color(); end
-
-  def self.index_color=(index_color); end
-end
-
-class HighLine::Paginator
-  def continue_paging?(); end
-
-  def highline(); end
-
-  def initialize(highline); end
-
-  def page_print(text); end
-end
-
-class HighLine::Paginator
-end
-
-class HighLine::Question
-  include ::HighLine::CustomErrors
-  def above(); end
-
-  def above=(above); end
-
-  def answer(); end
-
-  def answer=(answer); end
-
-  def answer_or_default(answer_string); end
-
-  def answer_type(); end
-
-  def answer_type=(answer_type); end
-
-  def ask_on_error_msg(); end
-
-  def below(); end
-
-  def below=(below); end
-
-  def build_responses(message_source=T.unsafe(nil)); end
-
-  def build_responses_new_hash(message_source); end
-
-  def case(); end
-
-  def case=(arg); end
-
-  def change_case(answer_string); end
-
-  def character(); end
-
-  def character=(character); end
-
-  def check_range(); end
-
-  def choices_complete(answer_string); end
-
-  def completion(); end
-
-  def completion=(completion); end
-
-  def confirm(); end
-
-  def confirm=(confirm); end
-
-  def confirm_question(highline); end
-
-  def convert(); end
-
-  def default(); end
-
-  def default=(default); end
-
-  def default_responses_hash(); end
-
-  def directory(); end
-
-  def directory=(directory); end
-
-  def echo(); end
-
-  def echo=(echo); end
-
-  def expected_range(); end
-
-  def final_response(error); end
-
-  def final_responses(); end
-
-  def first_answer(); end
-
-  def first_answer=(first_answer); end
-
-  def first_answer?(); end
-
-  def format_answer(answer_string); end
-
-  def gather(); end
-
-  def gather=(gather); end
-
-  def get_echo_for_response(response); end
-
-  def get_response(highline); end
-
-  def get_response_or_default(highline); end
-
-  def glob(); end
-
-  def glob=(glob); end
-
-  def in(); end
-
-  def in=(arg); end
-
-  def in_range?(); end
-
-  def initialize(template, answer_type); end
-
-  def limit(); end
-
-  def limit=(limit); end
-
-  def overwrite(); end
-
-  def overwrite=(overwrite); end
-
-  def readline(); end
-
-  def readline=(readline); end
-
-  def remove_whitespace(answer_string); end
-
-  def responses(); end
-
-  def selection(); end
-
-  def show_question(highline); end
-
-  def template(); end
-
-  def template=(template); end
-
-  def valid_answer?(); end
-
-  def validate(); end
-
-  def validate=(validate); end
-
-  def verify_match(); end
-
-  def verify_match=(verify_match); end
-
-  def whitespace(); end
-
-  def whitespace=(whitespace); end
-end
-
-class HighLine::Question::AnswerConverter
-  def answer(*args, &block); end
-
-  def answer=(*args, &block); end
-
-  def answer_type(*args, &block); end
-
-  def check_range(*args, &block); end
-
-  def choices_complete(*args, &block); end
-
-  def convert(); end
-
-  def directory(*args, &block); end
-
-  def initialize(question); end
-
-  def to_array(); end
-
-  def to_file(); end
-
-  def to_float(); end
-
-  def to_integer(); end
-
-  def to_pathname(); end
-
-  def to_proc(); end
-
-  def to_regexp(); end
-
-  def to_string(); end
-
-  def to_symbol(); end
-end
-
-class HighLine::Question::AnswerConverter
-  extend ::Forwardable
-end
-
-class HighLine::Question
-  def self.build(template_or_question, answer_type=T.unsafe(nil), &details); end
-end
-
-class HighLine::QuestionAsker
-  include ::HighLine::CustomErrors
-  def ask_once(); end
-
-  def gather_answers(); end
-
-  def gather_hash(); end
-
-  def gather_integer(); end
-
-  def gather_regexp(); end
-
-  def initialize(question, highline); end
-
-  def question(); end
-end
-
-class HighLine::QuestionAsker
-end
-
-class HighLine::SampleColorScheme
-  def initialize(_h=T.unsafe(nil)); end
-  SAMPLE_SCHEME = ::T.let(nil, ::T.untyped)
-end
-
-class HighLine::SampleColorScheme
-end
-
-class HighLine::Statement
-  def highline(); end
-
-  def initialize(source, highline); end
-
-  def source(); end
-
-  def statement(); end
-
-  def template_string(); end
-end
-
-class HighLine::Statement
-  def self.const_missing(constant); end
-end
-
-class HighLine::String
-  include ::HighLine::StringExtensions
-  def bright_black(); end
-
-  def bright_blue(); end
-
-  def bright_cyan(); end
-
-  def bright_gray(); end
-
-  def bright_green(); end
-
-  def bright_grey(); end
-
-  def bright_magenta(); end
-
-  def bright_none(); end
-
-  def bright_red(); end
-
-  def bright_white(); end
-
-  def bright_yellow(); end
-
-  def color(*args); end
-
-  def concealed(); end
-
-  def dark(); end
-
-  def foreground(*args); end
-
-  def gray(); end
-
-  def grey(); end
-
-  def light_gray(); end
-
-  def light_grey(); end
-
-  def light_none(); end
-
-  def method_missing(method, *_args); end
-
-  def none(); end
-
-  def on(arg); end
-
-  def on_bright_black(); end
-
-  def on_bright_blue(); end
-
-  def on_bright_cyan(); end
-
-  def on_bright_gray(); end
-
-  def on_bright_green(); end
-
-  def on_bright_grey(); end
-
-  def on_bright_magenta(); end
-
-  def on_bright_none(); end
-
-  def on_bright_red(); end
-
-  def on_bright_white(); end
-
-  def on_bright_yellow(); end
-
-  def on_gray(); end
-
-  def on_grey(); end
-
-  def on_light_gray(); end
-
-  def on_light_grey(); end
-
-  def on_light_none(); end
-
-  def on_none(); end
-
-  def on_rgb(*colors); end
-
-  def reset(); end
-
-  def rgb(*colors); end
-
-  def uncolor(); end
-end
-
-class HighLine::String
-end
-
-module HighLine::StringExtensions
-  STYLE_METHOD_NAME_PATTERN = ::T.let(nil, ::T.untyped)
-end
-
-module HighLine::StringExtensions
-  def self.define_builtin_style_methods(base); end
-
-  def self.define_style_support_methods(base); end
-
-  def self.included(base); end
-end
-
-class HighLine::Style
-  def blue(); end
-
-  def bright(); end
-
-  def builtin(); end
-
-  def builtin=(builtin); end
-
-  def code(); end
-
-  def color(string); end
-
-  def green(); end
-
-  def initialize(defn=T.unsafe(nil)); end
-
-  def light(); end
-
-  def list(); end
-
-  def name(); end
-
-  def on(); end
-
-  def red(); end
-
-  def rgb(); end
-
-  def rgb=(rgb); end
-
-  def to_hash(); end
-
-  def variant(new_name, options=T.unsafe(nil)); end
-end
-
-class HighLine::Style
-  def self.ansi_rgb_to_hex(ansi_number); end
-
-  def self.clear_index(); end
-
-  def self.code_index(); end
-
-  def self.index(style); end
-
-  def self.list(); end
-
-  def self.rgb(*colors); end
-
-  def self.rgb_hex(*colors); end
-
-  def self.rgb_number(*parts); end
-
-  def self.rgb_parts(hex); end
-
-  def self.uncolor(string); end
-end
-
-class HighLine::TemplateRenderer
-  def answer(*args, &block); end
-
-  def answer_type(*args, &block); end
-
-  def color(*args, &block); end
-
-  def header(*args, &block); end
-
-  def highline(); end
-
-  def initialize(template, source, highline); end
-
-  def key(*args, &block); end
-
-  def list(*args, &block); end
-
-  def menu(); end
-
-  def method_missing(method, *args); end
-
-  def prompt(*args, &block); end
-
-  def render(); end
-
-  def source(); end
-
-  def template(); end
-end
-
-class HighLine::TemplateRenderer
-  extend ::Forwardable
-  def self.const_missing(name); end
-end
-
-class HighLine::Terminal
-  def character_mode(); end
-
-  def get_character(); end
-
-  def get_line(question, highline); end
-
-  def get_line_default(highline); end
-
-  def get_line_with_readline(question, highline); end
-
-  def initialize(input, output); end
-
-  def initialize_system_extensions(); end
-
-  def input(); end
-
-  def jruby?(); end
-
-  def output(); end
-
-  def raw_no_echo_mode(); end
-
-  def raw_no_echo_mode_exec(); end
-
-  def readline_read(question); end
-
-  def restore_mode(); end
-
-  def rubinius?(); end
-
-  def terminal_size(); end
-
-  def windows?(); end
-end
-
-class HighLine::Terminal::IOConsole
-end
-
-class HighLine::Terminal::IOConsole
-end
-
-class HighLine::Terminal
-  def self.get_terminal(input, output); end
-end
-
-module HighLine::Wrapper
-end
-
-module HighLine::Wrapper
-  def self.actual_length(string_with_escapes); end
-
-  def self.wrap(text, wrap_at); end
-end
-
-class HighLine
-  extend ::HighLine::BuiltinStyles::ClassMethods
-  extend ::SingleForwardable
-  def self.String(s); end
-
-  def self.Style(*args); end
-
-  def self.color(*args, &block); end
-
-  def self.color_code(*args, &block); end
-
-  def self.color_scheme(); end
-
-  def self.color_scheme=(color_scheme); end
-
-  def self.colorize_strings(); end
-
-  def self.default_instance(); end
-
-  def self.default_instance=(default_instance); end
-
-  def self.find_or_create_style(arg); end
-
-  def self.find_or_create_style_list(*args); end
-
-  def self.reset(); end
-
-  def self.reset_color_scheme(); end
-
-  def self.reset_use_color(*args, &block); end
-
-  def self.supports_rgb_color?(); end
-
-  def self.track_eof=(*args, &block); end
-
-  def self.track_eof?(*args, &block); end
-
-  def self.uncolor(*args, &block); end
-
-  def self.use_color=(*args, &block); end
-
-  def self.use_color?(*args, &block); end
-
-  def self.using_color_scheme?(); end
-end
-
 module Homebrew
   MAX_PORT = ::T.let(nil, ::T.untyped)
   MIN_PORT = ::T.let(nil, ::T.untyped)
@@ -9801,7 +4365,6 @@ module Homebrew::API
 end
 
 module Homebrew::Assertions
-  include ::Minitest::Assertions
   def assert_include(*args); end
 
   def assert_no_match(*args); end
@@ -10182,936 +4745,6 @@ end
 module HostEnvironmentSimulatorHelper
 end
 
-module Hpricot
-  AttrCore = ::T.let(nil, ::T.untyped)
-  AttrEvents = ::T.let(nil, ::T.untyped)
-  AttrFocus = ::T.let(nil, ::T.untyped)
-  AttrHAlign = ::T.let(nil, ::T.untyped)
-  AttrI18n = ::T.let(nil, ::T.untyped)
-  AttrVAlign = ::T.let(nil, ::T.untyped)
-  Attrs = ::T.let(nil, ::T.untyped)
-  ElementContent = ::T.let(nil, ::T.untyped)
-  ElementExclusions = ::T.let(nil, ::T.untyped)
-  ElementInclusions = ::T.let(nil, ::T.untyped)
-  FORM_TAGS = ::T.let(nil, ::T.untyped)
-  NamedCharacters = ::T.let(nil, ::T.untyped)
-  NamedCharactersPattern = ::T.let(nil, ::T.untyped)
-  OmittedAttrName = ::T.let(nil, ::T.untyped)
-  ProcInsParse = ::T.let(nil, ::T.untyped)
-  SELF_CLOSING_TAGS = ::T.let(nil, ::T.untyped)
-end
-
-class Hpricot::Attributes
-  def [](k); end
-
-  def []=(k, v); end
-
-  def element(); end
-
-  def element=(element); end
-
-  def initialize(e); end
-
-  def to_hash(); end
-end
-
-class Hpricot::Attributes
-end
-
-class Hpricot::BlankSlate
-end
-
-class Hpricot::BlankSlate
-  def self.hide(name); end
-end
-
-class Hpricot::BogusETag
-  include ::Hpricot::Leaf
-  include ::Hpricot::Node
-  include ::Hpricot
-  include ::Hpricot::BogusETag::Trav
-  include ::Hpricot::Leaf::Trav
-  include ::Hpricot::Traverse
-  def initialize(name); end
-
-  def output(out, opts=T.unsafe(nil)); end
-
-  def raw_string(); end
-end
-
-module Hpricot::BogusETag::Trav
-  include ::Hpricot::Leaf::Trav
-  include ::Hpricot::Traverse
-end
-
-module Hpricot::BogusETag::Trav
-end
-
-class Hpricot::BogusETag
-end
-
-module Hpricot::Builder
-  def <<(string); end
-
-  def a(*args, &block); end
-
-  def abbr(*args, &block); end
-
-  def acronym(*args, &block); end
-
-  def add_child(ele); end
-
-  def address(*args, &block); end
-
-  def applet(*args, &block); end
-
-  def area(*args, &block); end
-
-  def b(*args, &block); end
-
-  def base(*args, &block); end
-
-  def basefont(*args, &block); end
-
-  def bdo(*args, &block); end
-
-  def big(*args, &block); end
-
-  def blockquote(*args, &block); end
-
-  def body(*args, &block); end
-
-  def br(*args, &block); end
-
-  def build(*a, &b); end
-
-  def button(*args, &block); end
-
-  def caption(*args, &block); end
-
-  def center(*args, &block); end
-
-  def cite(*args, &block); end
-
-  def code(*args, &block); end
-
-  def col(*args, &block); end
-
-  def colgroup(*args, &block); end
-
-  def concat(string); end
-
-  def dd(*args, &block); end
-
-  def del(*args, &block); end
-
-  def dfn(*args, &block); end
-
-  def dir(*args, &block); end
-
-  def div(*args, &block); end
-
-  def dl(*args, &block); end
-
-  def doctype(target, pub, sys); end
-
-  def dt(*args, &block); end
-
-  def em(*args, &block); end
-
-  def fieldset(*args, &block); end
-
-  def font(*args, &block); end
-
-  def form(*args, &block); end
-
-  def h1(*args, &block); end
-
-  def h2(*args, &block); end
-
-  def h3(*args, &block); end
-
-  def h4(*args, &block); end
-
-  def h5(*args, &block); end
-
-  def h6(*args, &block); end
-
-  def head(*args, &block); end
-
-  def hr(*args, &block); end
-
-  def html(*args, &block); end
-
-  def html_tag(sym, *args, &block); end
-
-  def i(*args, &block); end
-
-  def iframe(*args, &block); end
-
-  def img(*args, &block); end
-
-  def input(*args, &block); end
-
-  def ins(*args, &block); end
-
-  def isindex(*args, &block); end
-
-  def kbd(*args, &block); end
-
-  def label(*args, &block); end
-
-  def legend(*args, &block); end
-
-  def li(*args, &block); end
-
-  def link(*args, &block); end
-
-  def map(*args, &block); end
-
-  def menu(*args, &block); end
-
-  def meta(*args, &block); end
-
-  def noframes(*args, &block); end
-
-  def noscript(*args, &block); end
-
-  def object(*args, &block); end
-
-  def ol(*args, &block); end
-
-  def optgroup(*args, &block); end
-
-  def option(*args, &block); end
-
-  def p(*args, &block); end
-
-  def param(*args, &block); end
-
-  def pre(*args, &block); end
-
-  def q(*args, &block); end
-
-  def s(*args, &block); end
-
-  def samp(*args, &block); end
-
-  def script(*args, &block); end
-
-  def select(*args, &block); end
-
-  def small(*args, &block); end
-
-  def span(*args, &block); end
-
-  def strike(*args, &block); end
-
-  def strong(*args, &block); end
-
-  def style(*args, &block); end
-
-  def sub(*args, &block); end
-
-  def sup(*args, &block); end
-
-  def table(*args, &block); end
-
-  def tag!(tag, *args, &block); end
-
-  def tbody(*args, &block); end
-
-  def td(*args, &block); end
-
-  def text(string); end
-
-  def text!(string); end
-
-  def textarea(*args, &block); end
-
-  def tfoot(*args, &block); end
-
-  def th(*args, &block); end
-
-  def thead(*args, &block); end
-
-  def title(*args, &block); end
-
-  def tr(*args, &block); end
-
-  def tt(*args, &block); end
-
-  def u(*args, &block); end
-
-  def ul(*args, &block); end
-
-  def var(*args, &block); end
-
-  def xhtml_strict(attrs=T.unsafe(nil), &block); end
-
-  def xhtml_transitional(attrs=T.unsafe(nil), &block); end
-end
-
-module Hpricot::Builder
-  def self.set(option, value); end
-end
-
-class Hpricot::CData
-  include ::Hpricot::Leaf
-  include ::Hpricot::Node
-  include ::Hpricot
-  include ::Hpricot::CData::Trav
-  include ::Hpricot::Leaf::Trav
-  include ::Hpricot::Traverse
-  def content(); end
-
-  def content=(content); end
-
-  def initialize(content); end
-
-  def output(out, opts=T.unsafe(nil)); end
-
-  def raw_string(); end
-end
-
-module Hpricot::CData::Trav
-  include ::Hpricot::Leaf::Trav
-  include ::Hpricot::Traverse
-end
-
-module Hpricot::CData::Trav
-end
-
-class Hpricot::CData
-end
-
-class Hpricot::Comment
-  include ::Hpricot::Leaf
-  include ::Hpricot::Node
-  include ::Hpricot
-  include ::Hpricot::Comment::Trav
-  include ::Hpricot::Leaf::Trav
-  include ::Hpricot::Traverse
-  def content(); end
-
-  def content=(content); end
-
-  def output(out, opts=T.unsafe(nil)); end
-
-  def raw_string(); end
-end
-
-module Hpricot::Comment::Trav
-  include ::Hpricot::Leaf::Trav
-  include ::Hpricot::Traverse
-end
-
-module Hpricot::Comment::Trav
-end
-
-class Hpricot::Comment
-end
-
-module Hpricot::Container
-  include ::Hpricot::Node
-  include ::Hpricot
-end
-
-module Hpricot::Container::Trav
-  include ::Hpricot::Traverse
-  def classes(); end
-
-  def containers(); end
-
-  def each_child(&block); end
-
-  def each_child_with_index(&block); end
-
-  def each_hyperlink(); end
-
-  def each_hyperlink_uri(base_uri=T.unsafe(nil)); end
-
-  def each_uri(base_uri=T.unsafe(nil)); end
-
-  def filter(&block); end
-
-  def find_element(*names); end
-
-  def following_siblings(); end
-
-  def get_element_by_id(id); end
-
-  def get_elements_by_tag_name(*a); end
-
-  def insert_after(nodes, ele); end
-
-  def insert_before(nodes, ele); end
-
-  def next_sibling(); end
-
-  def preceding_siblings(); end
-
-  def previous_sibling(); end
-
-  def replace_child(old, new); end
-
-  def siblings_at(*pos); end
-
-  def traverse_text_internal(&block); end
-end
-
-module Hpricot::Container::Trav
-end
-
-module Hpricot::Container
-end
-
-class Hpricot::Context
-  include ::Hpricot
-end
-
-class Hpricot::Context
-end
-
-class Hpricot::CssProxy
-  def initialize(builder, sym); end
-
-  def method_missing(id_or_class, *args, &block); end
-end
-
-class Hpricot::CssProxy
-end
-
-class Hpricot::Doc
-  include ::Hpricot::Container
-  include ::Hpricot::Node
-  include ::Hpricot
-  include ::Hpricot::Doc::Trav
-  include ::Hpricot::Container::Trav
-  include ::Hpricot::Traverse
-  def inspect_tree(); end
-
-  def output(out, opts=T.unsafe(nil)); end
-end
-
-module Hpricot::Doc::Trav
-  include ::Hpricot::Container::Trav
-  include ::Hpricot::Traverse
-  def author(); end
-
-  def css_path(); end
-
-  def root(); end
-
-  def title(); end
-
-  def traverse_all_element(&block); end
-
-  def traverse_some_element(name_set, &block); end
-
-  def xpath(); end
-end
-
-module Hpricot::Doc::Trav
-end
-
-class Hpricot::Doc
-end
-
-class Hpricot::DocType
-  include ::Hpricot::Leaf
-  include ::Hpricot::Node
-  include ::Hpricot
-  include ::Hpricot::DocType::Trav
-  include ::Hpricot::Leaf::Trav
-  include ::Hpricot::Traverse
-  def initialize(target, pub, sys); end
-
-  def output(out, opts=T.unsafe(nil)); end
-
-  def public_id(); end
-
-  def public_id=(public_id); end
-
-  def raw_string(); end
-
-  def system_id(); end
-
-  def system_id=(system_id); end
-
-  def target(); end
-
-  def target=(target); end
-end
-
-module Hpricot::DocType::Trav
-  include ::Hpricot::Leaf::Trav
-  include ::Hpricot::Traverse
-end
-
-module Hpricot::DocType::Trav
-end
-
-class Hpricot::DocType
-end
-
-class Hpricot::ETag
-  include ::Hpricot::Tag
-end
-
-class Hpricot::ETag
-end
-
-class Hpricot::Elem
-  include ::Hpricot::Container
-  include ::Hpricot::Node
-  include ::Hpricot
-  include ::Hpricot::Elem::Trav
-  include ::Hpricot::Container::Trav
-  include ::Hpricot::Traverse
-  def attributes(); end
-
-  def attributes_as_html(); end
-
-  def empty?(); end
-
-  def initialize(tag, attrs=T.unsafe(nil), children=T.unsafe(nil), etag=T.unsafe(nil)); end
-
-  def output(out, opts=T.unsafe(nil)); end
-
-  def pretty_print_stag(q); end
-end
-
-module Hpricot::Elem::Trav
-  include ::Hpricot::Container::Trav
-  include ::Hpricot::Traverse
-  def [](name); end
-
-  def []=(name, val); end
-
-  def get_attribute(name); end
-
-  def has_attribute?(name); end
-
-  def remove_attribute(name); end
-
-  def set_attribute(name, val); end
-
-  def traverse_all_element(&block); end
-
-  def traverse_some_element(name_set, &block); end
-end
-
-module Hpricot::Elem::Trav
-end
-
-class Hpricot::Elem
-end
-
-class Hpricot::Elements
-  def %(expr, &blk); end
-
-  def /(*expr, &blk); end
-
-  def add_class(class_name); end
-
-  def after(str=T.unsafe(nil), &blk); end
-
-  def append(str=T.unsafe(nil), &blk); end
-
-  def at(expr, &blk); end
-
-  def attr(key, value=T.unsafe(nil), &blk); end
-
-  def before(str=T.unsafe(nil), &blk); end
-
-  def empty(); end
-
-  def filter(expr); end
-
-  def html(*string); end
-
-  def html=(string); end
-
-  def innerHTML(*string); end
-
-  def innerHTML=(string); end
-
-  def inner_html(*string); end
-
-  def inner_html=(string); end
-
-  def inner_text(); end
-
-  def not(expr); end
-
-  def prepend(str=T.unsafe(nil), &blk); end
-
-  def remove(); end
-
-  def remove_attr(name); end
-
-  def remove_class(name=T.unsafe(nil)); end
-
-  def search(*expr, &blk); end
-
-  def set(key, value=T.unsafe(nil), &blk); end
-
-  def text(); end
-
-  def to_html(); end
-
-  def to_s(); end
-
-  def wrap(str=T.unsafe(nil), &blk); end
-  ATTR_RE = ::T.let(nil, ::T.untyped)
-  BRACK_RE = ::T.let(nil, ::T.untyped)
-  CATCH_RE = ::T.let(nil, ::T.untyped)
-  CUST_RE = ::T.let(nil, ::T.untyped)
-  FUNC_RE = ::T.let(nil, ::T.untyped)
-end
-
-class Hpricot::Elements
-  def self.expand(ele1, ele2, excl=T.unsafe(nil)); end
-
-  def self.filter(nodes, expr, truth=T.unsafe(nil)); end
-end
-
-class Hpricot::EncodingError
-end
-
-class Hpricot::EncodingError
-end
-
-class Hpricot::Error
-end
-
-class Hpricot::Error
-end
-
-module Hpricot::Leaf
-  include ::Hpricot::Node
-  include ::Hpricot
-  def inspect(); end
-
-  def pretty_print(q); end
-end
-
-module Hpricot::Leaf::Trav
-  include ::Hpricot::Traverse
-  def traverse_all_element(); end
-
-  def traverse_some_element(name_set); end
-
-  def traverse_text_internal(); end
-end
-
-module Hpricot::Leaf::Trav
-end
-
-module Hpricot::Leaf
-end
-
-class Hpricot::Name
-  include ::Hpricot
-end
-
-class Hpricot::Name
-end
-
-module Hpricot::Node
-  include ::Hpricot
-  def altered!(); end
-
-  def clear_raw(); end
-
-  def html_quote(str); end
-
-  def if_output(opts); end
-
-  def inspect_tree(depth=T.unsafe(nil)); end
-
-  def pathname(); end
-end
-
-module Hpricot::Node
-end
-
-class Hpricot::ParseError
-end
-
-class Hpricot::ParseError
-end
-
-class Hpricot::ProcIns
-  include ::Hpricot::Leaf
-  include ::Hpricot::Node
-  include ::Hpricot
-  include ::Hpricot::ProcIns::Trav
-  include ::Hpricot::Leaf::Trav
-  include ::Hpricot::Traverse
-  def content(); end
-
-  def content=(content); end
-
-  def output(out, opts=T.unsafe(nil)); end
-
-  def raw_string(); end
-
-  def target(); end
-
-  def target=(target); end
-end
-
-module Hpricot::ProcIns::Trav
-  include ::Hpricot::Leaf::Trav
-  include ::Hpricot::Traverse
-end
-
-module Hpricot::ProcIns::Trav
-end
-
-class Hpricot::ProcIns
-end
-
-module Hpricot::Tag
-  include ::Hpricot
-end
-
-module Hpricot::Tag
-end
-
-class Hpricot::Text
-  include ::Hpricot::Leaf
-  include ::Hpricot::Node
-  include ::Hpricot
-  include ::Hpricot::Text::Trav
-  include ::Hpricot::Leaf::Trav
-  include ::Hpricot::Traverse
-  def <<(str); end
-
-  def content(); end
-
-  def content=(content); end
-
-  def initialize(content); end
-
-  def output(out, opts=T.unsafe(nil)); end
-
-  def raw_string(); end
-end
-
-module Hpricot::Text::Trav
-  include ::Hpricot::Leaf::Trav
-  include ::Hpricot::Traverse
-  def traverse_text_internal(); end
-end
-
-module Hpricot::Text::Trav
-end
-
-class Hpricot::Text
-end
-
-module Hpricot::Traverse
-  def %(expr); end
-
-  def /(expr, &blk); end
-
-  def after(html=T.unsafe(nil), &blk); end
-
-  def at(expr); end
-
-  def before(html=T.unsafe(nil), &blk); end
-
-  def bogusetag?(); end
-
-  def children_of_type(tag_name); end
-
-  def clean_path(path); end
-
-  def comment?(); end
-
-  def css_path(); end
-
-  def doc?(); end
-
-  def doctype?(); end
-
-  def elem?(); end
-
-  def following(); end
-
-  def get_subnode(*indexes); end
-
-  def html(inner=T.unsafe(nil), &blk); end
-
-  def index(name); end
-
-  def innerHTML(inner=T.unsafe(nil), &blk); end
-
-  def innerHTML=(inner); end
-
-  def innerText(); end
-
-  def inner_html(inner=T.unsafe(nil), &blk); end
-
-  def inner_html=(inner); end
-
-  def inner_text(); end
-
-  def make(input=T.unsafe(nil), &blk); end
-
-  def next(); end
-
-  def next_node(); end
-
-  def node_position(); end
-
-  def nodes_at(*pos); end
-
-  def position(); end
-
-  def preceding(); end
-
-  def previous(); end
-
-  def previous_node(); end
-
-  def procins?(); end
-
-  def search(expr, &blk); end
-
-  def swap(html=T.unsafe(nil), &blk); end
-
-  def text?(); end
-
-  def to_html(); end
-
-  def to_original_html(); end
-
-  def to_plain_text(); end
-
-  def to_s(); end
-
-  def traverse_element(*names, &block); end
-
-  def traverse_text(&block); end
-
-  def xmldecl?(); end
-
-  def xpath(); end
-end
-
-module Hpricot::Traverse
-  def self.filter(tok, &blk); end
-end
-
-class Hpricot::XHTMLStrict
-end
-
-class Hpricot::XHTMLStrict
-  def self.doctype(); end
-
-  def self.doctype=(doctype); end
-
-  def self.forms(); end
-
-  def self.forms=(forms); end
-
-  def self.self_closing(); end
-
-  def self.self_closing=(self_closing); end
-
-  def self.tags(); end
-
-  def self.tags=(tags); end
-
-  def self.tagset(); end
-
-  def self.tagset=(tagset); end
-end
-
-class Hpricot::XHTMLTransitional
-end
-
-class Hpricot::XHTMLTransitional
-  def self.doctype(); end
-
-  def self.doctype=(doctype); end
-
-  def self.forms(); end
-
-  def self.forms=(forms); end
-
-  def self.self_closing(); end
-
-  def self.self_closing=(self_closing); end
-
-  def self.tags(); end
-
-  def self.tags=(tags); end
-
-  def self.tagset(); end
-
-  def self.tagset=(tagset); end
-end
-
-class Hpricot::XMLDecl
-  include ::Hpricot::Leaf
-  include ::Hpricot::Node
-  include ::Hpricot
-  include ::Hpricot::XMLDecl::Trav
-  include ::Hpricot::Leaf::Trav
-  include ::Hpricot::Traverse
-  def encoding(); end
-
-  def encoding=(encoding); end
-
-  def output(out, opts=T.unsafe(nil)); end
-
-  def raw_string(); end
-
-  def standalone(); end
-
-  def standalone=(standalone); end
-
-  def version(); end
-
-  def version=(version); end
-end
-
-module Hpricot::XMLDecl::Trav
-  include ::Hpricot::Leaf::Trav
-  include ::Hpricot::Traverse
-end
-
-module Hpricot::XMLDecl::Trav
-end
-
-class Hpricot::XMLDecl
-end
-
-module Hpricot
-  def self.XML(input=T.unsafe(nil), opts=T.unsafe(nil), &blk); end
-
-  def self.buffer_size(); end
-
-  def self.buffer_size=(buffer_size); end
-
-  def self.build(ele=T.unsafe(nil), assigns=T.unsafe(nil), &blk); end
-
-  def self.css(arg, arg1, arg2); end
-
-  def self.make(input=T.unsafe(nil), opts=T.unsafe(nil), &blk); end
-
-  def self.parse(input=T.unsafe(nil), opts=T.unsafe(nil), &blk); end
-
-  def self.scan(*arg); end
-
-  def self.uxs(str); end
-end
-
 module I18n
   def self.cache_key_digest(); end
 
@@ -11442,8 +5075,6 @@ module IRB
 end
 
 class Integer
-  include ::JSON::Ext::Generator::GeneratorMethods::Integer
-  include ::MessagePack::CoreExt
   def to_bn(); end
 end
 
@@ -11461,193 +5092,6 @@ JSON::State = JSON::Ext::Generator::State
 
 JSON::UnparserError = JSON::GeneratorError
 
-module JSONSchemer
-  DEFAULT_META_SCHEMA = ::T.let(nil, ::T.untyped)
-  DRAFT_CLASS_BY_META_SCHEMA = ::T.let(nil, ::T.untyped)
-  FILE_URI_REF_RESOLVER = ::T.let(nil, ::T.untyped)
-  VERSION = ::T.let(nil, ::T.untyped)
-  WINDOWS_URI_PATH_REGEX = ::T.let(nil, ::T.untyped)
-end
-
-class JSONSchemer::CachedRefResolver
-  def call(uri); end
-
-  def initialize(&ref_resolver); end
-end
-
-class JSONSchemer::CachedRefResolver
-end
-
-module JSONSchemer::Errors
-end
-
-module JSONSchemer::Errors
-  def self.pretty(error); end
-end
-
-module JSONSchemer::Format
-  def iri_escape(data); end
-
-  def parse_uri_scheme(data); end
-
-  def valid_date_time?(data); end
-
-  def valid_email?(data); end
-
-  def valid_hostname?(data); end
-
-  def valid_ip?(data, type); end
-
-  def valid_json?(data); end
-
-  def valid_json_pointer?(data); end
-
-  def valid_relative_json_pointer?(data); end
-
-  def valid_spec_format?(data, format); end
-
-  def valid_uri?(data); end
-
-  def valid_uri_reference?(data); end
-
-  def valid_uri_template?(data); end
-  DATE_TIME_OFFSET_REGEX = ::T.let(nil, ::T.untyped)
-  EMAIL_REGEX = ::T.let(nil, ::T.untyped)
-  HOSTNAME_REGEX = ::T.let(nil, ::T.untyped)
-  INVALID_QUERY_REGEX = ::T.let(nil, ::T.untyped)
-  JSON_POINTER_REGEX = ::T.let(nil, ::T.untyped)
-  JSON_POINTER_REGEX_STRING = ::T.let(nil, ::T.untyped)
-  LABEL_REGEX_STRING = ::T.let(nil, ::T.untyped)
-  RELATIVE_JSON_POINTER_REGEX = ::T.let(nil, ::T.untyped)
-end
-
-module JSONSchemer::Format
-end
-
-class JSONSchemer::InvalidFileURI
-end
-
-class JSONSchemer::InvalidFileURI
-end
-
-class JSONSchemer::InvalidRefResolution
-end
-
-class JSONSchemer::InvalidRefResolution
-end
-
-class JSONSchemer::InvalidSymbolKey
-end
-
-class JSONSchemer::InvalidSymbolKey
-end
-
-module JSONSchemer::Schema
-end
-
-class JSONSchemer::Schema::Base
-  include ::JSONSchemer::Format
-  def ids(); end
-
-  def initialize(schema, format: T.unsafe(nil), insert_property_defaults: T.unsafe(nil), before_property_validation: T.unsafe(nil), after_property_validation: T.unsafe(nil), formats: T.unsafe(nil), keywords: T.unsafe(nil), ref_resolver: T.unsafe(nil)); end
-
-  def valid?(data); end
-
-  def valid_instance?(instance); end
-
-  def validate(data); end
-
-  def validate_instance(instance, &block); end
-  BOOLEANS = ::T.let(nil, ::T.untyped)
-  DEFAULT_REF_RESOLVER = ::T.let(nil, ::T.untyped)
-  ID_KEYWORD = ::T.let(nil, ::T.untyped)
-  INSERT_DEFAULT_PROPERTY = ::T.let(nil, ::T.untyped)
-  NET_HTTP_REF_RESOLVER = ::T.let(nil, ::T.untyped)
-  RUBY_REGEX_ANCHORS_TO_ECMA_262 = ::T.let(nil, ::T.untyped)
-end
-
-class JSONSchemer::Schema::Base::Instance
-  def after_property_validation(); end
-
-  def after_property_validation=(_); end
-
-  def before_property_validation(); end
-
-  def before_property_validation=(_); end
-
-  def data(); end
-
-  def data=(_); end
-
-  def data_pointer(); end
-
-  def data_pointer=(_); end
-
-  def merge(data: T.unsafe(nil), data_pointer: T.unsafe(nil), schema: T.unsafe(nil), schema_pointer: T.unsafe(nil), parent_uri: T.unsafe(nil), before_property_validation: T.unsafe(nil), after_property_validation: T.unsafe(nil)); end
-
-  def parent_uri(); end
-
-  def parent_uri=(_); end
-
-  def schema(); end
-
-  def schema=(_); end
-
-  def schema_pointer(); end
-
-  def schema_pointer=(_); end
-end
-
-class JSONSchemer::Schema::Base::Instance
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class JSONSchemer::Schema::Base
-end
-
-class JSONSchemer::Schema::Draft4
-  ID_KEYWORD = ::T.let(nil, ::T.untyped)
-  SUPPORTED_FORMATS = ::T.let(nil, ::T.untyped)
-end
-
-class JSONSchemer::Schema::Draft4
-end
-
-class JSONSchemer::Schema::Draft6
-  SUPPORTED_FORMATS = ::T.let(nil, ::T.untyped)
-end
-
-class JSONSchemer::Schema::Draft6
-end
-
-class JSONSchemer::Schema::Draft7
-  SUPPORTED_FORMATS = ::T.let(nil, ::T.untyped)
-end
-
-class JSONSchemer::Schema::Draft7
-end
-
-module JSONSchemer::Schema
-end
-
-class JSONSchemer::UnknownRef
-end
-
-class JSONSchemer::UnknownRef
-end
-
-class JSONSchemer::UnsupportedMetaSchema
-end
-
-class JSONSchemer::UnsupportedMetaSchema
-end
-
-module JSONSchemer
-  def self.schema(schema, **options); end
-end
-
 class Keg::ConflictError
   extend ::T::Private::Methods::MethodHooks
   extend ::T::Private::Methods::SingletonMethodHooks
@@ -11696,7 +5140,6 @@ module Kernel
 end
 
 module Kernel
-  extend ::Forwardable
   extend ::T::Private::Methods::MethodHooks
   extend ::T::Private::Methods::SingletonMethodHooks
   def self.at_exit(); end
@@ -11706,8 +5149,6 @@ module Kernel
   def self.gem(dep, *reqs); end
 
   def self.load(*arg); end
-
-  def self.require(path); end
 end
 
 class KeyError
@@ -11724,10 +5165,6 @@ module Language::Python::Virtualenv
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
-class LoadError
-  def is_missing?(location); end
-end
-
 class Locale
   extend ::T::Private::Methods::MethodHooks
   extend ::T::Private::Methods::SingletonMethodHooks
@@ -11749,1378 +5186,18 @@ module Logger::Period
   SiD = ::T.let(nil, ::T.untyped)
 end
 
-module MachO
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::CPUSubtypeError
-  def initialize(cputype, cpusubtype); end
-end
-
-class MachO::CPUSubtypeError
-end
-
-class MachO::CPUTypeError
-  def initialize(cputype); end
-end
-
-class MachO::CPUTypeError
-end
-
-class MachO::CodeSigningError
-end
-
-class MachO::CodeSigningError
-end
-
-class MachO::DylibIdMissingError
-  def initialize(); end
-end
-
-class MachO::DylibIdMissingError
-end
-
-class MachO::DylibUnknownError
-  def initialize(dylib); end
-end
-
-class MachO::DylibUnknownError
-end
-
-class MachO::FatArchOffsetOverflowError
-  def initialize(offset); end
-end
-
-class MachO::FatArchOffsetOverflowError
-end
-
-class MachO::FatBinaryError
-  def initialize(); end
-end
-
-class MachO::FatBinaryError
-end
-
-class MachO::FatFile
-  def add_rpath(path, options=T.unsafe(nil)); end
-
-  def bundle?(*args, &block); end
-
-  def change_dylib(old_name, new_name, options=T.unsafe(nil)); end
-
-  def change_dylib_id(new_id, options=T.unsafe(nil)); end
-
-  def change_install_name(old_name, new_name, options=T.unsafe(nil)); end
-
-  def change_rpath(old_path, new_path, options=T.unsafe(nil)); end
-
-  def core?(*args, &block); end
-
-  def delete_rpath(path, options=T.unsafe(nil)); end
-
-  def dsym?(*args, &block); end
-
-  def dylib?(*args, &block); end
-
-  def dylib_id(*args, &block); end
-
-  def dylib_id=(new_id, options=T.unsafe(nil)); end
-
-  def dylib_load_commands(); end
-
-  def dylinker?(*args, &block); end
-
-  def executable?(*args, &block); end
-
-  def extract(cputype); end
-
-  def fat_archs(); end
-
-  def filename(); end
-
-  def filename=(filename); end
-
-  def filetype(*args, &block); end
-
-  def fvmlib?(*args, &block); end
-
-  def header(); end
-
-  def initialize(filename, **opts); end
-
-  def initialize_from_bin(bin, opts); end
-
-  def kext?(*args, &block); end
-
-  def linked_dylibs(); end
-
-  def machos(); end
-
-  def magic(*args, &block); end
-
-  def magic_string(); end
-
-  def object?(*args, &block); end
-
-  def options(); end
-
-  def populate_fields(); end
-
-  def preload?(*args, &block); end
-
-  def rpaths(); end
-
-  def serialize(); end
-
-  def to_h(); end
-
-  def write(filename); end
-
-  def write!(); end
-end
-
-class MachO::FatFile
-  extend ::Forwardable
-  def self.new_from_bin(bin, **opts); end
-
-  def self.new_from_machos(*machos, fat64: T.unsafe(nil)); end
-end
-
-class MachO::FiletypeError
-  def initialize(num); end
-end
-
-class MachO::FiletypeError
-end
-
-class MachO::HeaderPadError
-  def initialize(filename); end
-end
-
-class MachO::HeaderPadError
-end
-
-module MachO::Headers
-  CPU_ARCH_ABI32 = ::T.let(nil, ::T.untyped)
-  CPU_ARCH_ABI64 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPES = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_486 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_486SX = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_586 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_ARM64E = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_ARM64_32_V8 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_ARM64_ALL = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_ARM64_V8 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_ARM_ALL = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_ARM_V4T = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_ARM_V5TEJ = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_ARM_V6 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_ARM_V6M = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_ARM_V7 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_ARM_V7EM = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_ARM_V7F = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_ARM_V7K = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_ARM_V7M = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_ARM_V7S = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_ARM_V8 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_ARM_XSCALE = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_I386 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_LIB64 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_MASK = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_MC68030 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_MC68030_ONLY = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_MC68040 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_MC680X0_ALL = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_MC88000_ALL = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_MC88100 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_MC88110 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_MMAX_JPC = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_PENT = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_PENTII_M3 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_PENTII_M5 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_PENTIUM_4 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_PENTPRO = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_POWERPC64_ALL = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_POWERPC_601 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_POWERPC_602 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_POWERPC_603 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_POWERPC_603E = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_POWERPC_603EV = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_POWERPC_604 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_POWERPC_604E = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_POWERPC_620 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_POWERPC_7400 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_POWERPC_7450 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_POWERPC_750 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_POWERPC_970 = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_POWERPC_ALL = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_X86_64_ALL = ::T.let(nil, ::T.untyped)
-  CPU_SUBTYPE_X86_64_H = ::T.let(nil, ::T.untyped)
-  CPU_TYPES = ::T.let(nil, ::T.untyped)
-  CPU_TYPE_ANY = ::T.let(nil, ::T.untyped)
-  CPU_TYPE_ARM = ::T.let(nil, ::T.untyped)
-  CPU_TYPE_ARM64 = ::T.let(nil, ::T.untyped)
-  CPU_TYPE_ARM64_32 = ::T.let(nil, ::T.untyped)
-  CPU_TYPE_I386 = ::T.let(nil, ::T.untyped)
-  CPU_TYPE_MC680X0 = ::T.let(nil, ::T.untyped)
-  CPU_TYPE_MC88000 = ::T.let(nil, ::T.untyped)
-  CPU_TYPE_POWERPC = ::T.let(nil, ::T.untyped)
-  CPU_TYPE_POWERPC64 = ::T.let(nil, ::T.untyped)
-  CPU_TYPE_X86_64 = ::T.let(nil, ::T.untyped)
-  FAT_CIGAM = ::T.let(nil, ::T.untyped)
-  FAT_CIGAM_64 = ::T.let(nil, ::T.untyped)
-  FAT_MAGIC = ::T.let(nil, ::T.untyped)
-  FAT_MAGIC_64 = ::T.let(nil, ::T.untyped)
-  MH_BUNDLE = ::T.let(nil, ::T.untyped)
-  MH_CIGAM = ::T.let(nil, ::T.untyped)
-  MH_CIGAM_64 = ::T.let(nil, ::T.untyped)
-  MH_CORE = ::T.let(nil, ::T.untyped)
-  MH_DSYM = ::T.let(nil, ::T.untyped)
-  MH_DYLIB = ::T.let(nil, ::T.untyped)
-  MH_DYLIB_STUB = ::T.let(nil, ::T.untyped)
-  MH_DYLINKER = ::T.let(nil, ::T.untyped)
-  MH_EXECUTE = ::T.let(nil, ::T.untyped)
-  MH_FILETYPES = ::T.let(nil, ::T.untyped)
-  MH_FLAGS = ::T.let(nil, ::T.untyped)
-  MH_FVMLIB = ::T.let(nil, ::T.untyped)
-  MH_KEXT_BUNDLE = ::T.let(nil, ::T.untyped)
-  MH_MAGIC = ::T.let(nil, ::T.untyped)
-  MH_MAGICS = ::T.let(nil, ::T.untyped)
-  MH_MAGIC_64 = ::T.let(nil, ::T.untyped)
-  MH_OBJECT = ::T.let(nil, ::T.untyped)
-  MH_PRELOAD = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::Headers::FatArch
-  def align(); end
-
-  def cpusubtype(); end
-
-  def cputype(); end
-
-  def initialize(cputype, cpusubtype, offset, size, align); end
-
-  def offset(); end
-
-  def serialize(); end
-
-  def size(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::Headers::FatArch
-end
-
-class MachO::Headers::FatArch64
-  def initialize(cputype, cpusubtype, offset, size, align, reserved=T.unsafe(nil)); end
-
-  def reserved(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::Headers::FatArch64
-end
-
-class MachO::Headers::FatHeader
-  def initialize(magic, nfat_arch); end
-
-  def magic(); end
-
-  def nfat_arch(); end
-
-  def serialize(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::Headers::FatHeader
-end
-
-class MachO::Headers::MachHeader
-  def alignment(); end
-
-  def bundle?(); end
-
-  def core?(); end
-
-  def cpusubtype(); end
-
-  def cputype(); end
-
-  def dsym?(); end
-
-  def dylib?(); end
-
-  def dylinker?(); end
-
-  def executable?(); end
-
-  def filetype(); end
-
-  def flag?(flag); end
-
-  def flags(); end
-
-  def fvmlib?(); end
-
-  def initialize(magic, cputype, cpusubtype, filetype, ncmds, sizeofcmds, flags); end
-
-  def kext?(); end
-
-  def magic(); end
-
-  def magic32?(); end
-
-  def magic64?(); end
-
-  def ncmds(); end
-
-  def object?(); end
-
-  def preload?(); end
-
-  def sizeofcmds(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::Headers::MachHeader
-end
-
-class MachO::Headers::MachHeader64
-  def initialize(magic, cputype, cpusubtype, filetype, ncmds, sizeofcmds, flags, reserved); end
-
-  def reserved(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::Headers::MachHeader64
-end
-
-module MachO::Headers
-end
-
-class MachO::JavaClassFileError
-  def initialize(); end
-end
-
-class MachO::JavaClassFileError
-end
-
-class MachO::LCStrMalformedError
-  def initialize(lc); end
-end
-
-class MachO::LCStrMalformedError
-end
-
-class MachO::LoadCommandCreationArityError
-  def initialize(cmd_sym, expected_arity, actual_arity); end
-end
-
-class MachO::LoadCommandCreationArityError
-end
-
-class MachO::LoadCommandError
-  def initialize(num); end
-end
-
-class MachO::LoadCommandError
-end
-
-class MachO::LoadCommandNotCreatableError
-  def initialize(cmd_sym); end
-end
-
-class MachO::LoadCommandNotCreatableError
-end
-
-class MachO::LoadCommandNotSerializableError
-  def initialize(cmd_sym); end
-end
-
-class MachO::LoadCommandNotSerializableError
-end
-
-module MachO::LoadCommands
-  CREATABLE_LOAD_COMMANDS = ::T.let(nil, ::T.untyped)
-  DYLIB_LOAD_COMMANDS = ::T.let(nil, ::T.untyped)
-  LC_REQ_DYLD = ::T.let(nil, ::T.untyped)
-  LC_STRUCTURES = ::T.let(nil, ::T.untyped)
-  LOAD_COMMANDS = ::T.let(nil, ::T.untyped)
-  LOAD_COMMAND_CONSTANTS = ::T.let(nil, ::T.untyped)
-  SEGMENT_FLAGS = ::T.let(nil, ::T.untyped)
-  SEGMENT_NAMES = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::BuildVersionCommand
-  def initialize(view, cmd, cmdsize, platform, minos, sdk, ntools); end
-
-  def minos(); end
-
-  def minos_string(); end
-
-  def platform(); end
-
-  def sdk(); end
-
-  def sdk_string(); end
-
-  def tool_entries(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::BuildVersionCommand::ToolEntries
-  def initialize(view, ntools); end
-
-  def tools(); end
-end
-
-class MachO::LoadCommands::BuildVersionCommand::ToolEntries::Tool
-  def initialize(tool, version); end
-
-  def to_h(); end
-
-  def tool(); end
-
-  def version(); end
-end
-
-class MachO::LoadCommands::BuildVersionCommand::ToolEntries::Tool
-end
-
-class MachO::LoadCommands::BuildVersionCommand::ToolEntries
-end
-
-class MachO::LoadCommands::BuildVersionCommand
-end
-
-class MachO::LoadCommands::DyldInfoCommand
-  def bind_off(); end
-
-  def bind_size(); end
-
-  def export_off(); end
-
-  def export_size(); end
-
-  def initialize(view, cmd, cmdsize, rebase_off, rebase_size, bind_off, bind_size, weak_bind_off, weak_bind_size, lazy_bind_off, lazy_bind_size, export_off, export_size); end
-
-  def lazy_bind_off(); end
-
-  def lazy_bind_size(); end
-
-  def rebase_off(); end
-
-  def rebase_size(); end
-
-  def weak_bind_off(); end
-
-  def weak_bind_size(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::DyldInfoCommand
-end
-
-class MachO::LoadCommands::DylibCommand
-  def compatibility_version(); end
-
-  def current_version(); end
-
-  def initialize(view, cmd, cmdsize, name, timestamp, current_version, compatibility_version); end
-
-  def name(); end
-
-  def timestamp(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::DylibCommand
-end
-
-class MachO::LoadCommands::DylinkerCommand
-  def initialize(view, cmd, cmdsize, name); end
-
-  def name(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::DylinkerCommand
-end
-
-class MachO::LoadCommands::DysymtabCommand
-  def extrefsymoff(); end
-
-  def extreloff(); end
-
-  def iextdefsym(); end
-
-  def ilocalsym(); end
-
-  def indirectsymoff(); end
-
-  def initialize(view, cmd, cmdsize, ilocalsym, nlocalsym, iextdefsym, nextdefsym, iundefsym, nundefsym, tocoff, ntoc, modtaboff, nmodtab, extrefsymoff, nextrefsyms, indirectsymoff, nindirectsyms, extreloff, nextrel, locreloff, nlocrel); end
-
-  def iundefsym(); end
-
-  def locreloff(); end
-
-  def modtaboff(); end
-
-  def nextdefsym(); end
-
-  def nextrefsyms(); end
-
-  def nextrel(); end
-
-  def nindirectsyms(); end
-
-  def nlocalsym(); end
-
-  def nlocrel(); end
-
-  def nmodtab(); end
-
-  def ntoc(); end
-
-  def nundefsym(); end
-
-  def tocoff(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::DysymtabCommand
-end
-
-class MachO::LoadCommands::EncryptionInfoCommand
-  def cryptid(); end
-
-  def cryptoff(); end
-
-  def cryptsize(); end
-
-  def initialize(view, cmd, cmdsize, cryptoff, cryptsize, cryptid); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::EncryptionInfoCommand
-end
-
-class MachO::LoadCommands::EncryptionInfoCommand64
-  def initialize(view, cmd, cmdsize, cryptoff, cryptsize, cryptid, pad); end
-
-  def pad(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::EncryptionInfoCommand64
-end
-
-class MachO::LoadCommands::EntryPointCommand
-  def entryoff(); end
-
-  def initialize(view, cmd, cmdsize, entryoff, stacksize); end
-
-  def stacksize(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::EntryPointCommand
-end
-
-class MachO::LoadCommands::FvmfileCommand
-  def header_addr(); end
-
-  def initialize(view, cmd, cmdsize, name, header_addr); end
-
-  def name(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::FvmfileCommand
-end
-
-class MachO::LoadCommands::FvmlibCommand
-  def header_addr(); end
-
-  def initialize(view, cmd, cmdsize, name, minor_version, header_addr); end
-
-  def minor_version(); end
-
-  def name(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::FvmlibCommand
-end
-
-class MachO::LoadCommands::IdentCommand
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::IdentCommand
-end
-
-class MachO::LoadCommands::LinkeditDataCommand
-  def dataoff(); end
-
-  def datasize(); end
-
-  def initialize(view, cmd, cmdsize, dataoff, datasize); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::LinkeditDataCommand
-end
-
-class MachO::LoadCommands::LinkerOptionCommand
-  def count(); end
-
-  def initialize(view, cmd, cmdsize, count); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::LinkerOptionCommand
-end
-
-class MachO::LoadCommands::LoadCommand
-  def cmd(); end
-
-  def cmdsize(); end
-
-  def initialize(view, cmd, cmdsize); end
-
-  def offset(); end
-
-  def serializable?(); end
-
-  def serialize(context); end
-
-  def to_sym(); end
-
-  def type(); end
-
-  def view(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::LoadCommand::LCStr
-  def initialize(lc, lc_str); end
-
-  def to_h(); end
-
-  def to_i(); end
-end
-
-class MachO::LoadCommands::LoadCommand::LCStr
-end
-
-class MachO::LoadCommands::LoadCommand::SerializationContext
-  def alignment(); end
-
-  def endianness(); end
-
-  def initialize(endianness, alignment); end
-end
-
-class MachO::LoadCommands::LoadCommand::SerializationContext
-  def self.context_for(macho); end
-end
-
-class MachO::LoadCommands::LoadCommand
-  def self.create(cmd_sym, *args); end
-
-  def self.new_from_bin(view); end
-end
-
-class MachO::LoadCommands::NoteCommand
-  def data_owner(); end
-
-  def initialize(view, cmd, cmdsize, data_owner, offset, size); end
-
-  def size(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::NoteCommand
-end
-
-class MachO::LoadCommands::PrebindCksumCommand
-  def cksum(); end
-
-  def initialize(view, cmd, cmdsize, cksum); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::PrebindCksumCommand
-end
-
-class MachO::LoadCommands::PreboundDylibCommand
-  def initialize(view, cmd, cmdsize, name, nmodules, linked_modules); end
-
-  def linked_modules(); end
-
-  def name(); end
-
-  def nmodules(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::PreboundDylibCommand
-end
-
-class MachO::LoadCommands::RoutinesCommand
-  def init_address(); end
-
-  def init_module(); end
-
-  def initialize(view, cmd, cmdsize, init_address, init_module, reserved1, reserved2, reserved3, reserved4, reserved5, reserved6); end
-
-  def reserved1(); end
-
-  def reserved2(); end
-
-  def reserved3(); end
-
-  def reserved4(); end
-
-  def reserved5(); end
-
-  def reserved6(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::RoutinesCommand
-end
-
-class MachO::LoadCommands::RoutinesCommand64
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::RoutinesCommand64
-end
-
-class MachO::LoadCommands::RpathCommand
-  def initialize(view, cmd, cmdsize, path); end
-
-  def path(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::RpathCommand
-end
-
-class MachO::LoadCommands::SegmentCommand
-  def fileoff(); end
-
-  def filesize(); end
-
-  def flag?(flag); end
-
-  def flags(); end
-
-  def guess_align(); end
-
-  def initialize(view, cmd, cmdsize, segname, vmaddr, vmsize, fileoff, filesize, maxprot, initprot, nsects, flags); end
-
-  def initprot(); end
-
-  def maxprot(); end
-
-  def nsects(); end
-
-  def sections(); end
-
-  def segname(); end
-
-  def vmaddr(); end
-
-  def vmsize(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::SegmentCommand
-end
-
-class MachO::LoadCommands::SegmentCommand64
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::SegmentCommand64
-end
-
-class MachO::LoadCommands::SourceVersionCommand
-  def initialize(view, cmd, cmdsize, version); end
-
-  def version(); end
-
-  def version_string(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::SourceVersionCommand
-end
-
-class MachO::LoadCommands::SubClientCommand
-  def initialize(view, cmd, cmdsize, sub_client); end
-
-  def sub_client(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::SubClientCommand
-end
-
-class MachO::LoadCommands::SubFrameworkCommand
-  def initialize(view, cmd, cmdsize, umbrella); end
-
-  def umbrella(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::SubFrameworkCommand
-end
-
-class MachO::LoadCommands::SubLibraryCommand
-  def initialize(view, cmd, cmdsize, sub_library); end
-
-  def sub_library(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::SubLibraryCommand
-end
-
-class MachO::LoadCommands::SubUmbrellaCommand
-  def initialize(view, cmd, cmdsize, sub_umbrella); end
-
-  def sub_umbrella(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::SubUmbrellaCommand
-end
-
-class MachO::LoadCommands::SymsegCommand
-  def initialize(view, cmd, cmdsize, offset, size); end
-
-  def size(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::SymsegCommand
-end
-
-class MachO::LoadCommands::SymtabCommand
-  def initialize(view, cmd, cmdsize, symoff, nsyms, stroff, strsize); end
-
-  def nsyms(); end
-
-  def stroff(); end
-
-  def strsize(); end
-
-  def symoff(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::SymtabCommand
-end
-
-class MachO::LoadCommands::ThreadCommand
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::ThreadCommand
-end
-
-class MachO::LoadCommands::TwolevelHintsCommand
-  def htoffset(); end
-
-  def initialize(view, cmd, cmdsize, htoffset, nhints); end
-
-  def nhints(); end
-
-  def table(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::TwolevelHintsCommand::TwolevelHintsTable
-  def hints(); end
-
-  def initialize(view, htoffset, nhints); end
-end
-
-class MachO::LoadCommands::TwolevelHintsCommand::TwolevelHintsTable::TwolevelHint
-  def initialize(blob); end
-
-  def isub_image(); end
-
-  def itoc(); end
-
-  def to_h(); end
-end
-
-class MachO::LoadCommands::TwolevelHintsCommand::TwolevelHintsTable::TwolevelHint
-end
-
-class MachO::LoadCommands::TwolevelHintsCommand::TwolevelHintsTable
-end
-
-class MachO::LoadCommands::TwolevelHintsCommand
-end
-
-class MachO::LoadCommands::UUIDCommand
-  def initialize(view, cmd, cmdsize, uuid); end
-
-  def uuid(); end
-
-  def uuid_string(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::UUIDCommand
-end
-
-class MachO::LoadCommands::VersionMinCommand
-  def initialize(view, cmd, cmdsize, version, sdk); end
-
-  def sdk(); end
-
-  def sdk_string(); end
-
-  def version(); end
-
-  def version_string(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::LoadCommands::VersionMinCommand
-end
-
-module MachO::LoadCommands
-end
-
-class MachO::MachOBinaryError
-  def initialize(); end
-end
-
-class MachO::MachOBinaryError
-end
-
-class MachO::MachOError
-end
-
-class MachO::MachOError
-end
-
-class MachO::MachOFile
-  def [](name); end
-
-  def add_command(lc, options=T.unsafe(nil)); end
-
-  def add_rpath(path, _options=T.unsafe(nil)); end
-
-  def alignment(*args, &block); end
-
-  def bundle?(*args, &block); end
-
-  def change_dylib(old_name, new_name, _options=T.unsafe(nil)); end
-
-  def change_dylib_id(new_id, _options=T.unsafe(nil)); end
-
-  def change_install_name(old_name, new_name, _options=T.unsafe(nil)); end
-
-  def change_rpath(old_path, new_path, _options=T.unsafe(nil)); end
-
-  def command(name); end
-
-  def core?(*args, &block); end
-
-  def cpusubtype(); end
-
-  def cputype(); end
-
-  def delete_command(lc, options=T.unsafe(nil)); end
-
-  def delete_rpath(path, _options=T.unsafe(nil)); end
-
-  def dsym?(*args, &block); end
-
-  def dylib?(*args, &block); end
-
-  def dylib_id(); end
-
-  def dylib_id=(new_id, _options=T.unsafe(nil)); end
-
-  def dylib_load_commands(); end
-
-  def dylinker?(*args, &block); end
-
-  def endianness(); end
-
-  def executable?(*args, &block); end
-
-  def filename(); end
-
-  def filename=(filename); end
-
-  def filetype(); end
-
-  def flags(*args, &block); end
-
-  def fvmlib?(*args, &block); end
-
-  def header(); end
-
-  def initialize(filename, **opts); end
-
-  def initialize_from_bin(bin, opts); end
-
-  def insert_command(offset, lc, options=T.unsafe(nil)); end
-
-  def kext?(*args, &block); end
-
-  def linked_dylibs(); end
-
-  def load_commands(); end
-
-  def magic(*args, &block); end
-
-  def magic32?(*args, &block); end
-
-  def magic64?(*args, &block); end
-
-  def magic_string(); end
-
-  def ncmds(*args, &block); end
-
-  def object?(*args, &block); end
-
-  def options(); end
-
-  def populate_fields(); end
-
-  def preload?(*args, &block); end
-
-  def replace_command(old_lc, new_lc); end
-
-  def rpaths(); end
-
-  def segment_alignment(); end
-
-  def segments(); end
-
-  def serialize(); end
-
-  def sizeofcmds(*args, &block); end
-
-  def to_h(); end
-
-  def write(filename); end
-
-  def write!(); end
-end
-
-class MachO::MachOFile
-  extend ::Forwardable
-  def self.new_from_bin(bin, **opts); end
-end
-
-class MachO::MachOStructure
-  def to_h(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::MachOStructure
-  def self.bytesize(); end
-
-  def self.new_from_bin(endianness, bin); end
-end
-
-class MachO::MachOView
-  def endianness(); end
-
-  def initialize(raw_data, endianness, offset); end
-
-  def offset(); end
-
-  def raw_data(); end
-
-  def to_h(); end
-end
-
-class MachO::MachOView
-end
-
-class MachO::MagicError
-  def initialize(magic); end
-end
-
-class MachO::MagicError
-end
-
-class MachO::ModificationError
-end
-
-class MachO::ModificationError
-end
-
-class MachO::NotAMachOError
-end
-
-class MachO::NotAMachOError
-end
-
-class MachO::OffsetInsertionError
-  def initialize(offset); end
-end
-
-class MachO::OffsetInsertionError
-end
-
-class MachO::RecoverableModificationError
-  def macho_slice(); end
-
-  def macho_slice=(macho_slice); end
-end
-
-class MachO::RecoverableModificationError
-end
-
-class MachO::RpathExistsError
-  def initialize(path); end
-end
-
-class MachO::RpathExistsError
-end
-
-class MachO::RpathUnknownError
-  def initialize(path); end
-end
-
-class MachO::RpathUnknownError
-end
-
-module MachO::Sections
-  MAX_SECT_ALIGN = ::T.let(nil, ::T.untyped)
-  SECTION_ATTRIBUTES = ::T.let(nil, ::T.untyped)
-  SECTION_ATTRIBUTES_SYS = ::T.let(nil, ::T.untyped)
-  SECTION_ATTRIBUTES_USR = ::T.let(nil, ::T.untyped)
-  SECTION_FLAGS = ::T.let(nil, ::T.untyped)
-  SECTION_NAMES = ::T.let(nil, ::T.untyped)
-  SECTION_TYPE = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::Sections::Section
-  def addr(); end
-
-  def align(); end
-
-  def empty?(); end
-
-  def flag?(flag); end
-
-  def flags(); end
-
-  def initialize(sectname, segname, addr, size, offset, align, reloff, nreloc, flags, reserved1, reserved2); end
-
-  def nreloc(); end
-
-  def offset(); end
-
-  def reloff(); end
-
-  def reserved1(); end
-
-  def reserved2(); end
-
-  def section_name(); end
-
-  def sectname(); end
-
-  def segment_name(); end
-
-  def segname(); end
-
-  def size(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::Sections::Section
-end
-
-class MachO::Sections::Section64
-  def initialize(sectname, segname, addr, size, offset, align, reloff, nreloc, flags, reserved1, reserved2, reserved3); end
-
-  def reserved3(); end
-  FORMAT = ::T.let(nil, ::T.untyped)
-  SIZEOF = ::T.let(nil, ::T.untyped)
-end
-
-class MachO::Sections::Section64
-end
-
-module MachO::Sections
-end
-
-module MachO::Tools
-end
-
-module MachO::Tools
-  def self.add_rpath(filename, new_path, options=T.unsafe(nil)); end
-
-  def self.change_dylib_id(filename, new_id, options=T.unsafe(nil)); end
-
-  def self.change_install_name(filename, old_name, new_name, options=T.unsafe(nil)); end
-
-  def self.change_rpath(filename, old_path, new_path, options=T.unsafe(nil)); end
-
-  def self.delete_rpath(filename, old_path, options=T.unsafe(nil)); end
-
-  def self.dylibs(filename); end
-
-  def self.merge_machos(filename, *files, fat64: T.unsafe(nil)); end
-end
-
-class MachO::TruncatedFileError
-  def initialize(); end
-end
-
-class MachO::TruncatedFileError
-end
-
-class MachO::UnimplementedError
-  def initialize(thing); end
-end
-
-class MachO::UnimplementedError
-end
-
-module MachO::Utils
-end
-
-module MachO::Utils
-  def self.big_magic?(num); end
-
-  def self.fat_magic32?(num); end
-
-  def self.fat_magic64?(num); end
-
-  def self.fat_magic?(num); end
-
-  def self.little_magic?(num); end
-
-  def self.magic32?(num); end
-
-  def self.magic64?(num); end
-
-  def self.magic?(num); end
-
-  def self.nullpad(size); end
-
-  def self.pack_strings(fixed_offset, alignment, strings=T.unsafe(nil)); end
-
-  def self.padding_for(size, alignment); end
-
-  def self.round(value, round); end
-
-  def self.specialize_format(format, endianness); end
-end
-
-module MachO
-  def self.codesign!(filename); end
-
-  def self.open(filename); end
-end
-
 module MachOShim
   def dylib_id(*args, &block); end
 
   def rpaths(*args, &block); end
 end
 
-Markdown = RDiscount
-
-module MessagePack
-  DEFAULT_EMPTY_PARAMS = ::T.let(nil, ::T.untyped)
-end
-
 class MessagePack::Packer
   def write_bin(arg); end
 
   def write_bin_header(arg); end
 end
 
-module MessagePack::Time
-  Packer = ::T.let(nil, ::T.untyped)
-  TIME_AT_3_AVAILABLE = ::T.let(nil, ::T.untyped)
-  Unpacker = ::T.let(nil, ::T.untyped)
-end
-
-module MessagePack::Time
-end
-
-class MessagePack::Timestamp
-  def ==(other); end
-
-  def initialize(sec, nsec); end
-
-  def nsec(); end
-
-  def sec(); end
-
-  def to_msgpack_ext(); end
-  TIMESTAMP32_MAX_SEC = ::T.let(nil, ::T.untyped)
-  TIMESTAMP64_MAX_SEC = ::T.let(nil, ::T.untyped)
-  TYPE = ::T.let(nil, ::T.untyped)
-end
-
-class MessagePack::Timestamp
-  def self.from_msgpack_ext(data); end
-
-  def self.to_msgpack_ext(sec, nsec); end
-end
-
 class MessagePack::Unpacker
   def feed_reference(arg); end
 
@@ -13137,95 +5214,6 @@ class Method
   include ::MethodSource::MethodExtensions
 end
 
-module MethodSource
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
-module MethodSource::CodeHelpers
-  def comment_describing(file, line_number); end
-
-  def complete_expression?(str); end
-
-  def expression_at(file, line_number, options=T.unsafe(nil)); end
-end
-
-module MethodSource::CodeHelpers::IncompleteExpression
-  GENERIC_REGEXPS = ::T.let(nil, ::T.untyped)
-  RBX_ONLY_REGEXPS = ::T.let(nil, ::T.untyped)
-end
-
-module MethodSource::CodeHelpers::IncompleteExpression
-  def self.===(ex); end
-
-  def self.rbx?(); end
-end
-
-module MethodSource::CodeHelpers
-end
-
-module MethodSource::MethodExtensions
-  def comment(); end
-
-  def source(); end
-end
-
-module MethodSource::MethodExtensions
-  def self.included(klass); end
-end
-
-module MethodSource::ReeSourceLocation
-  def source_location(); end
-end
-
-module MethodSource::ReeSourceLocation
-end
-
-module MethodSource::SourceLocation
-end
-
-module MethodSource::SourceLocation::MethodExtensions
-  def source_location(); end
-end
-
-module MethodSource::SourceLocation::MethodExtensions
-end
-
-module MethodSource::SourceLocation::ProcExtensions
-  def source_location(); end
-end
-
-module MethodSource::SourceLocation::ProcExtensions
-end
-
-module MethodSource::SourceLocation::UnboundMethodExtensions
-  def source_location(); end
-end
-
-module MethodSource::SourceLocation::UnboundMethodExtensions
-end
-
-module MethodSource::SourceLocation
-end
-
-class MethodSource::SourceNotFoundError
-end
-
-class MethodSource::SourceNotFoundError
-end
-
-module MethodSource
-  extend ::MethodSource::CodeHelpers
-  def self.comment_helper(source_location, name=T.unsafe(nil)); end
-
-  def self.extract_code(source_location); end
-
-  def self.lines_for(file_name, name=T.unsafe(nil)); end
-
-  def self.source_helper(source_location, name=T.unsafe(nil)); end
-
-  def self.valid_expression?(str); end
-end
-
 class Migrator
   extend ::T::Private::Methods::MethodHooks
   extend ::T::Private::Methods::SingletonMethodHooks
@@ -13233,183 +5221,8 @@ end
 
 MiniTest = Minitest
 
-module Minitest
-  ENCS = ::T.let(nil, ::T.untyped)
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
-class Minitest::AbstractReporter
-  include ::Mutex_m
-  def lock(); end
-
-  def locked?(); end
-
-  def passed?(); end
-
-  def prerecord(klass, name); end
-
-  def record(result); end
-
-  def report(); end
-
-  def start(); end
-
-  def synchronize(&block); end
-
-  def try_lock(); end
-
-  def unlock(); end
-end
-
-class Minitest::AbstractReporter
-end
-
-class Minitest::Assertion
-  def error(); end
-
-  def location(); end
-
-  def result_code(); end
-
-  def result_label(); end
-end
-
-class Minitest::Assertion
-end
-
 module Minitest::Assertions
-  def _synchronize(); end
-
-  def assert(test, msg=T.unsafe(nil)); end
-
-  def assert_empty(obj, msg=T.unsafe(nil)); end
-
-  def assert_equal(exp, act, msg=T.unsafe(nil)); end
-
-  def assert_in_delta(exp, act, delta=T.unsafe(nil), msg=T.unsafe(nil)); end
-
-  def assert_in_epsilon(exp, act, epsilon=T.unsafe(nil), msg=T.unsafe(nil)); end
-
-  def assert_includes(collection, obj, msg=T.unsafe(nil)); end
-
-  def assert_instance_of(cls, obj, msg=T.unsafe(nil)); end
-
-  def assert_kind_of(cls, obj, msg=T.unsafe(nil)); end
-
-  def assert_match(matcher, obj, msg=T.unsafe(nil)); end
-
   def assert_mock(mock); end
-
-  def assert_nil(obj, msg=T.unsafe(nil)); end
-
-  def assert_operator(o1, op, o2=T.unsafe(nil), msg=T.unsafe(nil)); end
-
-  def assert_output(stdout=T.unsafe(nil), stderr=T.unsafe(nil)); end
-
-  def assert_path_exists(path, msg=T.unsafe(nil)); end
-
-  def assert_predicate(o1, op, msg=T.unsafe(nil)); end
-
-  def assert_raises(*exp); end
-
-  def assert_respond_to(obj, meth, msg=T.unsafe(nil)); end
-
-  def assert_same(exp, act, msg=T.unsafe(nil)); end
-
-  def assert_send(send_ary, m=T.unsafe(nil)); end
-
-  def assert_silent(); end
-
-  def assert_throws(sym, msg=T.unsafe(nil)); end
-
-  def capture_io(); end
-
-  def capture_subprocess_io(); end
-
-  def diff(exp, act); end
-
-  def exception_details(e, msg); end
-
-  def fail_after(y, m, d, msg); end
-
-  def flunk(msg=T.unsafe(nil)); end
-
-  def message(msg=T.unsafe(nil), ending=T.unsafe(nil), &default); end
-
-  def mu_pp(obj); end
-
-  def mu_pp_for_diff(obj); end
-
-  def pass(_msg=T.unsafe(nil)); end
-
-  def refute(test, msg=T.unsafe(nil)); end
-
-  def refute_empty(obj, msg=T.unsafe(nil)); end
-
-  def refute_equal(exp, act, msg=T.unsafe(nil)); end
-
-  def refute_in_delta(exp, act, delta=T.unsafe(nil), msg=T.unsafe(nil)); end
-
-  def refute_in_epsilon(a, b, epsilon=T.unsafe(nil), msg=T.unsafe(nil)); end
-
-  def refute_includes(collection, obj, msg=T.unsafe(nil)); end
-
-  def refute_instance_of(cls, obj, msg=T.unsafe(nil)); end
-
-  def refute_kind_of(cls, obj, msg=T.unsafe(nil)); end
-
-  def refute_match(matcher, obj, msg=T.unsafe(nil)); end
-
-  def refute_nil(obj, msg=T.unsafe(nil)); end
-
-  def refute_operator(o1, op, o2=T.unsafe(nil), msg=T.unsafe(nil)); end
-
-  def refute_path_exists(path, msg=T.unsafe(nil)); end
-
-  def refute_predicate(o1, op, msg=T.unsafe(nil)); end
-
-  def refute_respond_to(obj, meth, msg=T.unsafe(nil)); end
-
-  def refute_same(exp, act, msg=T.unsafe(nil)); end
-
-  def skip(msg=T.unsafe(nil), bt=T.unsafe(nil)); end
-
-  def skip_until(y, m, d, msg); end
-
-  def skipped?(); end
-
-  def things_to_diff(exp, act); end
-  E = ::T.let(nil, ::T.untyped)
-  UNDEFINED = ::T.let(nil, ::T.untyped)
-end
-
-module Minitest::Assertions
-  def self.diff(); end
-
-  def self.diff=(o); end
-end
-
-class Minitest::BacktraceFilter
-  def filter(bt); end
-  MT_RE = ::T.let(nil, ::T.untyped)
-end
-
-class Minitest::BacktraceFilter
-end
-
-class Minitest::CompositeReporter
-  def <<(reporter); end
-
-  def initialize(*reporters); end
-
-  def io(); end
-
-  def reporters(); end
-
-  def reporters=(reporters); end
-end
-
-class Minitest::CompositeReporter
 end
 
 class Minitest::Expectation
@@ -13497,23 +5310,6 @@ end
 module Minitest::Expectations
 end
 
-module Minitest::Guard
-  def jruby?(platform=T.unsafe(nil)); end
-
-  def maglev?(platform=T.unsafe(nil)); end
-
-  def mri?(platform=T.unsafe(nil)); end
-
-  def osx?(platform=T.unsafe(nil)); end
-
-  def rubinius?(platform=T.unsafe(nil)); end
-
-  def windows?(platform=T.unsafe(nil)); end
-end
-
-module Minitest::Guard
-end
-
 class Minitest::Mock
   def ===(*args, &b); end
 
@@ -13551,159 +5347,6 @@ end
 class Minitest::Mock
 end
 
-module Minitest::Parallel
-end
-
-class Minitest::Parallel::Executor
-  def <<(work); end
-
-  def initialize(size); end
-
-  def shutdown(); end
-
-  def size(); end
-
-  def start(); end
-end
-
-class Minitest::Parallel::Executor
-end
-
-module Minitest::Parallel::Test
-  def _synchronize(); end
-end
-
-module Minitest::Parallel::Test::ClassMethods
-  def run_one_method(klass, method_name, reporter); end
-
-  def test_order(); end
-end
-
-module Minitest::Parallel::Test::ClassMethods
-end
-
-module Minitest::Parallel::Test
-end
-
-module Minitest::Parallel
-end
-
-class Minitest::ProgressReporter
-end
-
-class Minitest::ProgressReporter
-end
-
-module Minitest::Reportable
-  def class_name(); end
-
-  def error?(); end
-
-  def location(); end
-
-  def passed?(); end
-
-  def result_code(); end
-
-  def skipped?(); end
-end
-
-module Minitest::Reportable
-end
-
-class Minitest::Reporter
-  def initialize(io=T.unsafe(nil), options=T.unsafe(nil)); end
-
-  def io(); end
-
-  def io=(io); end
-
-  def options(); end
-
-  def options=(options); end
-end
-
-class Minitest::Reporter
-end
-
-class Minitest::Result
-  include ::Minitest::Reportable
-  def klass(); end
-
-  def klass=(klass); end
-
-  def source_location(); end
-
-  def source_location=(source_location); end
-end
-
-class Minitest::Result
-  def self.from(runnable); end
-end
-
-class Minitest::Runnable
-  def assertions(); end
-
-  def assertions=(assertions); end
-
-  def failure(); end
-
-  def failures(); end
-
-  def failures=(failures); end
-
-  def initialize(name); end
-
-  def marshal_dump(); end
-
-  def marshal_load(ary); end
-
-  def name(); end
-
-  def name=(o); end
-
-  def passed?(); end
-
-  def result_code(); end
-
-  def run(); end
-
-  def skipped?(); end
-
-  def time(); end
-
-  def time=(time); end
-
-  def time_it(); end
-  SIGNALS = ::T.let(nil, ::T.untyped)
-end
-
-class Minitest::Runnable
-  def self.inherited(klass); end
-
-  def self.methods_matching(re); end
-
-  def self.on_signal(name, action); end
-
-  def self.reset(); end
-
-  def self.run(reporter, options=T.unsafe(nil)); end
-
-  def self.run_one_method(klass, method_name, reporter); end
-
-  def self.runnable_methods(); end
-
-  def self.runnables(); end
-
-  def self.with_info_handler(reporter, &block); end
-end
-
-class Minitest::Skip
-end
-
-class Minitest::Skip
-end
-
 class Minitest::Spec
   include ::Minitest::Spec::DSL::InstanceMethods
   TYPES = ::T.let(nil, ::T.untyped)
@@ -13764,173 +5407,6 @@ class Minitest::Spec
   def self.current(); end
 end
 
-class Minitest::StatisticsReporter
-  def assertions(); end
-
-  def assertions=(assertions); end
-
-  def count(); end
-
-  def count=(count); end
-
-  def errors(); end
-
-  def errors=(errors); end
-
-  def failures(); end
-
-  def failures=(failures); end
-
-  def results(); end
-
-  def results=(results); end
-
-  def skips(); end
-
-  def skips=(skips); end
-
-  def start_time(); end
-
-  def start_time=(start_time); end
-
-  def total_time(); end
-
-  def total_time=(total_time); end
-end
-
-class Minitest::StatisticsReporter
-end
-
-class Minitest::SummaryReporter
-  def aggregated_results(io); end
-
-  def old_sync(); end
-
-  def old_sync=(old_sync); end
-
-  def statistics(); end
-
-  def summary(); end
-
-  def sync(); end
-
-  def sync=(sync); end
-end
-
-class Minitest::SummaryReporter
-end
-
-class Minitest::Test
-  include ::Minitest::Assertions
-  include ::Minitest::Reportable
-  include ::Minitest::Test::LifecycleHooks
-  include ::Minitest::Guard
-  def capture_exceptions(); end
-
-  def with_info_handler(&block); end
-  PASSTHROUGH_EXCEPTIONS = ::T.let(nil, ::T.untyped)
-  TEARDOWN_METHODS = ::T.let(nil, ::T.untyped)
-end
-
-module Minitest::Test::LifecycleHooks
-  def after_setup(); end
-
-  def after_teardown(); end
-
-  def before_setup(); end
-
-  def before_teardown(); end
-
-  def setup(); end
-
-  def teardown(); end
-end
-
-module Minitest::Test::LifecycleHooks
-end
-
-class Minitest::Test
-  extend ::Minitest::Guard
-  def self.i_suck_and_my_tests_are_order_dependent!(); end
-
-  def self.io_lock(); end
-
-  def self.io_lock=(io_lock); end
-
-  def self.make_my_diffs_pretty!(); end
-
-  def self.parallelize_me!(); end
-
-  def self.test_order(); end
-end
-
-class Minitest::UnexpectedError
-  def error=(error); end
-
-  def initialize(error); end
-end
-
-class Minitest::UnexpectedError
-end
-
-class Minitest::Unit
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
-class Minitest::Unit::TestCase
-end
-
-class Minitest::Unit::TestCase
-end
-
-class Minitest::Unit
-  def self.after_tests(&b); end
-
-  def self.autorun(); end
-end
-
-module Minitest
-  def self.__run(reporter, options); end
-
-  def self.after_run(&block); end
-
-  def self.autorun(); end
-
-  def self.backtrace_filter(); end
-
-  def self.backtrace_filter=(backtrace_filter); end
-
-  def self.clock_time(); end
-
-  def self.extensions(); end
-
-  def self.extensions=(extensions); end
-
-  def self.filter_backtrace(bt); end
-
-  def self.info_signal(); end
-
-  def self.info_signal=(info_signal); end
-
-  def self.init_plugins(options); end
-
-  def self.load_plugins(); end
-
-  def self.parallel_executor(); end
-
-  def self.parallel_executor=(parallel_executor); end
-
-  def self.process_args(args=T.unsafe(nil)); end
-
-  def self.reporter(); end
-
-  def self.reporter=(reporter); end
-
-  def self.run(args=T.unsafe(nil)); end
-
-  def self.run_one_method(klass, method_name); end
-end
-
 class Mktemp
   include ::FileUtils::StreamUtils_
 end
@@ -13947,15 +5423,8 @@ class MockExpectationError
 end
 
 class Module
-  include ::ActiveSupport::Dependencies::ModuleConstMissing
-  def alias_attribute(new_name, old_name); end
-
-  def anonymous?(); end
-
   def context(*a, &b); end
 
-  def deprecate(*method_names); end
-
   def describe(*a, &b); end
 
   def example_group(*a, &b); end
@@ -13966,16 +5435,6 @@ class Module
 
   def infect_an_assertion(meth, new_name, dont_flip=T.unsafe(nil)); end
 
-  def module_parent(); end
-
-  def module_parent_name(); end
-
-  def module_parents(); end
-
-  def remove_possible_method(method); end
-
-  def remove_possible_singleton_method(method); end
-
   def shared_context(name, *args, &block); end
 
   def shared_examples(name, *args, &block); end
@@ -14003,244 +5462,6 @@ class MonitorMixin::ConditionVariable
   def initialize(monitor); end
 end
 
-class Mustache
-  def [](key); end
-
-  def []=(key, value); end
-
-  def compiled?(); end
-
-  def context(); end
-
-  def escape(value); end
-
-  def escapeHTML(str); end
-
-  def initialize(options=T.unsafe(nil)); end
-
-  def initialize_settings(); end
-
-  def partial(name); end
-
-  def path(); end
-
-  def raise_on_context_miss=(boolean); end
-
-  def raise_on_context_miss?(); end
-
-  def render(data=T.unsafe(nil), ctx=T.unsafe(nil)); end
-
-  def render_file(name, context=T.unsafe(nil)); end
-
-  def template(); end
-
-  def template=(template); end
-
-  def template_extension(); end
-
-  def template_extension=(template_extension); end
-
-  def template_file(); end
-
-  def template_file=(template_file); end
-
-  def template_name(); end
-
-  def template_name=(template_name); end
-
-  def template_path(); end
-
-  def template_path=(path); end
-end
-
-class Mustache::Context
-  def [](name); end
-
-  def []=(name, value); end
-
-  def current(); end
-
-  def escape(value); end
-
-  def fetch(name, default=T.unsafe(nil)); end
-
-  def find(obj, key, default=T.unsafe(nil)); end
-
-  def has_key?(key); end
-
-  def initialize(mustache); end
-
-  def mustache_in_stack(); end
-
-  def partial(name, indentation=T.unsafe(nil)); end
-
-  def pop(); end
-
-  def push(new_obj); end
-
-  def template_for_partial(partial); end
-end
-
-class Mustache::Context
-end
-
-class Mustache::ContextMiss
-end
-
-class Mustache::ContextMiss
-end
-
-module Mustache::Enumerable
-end
-
-module Mustache::Enumerable
-end
-
-class Mustache::Generator
-  def compile(exp); end
-
-  def initialize(options=T.unsafe(nil)); end
-end
-
-class Mustache::Generator
-end
-
-class Mustache::Parser
-  def compile(template); end
-
-  def ctag(); end
-
-  def ctag=(value); end
-
-  def initialize(options=T.unsafe(nil)); end
-
-  def otag(); end
-
-  def otag=(value); end
-  ALLOWED_CONTENT = ::T.let(nil, ::T.untyped)
-  ANY_CONTENT = ::T.let(nil, ::T.untyped)
-  SKIP_WHITESPACE = ::T.let(nil, ::T.untyped)
-  VALID_TYPES = ::T.let(nil, ::T.untyped)
-end
-
-class Mustache::Parser::SyntaxError
-  def initialize(message, position); end
-end
-
-class Mustache::Parser::SyntaxError
-end
-
-class Mustache::Parser
-  def self.add_type(*types, &block); end
-
-  def self.valid_types(); end
-end
-
-class Mustache::Template
-  def compile(src=T.unsafe(nil)); end
-
-  def initialize(source, options=T.unsafe(nil)); end
-
-  def partials(); end
-
-  def render(context); end
-
-  def sections(); end
-
-  def source(); end
-
-  def tags(); end
-
-  def to_s(src=T.unsafe(nil)); end
-
-  def tokens(src=T.unsafe(nil)); end
-end
-
-class Mustache::Template
-  def self.recursor(toks, section, &block); end
-end
-
-module Mustache::Utils
-end
-
-class Mustache::Utils::String
-  def classify(); end
-
-  def initialize(string); end
-
-  def underscore(view_namespace); end
-end
-
-class Mustache::Utils::String
-end
-
-module Mustache::Utils
-end
-
-class Mustache
-  def self.classify(underscored); end
-
-  def self.compiled?(); end
-
-  def self.const_from_file(name); end
-
-  def self.inheritable_config_for(attr_name, default); end
-
-  def self.inherited(subclass); end
-
-  def self.initialize_settings(); end
-
-  def self.partial(name); end
-
-  def self.path(); end
-
-  def self.path=(path); end
-
-  def self.raise_on_context_miss=(boolean); end
-
-  def self.raise_on_context_miss?(); end
-
-  def self.render(*args); end
-
-  def self.render_file(name, context=T.unsafe(nil)); end
-
-  def self.rescued_const_get(name); end
-
-  def self.template(); end
-
-  def self.template=(template); end
-
-  def self.template_extension(); end
-
-  def self.template_extension=(template_extension); end
-
-  def self.template_file(); end
-
-  def self.template_file=(template_file); end
-
-  def self.template_name(); end
-
-  def self.template_name=(template_name); end
-
-  def self.template_path(); end
-
-  def self.template_path=(path); end
-
-  def self.templateify(obj, options=T.unsafe(nil)); end
-
-  def self.underscore(classified=T.unsafe(nil)); end
-
-  def self.view_class(name); end
-
-  def self.view_namespace(); end
-
-  def self.view_namespace=(namespace); end
-
-  def self.view_path(); end
-
-  def self.view_path=(path); end
-end
-
 module Mutex_m
   VERSION = ::T.let(nil, ::T.untyped)
 end
@@ -14251,12 +5472,6 @@ module NKF
   UNKNOWN = ::T.let(nil, ::T.untyped)
 end
 
-class NameError
-  def missing_name(); end
-
-  def missing_name?(name); end
-end
-
 class Net::BufferedIO
   def write_timeout(); end
 
@@ -14279,7 +5494,6 @@ class Net::HTTP
   def write_timeout(); end
 
   def write_timeout=(sec); end
-  ENVIRONMENT_VARIABLE_IS_MULTIUSER_SAFE = ::T.let(nil, ::T.untyped)
 end
 
 class Net::HTTP::Persistent
@@ -14413,83 +5627,13 @@ class Net::WriteTimeout
 end
 
 class NilClass
-  include ::MessagePack::CoreExt
   def to_d(); end
-
-  def try(_method_name=T.unsafe(nil), *arg); end
-
-  def try!(_method_name=T.unsafe(nil), *arg); end
-end
-
-class NoSeedProgressFormatter
 end
 
 class Nokogiri::CSS::Parser
   Racc_debug_parser = ::T.let(nil, ::T.untyped)
 end
 
-class Numeric
-  def byte(); end
-
-  def bytes(); end
-
-  def day(); end
-
-  def days(); end
-
-  def exabyte(); end
-
-  def exabytes(); end
-
-  def fortnight(); end
-
-  def fortnights(); end
-
-  def gigabyte(); end
-
-  def gigabytes(); end
-
-  def hour(); end
-
-  def hours(); end
-
-  def in_milliseconds(); end
-
-  def kilobyte(); end
-
-  def kilobytes(); end
-
-  def megabyte(); end
-
-  def megabytes(); end
-
-  def minute(); end
-
-  def minutes(); end
-
-  def petabyte(); end
-
-  def petabytes(); end
-
-  def second(); end
-
-  def seconds(); end
-
-  def terabyte(); end
-
-  def terabytes(); end
-
-  def week(); end
-
-  def weeks(); end
-  EXABYTE = ::T.let(nil, ::T.untyped)
-  GIGABYTE = ::T.let(nil, ::T.untyped)
-  KILOBYTE = ::T.let(nil, ::T.untyped)
-  MEGABYTE = ::T.let(nil, ::T.untyped)
-  PETABYTE = ::T.let(nil, ::T.untyped)
-  TERABYTE = ::T.let(nil, ::T.untyped)
-end
-
 module OS::Linux::Glibc
   extend ::T::Private::Methods::MethodHooks
   extend ::T::Private::Methods::SingletonMethodHooks
@@ -14526,29 +5670,17 @@ module OS
 end
 
 class Object
-  include ::ActiveSupport::Dependencies::Loadable
-  include ::ActiveSupport::Tryable
   include ::Minitest::Expectations
   include ::Utils::Curl
   include ::SystemCommand::Mixin
-  include ::ActiveSupport::ForkTracker::CoreExtPrivate
-  include ::ActiveSupport::ForkTracker::CoreExt
-  def acts_like?(duck); end
+  def __send(*arg); end
 
-  def get_binding(); end
+  def __send!(*arg); end
 
-  def html_safe?(); end
-
-  def or_ask(*args, &details); end
-
-  def pry(object=T.unsafe(nil), hash=T.unsafe(nil)); end
+  def funcall(*arg); end
 
   def stub(name, val_or_callable, *block_args); end
 
-  def to_param(); end
-
-  def to_query(key); end
-
   def to_yaml(options=T.unsafe(nil)); end
   ARGF = ::T.let(nil, ::T.untyped)
   ARGV = ::T.let(nil, ::T.untyped)
@@ -14637,8 +5769,6 @@ class Object
 end
 
 class Object
-  def self.method_added(name); end
-
   def self.yaml_tag(url); end
 end
 
@@ -14765,6 +5895,58 @@ module OpenSSL
   def self.fips_mode(); end
 end
 
+class OpenURI::Buffer
+  def <<(str); end
+
+  def io(); end
+
+  def size(); end
+  StringMax = ::T.let(nil, ::T.untyped)
+end
+
+class OpenURI::Buffer
+end
+
+class OpenURI::HTTPError
+  def initialize(message, io); end
+end
+
+class OpenURI::HTTPRedirect
+  def initialize(message, io, uri); end
+end
+
+module OpenURI::Meta
+  def content_type_parse(); end
+
+  def meta_add_field(name, value); end
+
+  def meta_add_field2(name, values); end
+
+  def meta_setup_encoding(); end
+  RE_LWS = ::T.let(nil, ::T.untyped)
+  RE_PARAMETERS = ::T.let(nil, ::T.untyped)
+  RE_QUOTED_STRING = ::T.let(nil, ::T.untyped)
+  RE_TOKEN = ::T.let(nil, ::T.untyped)
+end
+
+module OpenURI::Meta
+  def self.init(obj, src=T.unsafe(nil)); end
+end
+
+module OpenURI
+  def self.check_options(options); end
+
+  def self.open_http(buf, target, proxy, options); end
+
+  def self.open_loop(uri, options); end
+
+  def self.open_uri(name, *rest); end
+
+  def self.redirectable?(uri1, uri2); end
+
+  def self.scan_open_optional_arguments(*rest); end
+end
+
 class Option
   extend ::T::Private::Methods::MethodHooks
   extend ::T::Private::Methods::SingletonMethodHooks
@@ -14785,76 +5967,9 @@ class PATH
 end
 
 module ParallelTests
-  RUBY_BINARY = ::T.let(nil, ::T.untyped)
-  VERSION = ::T.let(nil, ::T.untyped)
   WINDOWS = ::T.let(nil, ::T.untyped)
 end
 
-class ParallelTests::CLI
-  def run(argv); end
-end
-
-class ParallelTests::CLI
-end
-
-class ParallelTests::Grouper
-end
-
-class ParallelTests::Grouper
-  def self.by_scenarios(tests, num_groups, options=T.unsafe(nil)); end
-
-  def self.by_steps(tests, num_groups, options); end
-
-  def self.in_even_groups_by_size(items, num_groups, options=T.unsafe(nil)); end
-end
-
-class ParallelTests::Pids
-  def add(pid); end
-
-  def all(); end
-
-  def count(); end
-
-  def delete(pid); end
-
-  def file_path(); end
-
-  def initialize(file_path); end
-
-  def mutex(); end
-end
-
-class ParallelTests::Pids
-end
-
-module ParallelTests
-  def self.bundler_enabled?(); end
-
-  def self.delta(); end
-
-  def self.determine_number_of_processes(count); end
-
-  def self.first_process?(); end
-
-  def self.last_process?(); end
-
-  def self.now(); end
-
-  def self.number_of_running_processes(); end
-
-  def self.pid_file_path(); end
-
-  def self.pids(); end
-
-  def self.stop_all_processes(); end
-
-  def self.wait_for_other_processes_to_finish(); end
-
-  def self.with_pid_file(); end
-
-  def self.with_ruby_binary(command); end
-end
-
 class Parlour::ConflictResolver
   extend ::T::Sig
   extend ::T::Private::Methods::MethodHooks
@@ -15914,3181 +7029,9 @@ module Process
   def self.fork_without_simplecov(); end
 end
 
-class Pry
-  def add_sticky_local(name, &block); end
-
-  def backtrace(); end
-
-  def backtrace=(backtrace); end
-
-  def binding_stack(); end
-
-  def binding_stack=(binding_stack); end
-
-  def color(*args, &block); end
-
-  def color=(*args, &block); end
-
-  def commands(*args, &block); end
-
-  def commands=(*args, &block); end
-
-  def complete(str); end
-
-  def config(); end
-
-  def current_binding(); end
-
-  def current_context(); end
-
-  def custom_completions(); end
-
-  def custom_completions=(custom_completions); end
-
-  def editor(*args, &block); end
-
-  def editor=(*args, &block); end
-
-  def eval(line, options=T.unsafe(nil)); end
-
-  def eval_string(); end
-
-  def eval_string=(eval_string); end
-
-  def evaluate_ruby(code); end
-
-  def exception_handler(*args, &block); end
-
-  def exception_handler=(*args, &block); end
-
-  def exec_hook(name, *args, &block); end
-
-  def exit_value(); end
-
-  def extra_sticky_locals(*args, &block); end
-
-  def extra_sticky_locals=(*args, &block); end
-
-  def hooks(*args, &block); end
-
-  def hooks=(*args, &block); end
-
-  def initialize(options=T.unsafe(nil)); end
-
-  def inject_local(name, value, binding); end
-
-  def inject_sticky_locals!(); end
-
-  def input(*args, &block); end
-
-  def input=(*args, &block); end
-
-  def input_ring(); end
-
-  def last_dir(); end
-
-  def last_dir=(last_dir); end
-
-  def last_exception(); end
-
-  def last_exception=(exception); end
-
-  def last_file(); end
-
-  def last_file=(last_file); end
-
-  def last_result(); end
-
-  def last_result=(last_result); end
-
-  def last_result_is_exception?(); end
-
-  def memory_size(); end
-
-  def memory_size=(size); end
-
-  def output(); end
-
-  def output=(*args, &block); end
-
-  def output_ring(); end
-
-  def pager(); end
-
-  def pager=(*args, &block); end
-
-  def pop_prompt(); end
-
-  def print(*args, &block); end
-
-  def print=(*args, &block); end
-
-  def process_command(val); end
-
-  def process_command_safely(val); end
-
-  def prompt(); end
-
-  def prompt=(new_prompt); end
-
-  def push_binding(object); end
-
-  def push_initial_binding(target=T.unsafe(nil)); end
-
-  def push_prompt(new_prompt); end
-
-  def quiet?(); end
-
-  def raise_up(*args); end
-
-  def raise_up!(*args); end
-
-  def raise_up_common(force, *args); end
-
-  def repl(target=T.unsafe(nil)); end
-
-  def reset_eval_string(); end
-
-  def run_command(val); end
-
-  def select_prompt(); end
-
-  def set_last_result(result, code=T.unsafe(nil)); end
-
-  def should_print?(); end
-
-  def show_result(result); end
-
-  def sticky_locals(); end
-
-  def suppress_output(); end
-
-  def suppress_output=(suppress_output); end
-
-  def update_input_history(code); end
-  BINDING_METHOD_IMPL = ::T.let(nil, ::T.untyped)
-  Commands = ::T.let(nil, ::T.untyped)
-  EMPTY_COMPLETIONS = ::T.let(nil, ::T.untyped)
-  HAS_SAFE_LEVEL = ::T.let(nil, ::T.untyped)
-  LOCAL_RC_FILE = ::T.let(nil, ::T.untyped)
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
 class Pry::BasicObject
-  include ::Kernel
   include ::ActiveSupport::ForkTracker::CoreExtPrivate
   include ::ActiveSupport::ForkTracker::CoreExt
-  ENV = ::T.let(nil, ::T.untyped)
-end
-
-Pry::BasicObject::Dir = Dir
-
-Pry::BasicObject::File = File
-
-Pry::BasicObject::Kernel = Kernel
-
-Pry::BasicObject::LoadError = LoadError
-
-Pry::BasicObject::Pry = Pry
-
-class Pry::BasicObject
-end
-
-class Pry::BlockCommand
-  def call(*args); end
-
-  def help(); end
-end
-
-class Pry::BlockCommand
-end
-
-class Pry::CLI
-end
-
-class Pry::CLI::NoOptionsError
-end
-
-class Pry::CLI::NoOptionsError
-end
-
-class Pry::CLI
-  def self.add_option_processor(&block); end
-
-  def self.add_options(&block); end
-
-  def self.input_args(); end
-
-  def self.input_args=(input_args); end
-
-  def self.option_processors(); end
-
-  def self.option_processors=(option_processors); end
-
-  def self.options(); end
-
-  def self.options=(options); end
-
-  def self.parse_options(args=T.unsafe(nil)); end
-
-  def self.reset(); end
-
-  def self.start(opts); end
-end
-
-class Pry::ClassCommand
-  def args(); end
-
-  def args=(args); end
-
-  def call(*args); end
-
-  def complete(search); end
-
-  def help(); end
-
-  def options(opt); end
-
-  def opts(); end
-
-  def opts=(opts); end
-
-  def process(); end
-
-  def setup(); end
-
-  def slop(); end
-
-  def subcommands(cmd); end
-end
-
-class Pry::ClassCommand
-  def self.inherited(klass); end
-
-  def self.source_location(); end
-end
-
-class Pry::Code
-  def <<(line); end
-
-  def ==(other); end
-
-  def after(lineno, lines=T.unsafe(nil)); end
-
-  def alter(&block); end
-
-  def around(lineno, lines=T.unsafe(nil)); end
-
-  def before(lineno, lines=T.unsafe(nil)); end
-
-  def between(start_line, end_line=T.unsafe(nil)); end
-
-  def code_type(); end
-
-  def code_type=(code_type); end
-
-  def comment_describing(line_number); end
-
-  def expression_at(line_number, consume=T.unsafe(nil)); end
-
-  def grep(pattern); end
-
-  def highlighted(); end
-
-  def initialize(lines=T.unsafe(nil), start_line=T.unsafe(nil), code_type=T.unsafe(nil)); end
-
-  def length(); end
-
-  def max_lineno_width(); end
-
-  def method_missing(method_name, *args, &block); end
-
-  def nesting_at(line_number); end
-
-  def print_to_output(output, color=T.unsafe(nil)); end
-
-  def push(line); end
-
-  def raw(); end
-
-  def reject(&block); end
-
-  def select(&block); end
-
-  def take_lines(start_line, num_lines); end
-
-  def with_indentation(spaces=T.unsafe(nil)); end
-
-  def with_line_numbers(y_n=T.unsafe(nil)); end
-
-  def with_marker(lineno=T.unsafe(nil)); end
-end
-
-class Pry::Code::CodeRange
-  def indices_range(lines); end
-
-  def initialize(start_line, end_line=T.unsafe(nil)); end
-end
-
-class Pry::Code::CodeRange
-end
-
-class Pry::Code::LOC
-  def ==(other); end
-
-  def add_line_number(max_width=T.unsafe(nil), color=T.unsafe(nil)); end
-
-  def add_marker(marker_lineno); end
-
-  def colorize(code_type); end
-
-  def handle_multiline_entries_from_edit_command(line, max_width); end
-
-  def indent(distance); end
-
-  def initialize(line, lineno); end
-
-  def line(); end
-
-  def lineno(); end
-
-  def tuple(); end
-end
-
-class Pry::Code::LOC
-end
-
-class Pry::Code
-  extend ::MethodSource::CodeHelpers
-  def self.from_file(filename, code_type=T.unsafe(nil)); end
-
-  def self.from_method(meth, start_line=T.unsafe(nil)); end
-
-  def self.from_module(mod, candidate_rank=T.unsafe(nil), start_line=T.unsafe(nil)); end
-end
-
-class Pry::CodeFile
-  def code(); end
-
-  def code_type(); end
-
-  def initialize(filename, code_type=T.unsafe(nil)); end
-  DEFAULT_EXT = ::T.let(nil, ::T.untyped)
-  EXTENSIONS = ::T.let(nil, ::T.untyped)
-  FILES = ::T.let(nil, ::T.untyped)
-  INITIAL_PWD = ::T.let(nil, ::T.untyped)
-end
-
-class Pry::CodeFile
-end
-
-class Pry::CodeObject
-  include ::Pry::Helpers::CommandHelpers
-  include ::Pry::Helpers::OptionsHelpers
-  def command_lookup(); end
-
-  def default_lookup(); end
-
-  def empty_lookup(); end
-
-  def initialize(str, pry_instance, options=T.unsafe(nil)); end
-
-  def method_or_class_lookup(); end
-
-  def pry_instance(); end
-
-  def pry_instance=(pry_instance); end
-
-  def str(); end
-
-  def str=(str); end
-
-  def super_level(); end
-
-  def super_level=(super_level); end
-
-  def target(); end
-
-  def target=(target); end
-end
-
-module Pry::CodeObject::Helpers
-  def c_method?(); end
-
-  def c_module?(); end
-
-  def command?(); end
-
-  def module_with_yard_docs?(); end
-
-  def real_method_object?(); end
-end
-
-module Pry::CodeObject::Helpers
-end
-
-class Pry::CodeObject
-  def self.lookup(str, pry_instance, options=T.unsafe(nil)); end
-end
-
-class Pry::ColorPrinter
-  def pp(object); end
-
-  def text(str, max_width=T.unsafe(nil)); end
-end
-
-class Pry::ColorPrinter
-  def self.default(_output, value, pry_instance); end
-
-  def self.pp(obj, output=T.unsafe(nil), max_width=T.unsafe(nil)); end
-end
-
-class Pry::Command
-  include ::Pry::Helpers::BaseHelpers
-  include ::Pry::Helpers::CommandHelpers
-  include ::Pry::Helpers::OptionsHelpers
-  include ::Pry::Helpers::Text
-  def _pry_(); end
-
-  def _pry_=(_pry_); end
-
-  def arg_string(); end
-
-  def arg_string=(arg_string); end
-
-  def block(); end
-
-  def captures(); end
-
-  def captures=(captures); end
-
-  def check_for_command_collision(command_match, arg_string); end
-
-  def command_block(); end
-
-  def command_block=(command_block); end
-
-  def command_name(); end
-
-  def command_options(); end
-
-  def command_set(); end
-
-  def command_set=(command_set); end
-
-  def commands(); end
-
-  def complete(_search); end
-
-  def context(); end
-
-  def context=(context); end
-
-  def description(); end
-
-  def eval_string(); end
-
-  def eval_string=(eval_string); end
-
-  def hooks(); end
-
-  def hooks=(hooks); end
-
-  def initialize(context=T.unsafe(nil)); end
-
-  def interpolate_string(str); end
-
-  def match(); end
-
-  def name(); end
-
-  def output(); end
-
-  def output=(output); end
-
-  def process_line(line); end
-
-  def pry_instance(); end
-
-  def pry_instance=(pry_instance); end
-
-  def run(command_string, *args); end
-
-  def source(); end
-
-  def state(); end
-
-  def target(); end
-
-  def target=(target); end
-
-  def target_self(); end
-
-  def tokenize(val); end
-
-  def void(); end
-  VOID_VALUE = ::T.let(nil, ::T.untyped)
-end
-
-class Pry::Command::AmendLine
-end
-
-class Pry::Command::AmendLine
-end
-
-class Pry::Command::Bang
-end
-
-class Pry::Command::Bang
-end
-
-class Pry::Command::BangPry
-end
-
-class Pry::Command::BangPry
-end
-
-class Pry::Command::Cat
-  def load_path_completions(); end
-end
-
-class Pry::Command::Cat::AbstractFormatter
-  include ::Pry::Helpers::CommandHelpers
-  include ::Pry::Helpers::OptionsHelpers
-  include ::Pry::Helpers::BaseHelpers
-end
-
-class Pry::Command::Cat::AbstractFormatter
-end
-
-class Pry::Command::Cat::ExceptionFormatter
-  include ::Pry::Helpers::Text
-  def ex(); end
-
-  def format(); end
-
-  def initialize(exception, pry_instance, opts); end
-
-  def opts(); end
-
-  def pry_instance(); end
-end
-
-class Pry::Command::Cat::ExceptionFormatter
-end
-
-class Pry::Command::Cat::FileFormatter
-  def file_and_line(); end
-
-  def file_with_embedded_line(); end
-
-  def format(); end
-
-  def initialize(file_with_embedded_line, pry_instance, opts); end
-
-  def opts(); end
-
-  def pry_instance(); end
-end
-
-class Pry::Command::Cat::FileFormatter
-end
-
-class Pry::Command::Cat::InputExpressionFormatter
-  def format(); end
-
-  def initialize(input_expressions, opts); end
-
-  def input_expressions(); end
-
-  def input_expressions=(input_expressions); end
-
-  def opts(); end
-
-  def opts=(opts); end
-end
-
-class Pry::Command::Cat::InputExpressionFormatter
-end
-
-class Pry::Command::Cat
-end
-
-class Pry::Command::Cd
-end
-
-class Pry::Command::Cd
-end
-
-class Pry::Command::ChangeInspector
-  def process(inspector); end
-end
-
-class Pry::Command::ChangeInspector
-end
-
-class Pry::Command::ChangePrompt
-  def process(prompt); end
-end
-
-class Pry::Command::ChangePrompt
-end
-
-class Pry::Command::ClearScreen
-end
-
-class Pry::Command::ClearScreen
-end
-
-class Pry::Command::CodeCollector
-  include ::Pry::Helpers::CommandHelpers
-  include ::Pry::Helpers::OptionsHelpers
-  def args(); end
-
-  def code_object(); end
-
-  def content(); end
-
-  def file(); end
-
-  def file=(file); end
-
-  def initialize(args, opts, pry_instance); end
-
-  def line_range(); end
-
-  def obj_name(); end
-
-  def opts(); end
-
-  def pry_input_content(); end
-
-  def pry_instance(); end
-
-  def pry_output_content(); end
-
-  def restrict_to_lines(content, range); end
-end
-
-class Pry::Command::CodeCollector
-  def self.inject_options(opt); end
-
-  def self.input_expression_ranges(); end
-
-  def self.input_expression_ranges=(input_expression_ranges); end
-
-  def self.output_result_ranges(); end
-
-  def self.output_result_ranges=(output_result_ranges); end
-end
-
-class Pry::Command::DisablePry
-end
-
-class Pry::Command::DisablePry
-end
-
-class Pry::Command::Edit
-  def apply_runtime_patch(); end
-
-  def bad_option_combination?(); end
-
-  def code_object(); end
-
-  def ensure_file_name_is_valid(file_name); end
-
-  def file_and_line(); end
-
-  def file_and_line_for_current_exception(); end
-
-  def file_based_exception?(); end
-
-  def file_edit(); end
-
-  def filename_argument(); end
-
-  def initial_temp_file_content(); end
-
-  def input_expression(); end
-
-  def never_reload?(); end
-
-  def patch_exception?(); end
-
-  def previously_patched?(code_object); end
-
-  def probably_a_file?(str); end
-
-  def pry_method?(code_object); end
-
-  def reload?(file_name=T.unsafe(nil)); end
-
-  def reloadable?(); end
-
-  def repl_edit(); end
-
-  def repl_edit?(); end
-
-  def runtime_patch?(); end
-end
-
-class Pry::Command::Edit::ExceptionPatcher
-  def file_and_line(); end
-
-  def file_and_line=(file_and_line); end
-
-  def initialize(pry_instance, state, exception_file_and_line); end
-
-  def perform_patch(); end
-
-  def pry_instance(); end
-
-  def pry_instance=(pry_instance); end
-
-  def state(); end
-
-  def state=(state); end
-end
-
-class Pry::Command::Edit::ExceptionPatcher
-end
-
-module Pry::Command::Edit::FileAndLineLocator
-end
-
-module Pry::Command::Edit::FileAndLineLocator
-  def self.from_binding(target); end
-
-  def self.from_code_object(code_object, filename_argument); end
-
-  def self.from_exception(exception, backtrace_level); end
-
-  def self.from_filename_argument(filename_argument); end
-end
-
-class Pry::Command::Edit
-end
-
-class Pry::Command::Exit
-  def process_pop_and_return(); end
-end
-
-class Pry::Command::Exit
-end
-
-class Pry::Command::ExitAll
-end
-
-class Pry::Command::ExitAll
-end
-
-class Pry::Command::ExitProgram
-end
-
-class Pry::Command::ExitProgram
-end
-
-class Pry::Command::FindMethod
-end
-
-class Pry::Command::FindMethod
-  extend ::Pry::Helpers::BaseHelpers
-end
-
-class Pry::Command::FixIndent
-end
-
-class Pry::Command::FixIndent
-end
-
-class Pry::Command::Help
-  def command_groups(); end
-
-  def display_command(command); end
-
-  def display_filtered_commands(search); end
-
-  def display_filtered_search_results(search); end
-
-  def display_index(groups); end
-
-  def display_search(search); end
-
-  def group_sort_key(group_name); end
-
-  def help_text_for_commands(name, commands); end
-
-  def normalize(key); end
-
-  def search_hash(search, hash); end
-
-  def sorted_commands(commands); end
-
-  def sorted_group_names(groups); end
-
-  def visible_commands(); end
-end
-
-class Pry::Command::Help
-end
-
-class Pry::Command::Hist
-end
-
-class Pry::Command::Hist
-end
-
-class Pry::Command::ImportSet
-  def process(_command_set_name); end
-end
-
-class Pry::Command::ImportSet
-end
-
-class Pry::Command::JumpTo
-  def process(break_level); end
-end
-
-class Pry::Command::JumpTo
-end
-
-class Pry::Command::ListInspectors
-end
-
-class Pry::Command::ListInspectors
-end
-
-class Pry::Command::Ls
-  def no_user_opts?(); end
-  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
-end
-
-class Pry::Command::Ls::Constants
-  include ::Pry::Command::Ls::Interrogatable
-  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
-  DEPRECATED_CONSTANTS = ::T.let(nil, ::T.untyped)
-end
-
-class Pry::Command::Ls::Constants
-end
-
-class Pry::Command::Ls::Formatter
-  def grep=(grep); end
-
-  def initialize(pry_instance); end
-
-  def pry_instance(); end
-
-  def write_out(); end
-end
-
-class Pry::Command::Ls::Formatter
-end
-
-class Pry::Command::Ls::Globals
-  def initialize(opts, pry_instance); end
-  BUILTIN_GLOBALS = ::T.let(nil, ::T.untyped)
-  PSEUDO_GLOBALS = ::T.let(nil, ::T.untyped)
-end
-
-class Pry::Command::Ls::Globals
-end
-
-class Pry::Command::Ls::Grep
-  def initialize(grep_regexp); end
-
-  def regexp(); end
-end
-
-class Pry::Command::Ls::Grep
-end
-
-class Pry::Command::Ls::InstanceVars
-  include ::Pry::Command::Ls::Interrogatable
-  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
-end
-
-class Pry::Command::Ls::InstanceVars
-end
-
-module Pry::Command::Ls::Interrogatable
-end
-
-module Pry::Command::Ls::Interrogatable
-end
-
-module Pry::Command::Ls::JRubyHacks
-end
-
-module Pry::Command::Ls::JRubyHacks
-end
-
-class Pry::Command::Ls::LocalNames
-  def initialize(no_user_opts, args, pry_instance); end
-end
-
-class Pry::Command::Ls::LocalNames
-end
-
-class Pry::Command::Ls::LocalVars
-  def initialize(opts, pry_instance); end
-end
-
-class Pry::Command::Ls::LocalVars
-end
-
-class Pry::Command::Ls::LsEntity
-  def entities_table(); end
-
-  def initialize(opts); end
-
-  def pry_instance(); end
-end
-
-class Pry::Command::Ls::LsEntity
-end
-
-class Pry::Command::Ls::Methods
-  include ::Pry::Command::Ls::Interrogatable
-  include ::Pry::Command::Ls::MethodsHelper
-  include ::Pry::Command::Ls::JRubyHacks
-  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
-end
-
-class Pry::Command::Ls::Methods
-end
-
-module Pry::Command::Ls::MethodsHelper
-  include ::Pry::Command::Ls::JRubyHacks
-end
-
-module Pry::Command::Ls::MethodsHelper
-end
-
-class Pry::Command::Ls::SelfMethods
-  include ::Pry::Command::Ls::Interrogatable
-  include ::Pry::Command::Ls::MethodsHelper
-  include ::Pry::Command::Ls::JRubyHacks
-  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
-end
-
-class Pry::Command::Ls::SelfMethods
-end
-
-class Pry::Command::Ls
-end
-
-class Pry::Command::Nesting
-end
-
-class Pry::Command::Nesting
-end
-
-class Pry::Command::Play
-  def code_object(); end
-
-  def content(); end
-
-  def content_after_options(); end
-
-  def content_at_expression(); end
-
-  def default_file(); end
-
-  def file_content(); end
-
-  def perform_play(); end
-
-  def should_use_default_file?(); end
-
-  def show_input(); end
-end
-
-class Pry::Command::Play
-end
-
-class Pry::Command::PryBacktrace
-end
-
-class Pry::Command::PryBacktrace
-end
-
-class Pry::Command::RaiseUp
-end
-
-class Pry::Command::RaiseUp
-end
-
-class Pry::Command::ReloadCode
-end
-
-class Pry::Command::ReloadCode
-end
-
-class Pry::Command::Reset
-end
-
-class Pry::Command::Reset
-end
-
-class Pry::Command::Ri
-  def process(spec); end
-end
-
-class Pry::Command::Ri
-end
-
-class Pry::Command::SaveFile
-  def display_content(); end
-
-  def file_name(); end
-
-  def mode(); end
-
-  def save_file(); end
-end
-
-class Pry::Command::SaveFile
-end
-
-class Pry::Command::ShellCommand
-  def process(cmd); end
-end
-
-class Pry::Command::ShellCommand
-end
-
-class Pry::Command::ShellMode
-end
-
-class Pry::Command::ShellMode
-end
-
-class Pry::Command::ShowDoc
-  include ::Pry::Helpers::DocumentationHelpers
-  def content_for(code_object); end
-
-  def docs_for(code_object); end
-
-  def render_doc_markup_for(code_object); end
-end
-
-class Pry::Command::ShowDoc
-end
-
-class Pry::Command::ShowInfo
-  def code_object_header(code_object, line_num); end
-
-  def code_object_with_accessible_source(code_object); end
-
-  def complete(input); end
-
-  def content_and_header_for_code_object(code_object); end
-
-  def content_and_headers_for_all_module_candidates(mod); end
-
-  def file_and_line_for(code_object); end
-
-  def header(code_object); end
-
-  def header_options(); end
-
-  def initialize(*arg); end
-
-  def method_header(code_object, line_num); end
-
-  def method_sections(code_object); end
-
-  def module_header(code_object, line_num); end
-
-  def no_definition_message(); end
-
-  def obj_name(); end
-
-  def show_all_modules?(code_object); end
-
-  def start_line_for(code_object); end
-
-  def use_line_numbers?(); end
-
-  def valid_superclass?(code_object); end
-end
-
-class Pry::Command::ShowInfo
-  extend ::Pry::Helpers::BaseHelpers
-end
-
-class Pry::Command::ShowInput
-end
-
-class Pry::Command::ShowInput
-end
-
-class Pry::Command::ShowSource
-  include ::Pry::Helpers::DocumentationHelpers
-  def content_for(code_object); end
-
-  def docs_for(code_object); end
-
-  def render_doc_markup_for(code_object); end
-end
-
-class Pry::Command::ShowSource
-end
-
-class Pry::Command::Stat
-end
-
-class Pry::Command::Stat
-end
-
-class Pry::Command::SwitchTo
-  def process(selection); end
-end
-
-class Pry::Command::SwitchTo
-end
-
-class Pry::Command::ToggleColor
-  def color_toggle(); end
-end
-
-class Pry::Command::ToggleColor
-end
-
-class Pry::Command::Version
-end
-
-class Pry::Command::Version
-end
-
-class Pry::Command::WatchExpression
-end
-
-class Pry::Command::WatchExpression::Expression
-  def changed?(); end
-
-  def eval!(); end
-
-  def initialize(pry_instance, target, source); end
-
-  def previous_value(); end
-
-  def pry_instance(); end
-
-  def source(); end
-
-  def target(); end
-
-  def value(); end
-end
-
-class Pry::Command::WatchExpression::Expression
-end
-
-class Pry::Command::WatchExpression
-end
-
-class Pry::Command::Whereami
-  def bad_option_combination?(); end
-
-  def code(); end
-
-  def code?(); end
-
-  def initialize(*arg); end
-
-  def location(); end
-end
-
-class Pry::Command::Whereami
-  def self.method_size_cutoff(); end
-
-  def self.method_size_cutoff=(method_size_cutoff); end
-end
-
-class Pry::Command::Wtf
-  RUBY_FRAME_PATTERN = ::T.let(nil, ::T.untyped)
-end
-
-class Pry::Command::Wtf
-end
-
-class Pry::Command
-  extend ::Pry::Helpers::DocumentationHelpers
-  extend ::Pry::CodeObject::Helpers
-  def self.banner(arg=T.unsafe(nil)); end
-
-  def self.block(); end
-
-  def self.block=(block); end
-
-  def self.command_name(); end
-
-  def self.command_options(arg=T.unsafe(nil)); end
-
-  def self.command_options=(command_options); end
-
-  def self.command_regex(); end
-
-  def self.convert_to_regex(obj); end
-
-  def self.default_options(match); end
-
-  def self.description(arg=T.unsafe(nil)); end
-
-  def self.description=(description); end
-
-  def self.doc(); end
-
-  def self.file(); end
-
-  def self.group(name=T.unsafe(nil)); end
-
-  def self.line(); end
-
-  def self.match(arg=T.unsafe(nil)); end
-
-  def self.match=(match); end
-
-  def self.match_score(val); end
-
-  def self.matches?(val); end
-
-  def self.options(arg=T.unsafe(nil)); end
-
-  def self.options=(options); end
-
-  def self.source(); end
-
-  def self.source_file(); end
-
-  def self.source_line(); end
-
-  def self.state(); end
-
-  def self.subclass(match, description, options, helpers, &block); end
-end
-
-class Pry::CommandError
-end
-
-class Pry::CommandError
-end
-
-class Pry::CommandSet
-  include ::Enumerable
-  include ::Pry::Helpers::BaseHelpers
-  def [](pattern); end
-
-  def []=(pattern, command); end
-
-  def add_command(command); end
-
-  def alias_command(match, action, options=T.unsafe(nil)); end
-
-  def block_command(match, description=T.unsafe(nil), options=T.unsafe(nil), &block); end
-
-  def command(match, description=T.unsafe(nil), options=T.unsafe(nil), &block); end
-
-  def complete(search, context=T.unsafe(nil)); end
-
-  def create_command(match, description=T.unsafe(nil), options=T.unsafe(nil), &block); end
-
-  def delete(*searches); end
-
-  def desc(search, description=T.unsafe(nil)); end
-
-  def each(&block); end
-
-  def find_command(pattern); end
-
-  def find_command_by_match_or_listing(match_or_listing); end
-
-  def find_command_for_help(search); end
-
-  def helper_module(); end
-
-  def import(*sets); end
-
-  def import_from(set, *matches); end
-
-  def initialize(*imported_sets, &block); end
-
-  def keys(); end
-
-  def list_commands(); end
-
-  def process_line(val, context=T.unsafe(nil)); end
-
-  def rename_command(new_match, search, options=T.unsafe(nil)); end
-
-  def to_h(); end
-
-  def to_hash(); end
-
-  def valid_command?(val); end
-end
-
-class Pry::CommandSet
-end
-
-class Pry::CommandState
-  def reset(command_name); end
-
-  def state_for(command_name); end
-end
-
-class Pry::CommandState
-  def self.default(); end
-end
-
-class Pry::Config
-  def [](attr); end
-
-  def []=(attr, value); end
-
-  def auto_indent(); end
-
-  def auto_indent=(auto_indent); end
-
-  def collision_warning(); end
-
-  def collision_warning=(collision_warning); end
-
-  def color(); end
-
-  def color=(color); end
-
-  def command_completions(); end
-
-  def command_completions=(command_completions); end
-
-  def command_prefix(); end
-
-  def command_prefix=(command_prefix); end
-
-  def commands(); end
-
-  def commands=(commands); end
-
-  def completer(); end
-
-  def completer=(completer); end
-
-  def control_d_handler(); end
-
-  def control_d_handler=(value); end
-
-  def correct_indent(); end
-
-  def correct_indent=(correct_indent); end
-
-  def default_window_size(); end
-
-  def default_window_size=(default_window_size); end
-
-  def disable_auto_reload(); end
-
-  def disable_auto_reload=(disable_auto_reload); end
-
-  def editor(); end
-
-  def editor=(editor); end
-
-  def exception_handler(); end
-
-  def exception_handler=(exception_handler); end
-
-  def exception_whitelist(); end
-
-  def exception_whitelist=(exception_whitelist); end
-
-  def exec_string(); end
-
-  def exec_string=(exec_string); end
-
-  def extra_sticky_locals(); end
-
-  def extra_sticky_locals=(extra_sticky_locals); end
-
-  def file_completions(); end
-
-  def file_completions=(file_completions); end
-
-  def history(); end
-
-  def history=(history); end
-
-  def history_file(); end
-
-  def history_file=(history_file); end
-
-  def history_ignorelist(); end
-
-  def history_ignorelist=(history_ignorelist); end
-
-  def history_load(); end
-
-  def history_load=(history_load); end
-
-  def history_save(); end
-
-  def history_save=(history_save); end
-
-  def hooks(); end
-
-  def hooks=(hooks); end
-
-  def input(); end
-
-  def input=(input); end
-
-  def ls(); end
-
-  def ls=(ls); end
-
-  def memory_size(); end
-
-  def memory_size=(memory_size); end
-
-  def merge(config_hash); end
-
-  def merge!(config_hash); end
-
-  def method_missing(method_name, *args, &_block); end
-
-  def output(); end
-
-  def output=(output); end
-
-  def output_prefix(); end
-
-  def output_prefix=(output_prefix); end
-
-  def pager(); end
-
-  def pager=(pager); end
-
-  def print(); end
-
-  def print=(print); end
-
-  def prompt(); end
-
-  def prompt=(prompt); end
-
-  def prompt_name(); end
-
-  def prompt_name=(prompt_name); end
-
-  def prompt_safe_contexts(); end
-
-  def prompt_safe_contexts=(prompt_safe_contexts); end
-
-  def quiet(); end
-
-  def quiet=(quiet); end
-
-  def rc_file(); end
-
-  def rc_file=(rc_file); end
-
-  def requires(); end
-
-  def requires=(requires); end
-
-  def should_load_local_rc(); end
-
-  def should_load_local_rc=(should_load_local_rc); end
-
-  def should_load_rc(); end
-
-  def should_load_rc=(should_load_rc); end
-
-  def should_load_requires(); end
-
-  def should_load_requires=(should_load_requires); end
-
-  def should_trap_interrupts(); end
-
-  def should_trap_interrupts=(should_trap_interrupts); end
-
-  def system(); end
-
-  def system=(system); end
-
-  def unrescued_exceptions(); end
-
-  def unrescued_exceptions=(unrescued_exceptions); end
-
-  def windows_console_warning(); end
-
-  def windows_console_warning=(windows_console_warning); end
-end
-
-module Pry::Config::Attributable
-  def attribute(attr_name); end
-end
-
-module Pry::Config::Attributable
-end
-
-class Pry::Config::LazyValue
-  def call(); end
-
-  def initialize(&block); end
-end
-
-class Pry::Config::LazyValue
-end
-
-class Pry::Config::MemoizedValue
-  def call(); end
-
-  def initialize(&block); end
-end
-
-class Pry::Config::MemoizedValue
-end
-
-class Pry::Config::Value
-  def call(); end
-
-  def initialize(value); end
-end
-
-class Pry::Config::Value
-end
-
-class Pry::Config
-  extend ::Pry::Config::Attributable
-end
-
-module Pry::ControlDHandler
-end
-
-module Pry::ControlDHandler
-  def self.default(pry_instance); end
-end
-
-class Pry::Editor
-  include ::Pry::Helpers::CommandHelpers
-  include ::Pry::Helpers::OptionsHelpers
-  def build_editor_invocation_string(file, line, blocking); end
-
-  def edit_tempfile_with_content(initial_content, line=T.unsafe(nil)); end
-
-  def initialize(pry_instance); end
-
-  def invoke_editor(file, line, blocking=T.unsafe(nil)); end
-
-  def pry_instance(); end
-end
-
-class Pry::Editor
-  def self.default(); end
-end
-
-module Pry::Env
-end
-
-module Pry::Env
-  def self.[](key); end
-end
-
-module Pry::ExceptionHandler
-end
-
-module Pry::ExceptionHandler
-  def self.handle_exception(output, exception, _pry_instance); end
-end
-
-module Pry::Forwardable
-  include ::Forwardable
-  def def_private_delegators(target, *private_delegates); end
-end
-
-module Pry::Forwardable
-end
-
-module Pry::FrozenObjectException
-end
-
-module Pry::FrozenObjectException
-  def self.===(exception); end
-end
-
-module Pry::Helpers
-end
-
-module Pry::Helpers::BaseHelpers
-  def colorize_code(code); end
-
-  def find_command(name, set=T.unsafe(nil)); end
-
-  def heading(text); end
-
-  def highlight(string, regexp, highlight_color=T.unsafe(nil)); end
-
-  def not_a_real_file?(file); end
-
-  def safe_send(obj, method, *args, &block); end
-
-  def silence_warnings(); end
-
-  def stagger_output(text, _out=T.unsafe(nil)); end
-
-  def use_ansi_codes?(); end
-end
-
-module Pry::Helpers::BaseHelpers
-  extend ::Pry::Helpers::BaseHelpers
-end
-
-module Pry::Helpers::CommandHelpers
-  include ::Pry::Helpers::OptionsHelpers
-  def absolute_index_number(line_number, array_length); end
-
-  def absolute_index_range(range_or_number, array_length); end
-
-  def get_method_or_raise(method_name, context, opts=T.unsafe(nil)); end
-
-  def internal_binding?(context); end
-
-  def one_index_number(line_number); end
-
-  def one_index_range(range); end
-
-  def one_index_range_or_number(range_or_number); end
-
-  def restrict_to_lines(content, lines); end
-
-  def set_file_and_dir_locals(file_name, pry=T.unsafe(nil), ctx=T.unsafe(nil)); end
-
-  def temp_file(ext=T.unsafe(nil)); end
-
-  def unindent(dirty_text, left_padding=T.unsafe(nil)); end
-end
-
-module Pry::Helpers::CommandHelpers
-  extend ::Pry::Helpers::CommandHelpers
-  extend ::Pry::Helpers::OptionsHelpers
-end
-
-module Pry::Helpers::DocumentationHelpers
-  YARD_TAGS = ::T.let(nil, ::T.untyped)
-end
-
-module Pry::Helpers::DocumentationHelpers
-  def self.get_comment_content(comment); end
-
-  def self.process_comment_markup(comment); end
-
-  def self.process_rdoc(comment); end
-
-  def self.process_yardoc(comment); end
-
-  def self.process_yardoc_tag(comment, tag); end
-
-  def self.strip_comments_from_c_code(code); end
-
-  def self.strip_leading_whitespace(text); end
-end
-
-module Pry::Helpers::OptionsHelpers
-end
-
-module Pry::Helpers::OptionsHelpers
-  def self.method_object(); end
-
-  def self.method_options(opt); end
-end
-
-module Pry::Helpers::Platform
-end
-
-module Pry::Helpers::Platform
-  def self.jruby?(); end
-
-  def self.jruby_19?(); end
-
-  def self.linux?(); end
-
-  def self.mac_osx?(); end
-
-  def self.mri?(); end
-
-  def self.mri_19?(); end
-
-  def self.mri_2?(); end
-
-  def self.windows?(); end
-
-  def self.windows_ansi?(); end
-end
-
-class Pry::Helpers::Table
-  def ==(other); end
-
-  def column_count(); end
-
-  def column_count=(count); end
-
-  def columns(); end
-
-  def fits_on_line?(line_length); end
-
-  def initialize(items, args, pry_instance=T.unsafe(nil)); end
-
-  def items(); end
-
-  def items=(items); end
-
-  def rows_to_s(style=T.unsafe(nil)); end
-
-  def to_a(); end
-end
-
-class Pry::Helpers::Table
-end
-
-module Pry::Helpers::Text
-  def black(text); end
-
-  def black_on_black(text); end
-
-  def black_on_blue(text); end
-
-  def black_on_cyan(text); end
-
-  def black_on_green(text); end
-
-  def black_on_magenta(text); end
-
-  def black_on_purple(text); end
-
-  def black_on_red(text); end
-
-  def black_on_white(text); end
-
-  def black_on_yellow(text); end
-
-  def blue(text); end
-
-  def blue_on_black(text); end
-
-  def blue_on_blue(text); end
-
-  def blue_on_cyan(text); end
-
-  def blue_on_green(text); end
-
-  def blue_on_magenta(text); end
-
-  def blue_on_purple(text); end
-
-  def blue_on_red(text); end
-
-  def blue_on_white(text); end
-
-  def blue_on_yellow(text); end
-
-  def bold(text); end
-
-  def bright_black(text); end
-
-  def bright_black_on_black(text); end
-
-  def bright_black_on_blue(text); end
-
-  def bright_black_on_cyan(text); end
-
-  def bright_black_on_green(text); end
-
-  def bright_black_on_magenta(text); end
-
-  def bright_black_on_purple(text); end
-
-  def bright_black_on_red(text); end
-
-  def bright_black_on_white(text); end
-
-  def bright_black_on_yellow(text); end
-
-  def bright_blue(text); end
-
-  def bright_blue_on_black(text); end
-
-  def bright_blue_on_blue(text); end
-
-  def bright_blue_on_cyan(text); end
-
-  def bright_blue_on_green(text); end
-
-  def bright_blue_on_magenta(text); end
-
-  def bright_blue_on_purple(text); end
-
-  def bright_blue_on_red(text); end
-
-  def bright_blue_on_white(text); end
-
-  def bright_blue_on_yellow(text); end
-
-  def bright_cyan(text); end
-
-  def bright_cyan_on_black(text); end
-
-  def bright_cyan_on_blue(text); end
-
-  def bright_cyan_on_cyan(text); end
-
-  def bright_cyan_on_green(text); end
-
-  def bright_cyan_on_magenta(text); end
-
-  def bright_cyan_on_purple(text); end
-
-  def bright_cyan_on_red(text); end
-
-  def bright_cyan_on_white(text); end
-
-  def bright_cyan_on_yellow(text); end
-
-  def bright_green(text); end
-
-  def bright_green_on_black(text); end
-
-  def bright_green_on_blue(text); end
-
-  def bright_green_on_cyan(text); end
-
-  def bright_green_on_green(text); end
-
-  def bright_green_on_magenta(text); end
-
-  def bright_green_on_purple(text); end
-
-  def bright_green_on_red(text); end
-
-  def bright_green_on_white(text); end
-
-  def bright_green_on_yellow(text); end
-
-  def bright_magenta(text); end
-
-  def bright_magenta_on_black(text); end
-
-  def bright_magenta_on_blue(text); end
-
-  def bright_magenta_on_cyan(text); end
-
-  def bright_magenta_on_green(text); end
-
-  def bright_magenta_on_magenta(text); end
-
-  def bright_magenta_on_purple(text); end
-
-  def bright_magenta_on_red(text); end
-
-  def bright_magenta_on_white(text); end
-
-  def bright_magenta_on_yellow(text); end
-
-  def bright_purple(text); end
-
-  def bright_purple_on_black(text); end
-
-  def bright_purple_on_blue(text); end
-
-  def bright_purple_on_cyan(text); end
-
-  def bright_purple_on_green(text); end
-
-  def bright_purple_on_magenta(text); end
-
-  def bright_purple_on_purple(text); end
-
-  def bright_purple_on_red(text); end
-
-  def bright_purple_on_white(text); end
-
-  def bright_purple_on_yellow(text); end
-
-  def bright_red(text); end
-
-  def bright_red_on_black(text); end
-
-  def bright_red_on_blue(text); end
-
-  def bright_red_on_cyan(text); end
-
-  def bright_red_on_green(text); end
-
-  def bright_red_on_magenta(text); end
-
-  def bright_red_on_purple(text); end
-
-  def bright_red_on_red(text); end
-
-  def bright_red_on_white(text); end
-
-  def bright_red_on_yellow(text); end
-
-  def bright_white(text); end
-
-  def bright_white_on_black(text); end
-
-  def bright_white_on_blue(text); end
-
-  def bright_white_on_cyan(text); end
-
-  def bright_white_on_green(text); end
-
-  def bright_white_on_magenta(text); end
-
-  def bright_white_on_purple(text); end
-
-  def bright_white_on_red(text); end
-
-  def bright_white_on_white(text); end
-
-  def bright_white_on_yellow(text); end
-
-  def bright_yellow(text); end
-
-  def bright_yellow_on_black(text); end
-
-  def bright_yellow_on_blue(text); end
-
-  def bright_yellow_on_cyan(text); end
-
-  def bright_yellow_on_green(text); end
-
-  def bright_yellow_on_magenta(text); end
-
-  def bright_yellow_on_purple(text); end
-
-  def bright_yellow_on_red(text); end
-
-  def bright_yellow_on_white(text); end
-
-  def bright_yellow_on_yellow(text); end
-
-  def cyan(text); end
-
-  def cyan_on_black(text); end
-
-  def cyan_on_blue(text); end
-
-  def cyan_on_cyan(text); end
-
-  def cyan_on_green(text); end
-
-  def cyan_on_magenta(text); end
-
-  def cyan_on_purple(text); end
-
-  def cyan_on_red(text); end
-
-  def cyan_on_white(text); end
-
-  def cyan_on_yellow(text); end
-
-  def default(text); end
-
-  def green(text); end
-
-  def green_on_black(text); end
-
-  def green_on_blue(text); end
-
-  def green_on_cyan(text); end
-
-  def green_on_green(text); end
-
-  def green_on_magenta(text); end
-
-  def green_on_purple(text); end
-
-  def green_on_red(text); end
-
-  def green_on_white(text); end
-
-  def green_on_yellow(text); end
-
-  def indent(text, chars); end
-
-  def magenta(text); end
-
-  def magenta_on_black(text); end
-
-  def magenta_on_blue(text); end
-
-  def magenta_on_cyan(text); end
-
-  def magenta_on_green(text); end
-
-  def magenta_on_magenta(text); end
-
-  def magenta_on_purple(text); end
-
-  def magenta_on_red(text); end
-
-  def magenta_on_white(text); end
-
-  def magenta_on_yellow(text); end
-
-  def no_color(); end
-
-  def no_pager(); end
-
-  def purple(text); end
-
-  def purple_on_black(text); end
-
-  def purple_on_blue(text); end
-
-  def purple_on_cyan(text); end
-
-  def purple_on_green(text); end
-
-  def purple_on_magenta(text); end
-
-  def purple_on_purple(text); end
-
-  def purple_on_red(text); end
-
-  def purple_on_white(text); end
-
-  def purple_on_yellow(text); end
-
-  def red(text); end
-
-  def red_on_black(text); end
-
-  def red_on_blue(text); end
-
-  def red_on_cyan(text); end
-
-  def red_on_green(text); end
-
-  def red_on_magenta(text); end
-
-  def red_on_purple(text); end
-
-  def red_on_red(text); end
-
-  def red_on_white(text); end
-
-  def red_on_yellow(text); end
-
-  def strip_color(text); end
-
-  def white(text); end
-
-  def white_on_black(text); end
-
-  def white_on_blue(text); end
-
-  def white_on_cyan(text); end
-
-  def white_on_green(text); end
-
-  def white_on_magenta(text); end
-
-  def white_on_purple(text); end
-
-  def white_on_red(text); end
-
-  def white_on_white(text); end
-
-  def white_on_yellow(text); end
-
-  def with_line_numbers(text, offset, color=T.unsafe(nil)); end
-
-  def yellow(text); end
-
-  def yellow_on_black(text); end
-
-  def yellow_on_blue(text); end
-
-  def yellow_on_cyan(text); end
-
-  def yellow_on_green(text); end
-
-  def yellow_on_magenta(text); end
-
-  def yellow_on_purple(text); end
-
-  def yellow_on_red(text); end
-
-  def yellow_on_white(text); end
-
-  def yellow_on_yellow(text); end
-  COLORS = ::T.let(nil, ::T.untyped)
-end
-
-module Pry::Helpers::Text
-  extend ::Pry::Helpers::Text
-end
-
-module Pry::Helpers
-  def self.tablify(things, line_length, pry_instance=T.unsafe(nil)); end
-
-  def self.tablify_or_one_line(heading, things, pry_instance=T.unsafe(nil)); end
-
-  def self.tablify_to_screen_width(things, options, pry_instance=T.unsafe(nil)); end
-end
-
-class Pry::History
-  def <<(line); end
-
-  def clear(); end
-
-  def filter(history); end
-
-  def history_line_count(); end
-
-  def initialize(options=T.unsafe(nil)); end
-
-  def load(); end
-
-  def loader(); end
-
-  def loader=(loader); end
-
-  def original_lines(); end
-
-  def push(line); end
-
-  def saver(); end
-
-  def saver=(saver); end
-
-  def session_line_count(); end
-
-  def to_a(); end
-end
-
-class Pry::History
-  def self.default_file(); end
-end
-
-class Pry::Hooks
-  def add_hook(event_name, hook_name, callable=T.unsafe(nil), &block); end
-
-  def clear_event_hooks(event_name); end
-
-  def delete_hook(event_name, hook_name); end
-
-  def errors(); end
-
-  def exec_hook(event_name, *args, &block); end
-
-  def get_hook(event_name, hook_name); end
-
-  def get_hooks(event_name); end
-
-  def hook_count(event_name); end
-
-  def hook_exists?(event_name, hook_name); end
-
-  def hooks(); end
-
-  def merge(other); end
-
-  def merge!(other); end
-end
-
-class Pry::Hooks
-  def self.default(); end
-end
-
-class Pry::Indent
-  include ::Pry::Helpers::BaseHelpers
-  def correct_indentation(prompt, code, overhang=T.unsafe(nil)); end
-
-  def current_prefix(); end
-
-  def end_of_statement?(last_token, last_kind); end
-
-  def in_string?(); end
-
-  def indent(input); end
-
-  def indent_level(); end
-
-  def indentation_delta(tokens); end
-
-  def initialize(pry_instance=T.unsafe(nil)); end
-
-  def module_nesting(); end
-
-  def open_delimiters(); end
-
-  def open_delimiters_line(); end
-
-  def reset(); end
-
-  def stack(); end
-
-  def tokenize(string); end
-
-  def track_delimiter(token); end
-
-  def track_module_nesting(token, kind); end
-
-  def track_module_nesting_end(token, kind=T.unsafe(nil)); end
-  IGNORE_TOKENS = ::T.let(nil, ::T.untyped)
-  MIDWAY_TOKENS = ::T.let(nil, ::T.untyped)
-  OPEN_TOKENS = ::T.let(nil, ::T.untyped)
-  OPTIONAL_DO_TOKENS = ::T.let(nil, ::T.untyped)
-  SINGLELINE_TOKENS = ::T.let(nil, ::T.untyped)
-  SPACES = ::T.let(nil, ::T.untyped)
-  STATEMENT_END_TOKENS = ::T.let(nil, ::T.untyped)
-end
-
-class Pry::Indent::UnparseableNestingError
-end
-
-class Pry::Indent::UnparseableNestingError
-end
-
-class Pry::Indent
-  def self.indent(str); end
-
-  def self.nesting_at(str, line_number); end
-end
-
-class Pry::InputCompleter
-  def build_path(input); end
-
-  def call(str, options=T.unsafe(nil)); end
-
-  def ignored_modules(); end
-
-  def initialize(input, pry=T.unsafe(nil)); end
-
-  def select_message(path, receiver, message, candidates); end
-  ARRAY_REGEXP = ::T.let(nil, ::T.untyped)
-  CONSTANT_OR_METHOD_REGEXP = ::T.let(nil, ::T.untyped)
-  CONSTANT_REGEXP = ::T.let(nil, ::T.untyped)
-  GLOBALVARIABLE_REGEXP = ::T.let(nil, ::T.untyped)
-  HEX_REGEXP = ::T.let(nil, ::T.untyped)
-  NUMERIC_REGEXP = ::T.let(nil, ::T.untyped)
-  PROC_OR_HASH_REGEXP = ::T.let(nil, ::T.untyped)
-  REGEX_REGEXP = ::T.let(nil, ::T.untyped)
-  RESERVED_WORDS = ::T.let(nil, ::T.untyped)
-  SYMBOL_METHOD_CALL_REGEXP = ::T.let(nil, ::T.untyped)
-  SYMBOL_REGEXP = ::T.let(nil, ::T.untyped)
-  TOPLEVEL_LOOKUP_REGEXP = ::T.let(nil, ::T.untyped)
-  VARIABLE_REGEXP = ::T.let(nil, ::T.untyped)
-  WORD_ESCAPE_STR = ::T.let(nil, ::T.untyped)
-end
-
-class Pry::InputCompleter
-end
-
-class Pry::InputLock
-  def __with_ownership(); end
-
-  def enter_interruptible_region(); end
-
-  def interruptible_region(); end
-
-  def leave_interruptible_region(); end
-
-  def with_ownership(&block); end
-end
-
-class Pry::InputLock::Interrupt
-end
-
-class Pry::InputLock::Interrupt
-end
-
-class Pry::InputLock
-  def self.for(input); end
-
-  def self.global_lock(); end
-
-  def self.global_lock=(global_lock); end
-
-  def self.input_locks(); end
-
-  def self.input_locks=(input_locks); end
-end
-
-class Pry::Inspector
-  MAP = ::T.let(nil, ::T.untyped)
-end
-
-class Pry::Inspector
-end
-
-class Pry::LastException
-  def bt_index(); end
-
-  def bt_index=(bt_index); end
-
-  def bt_source_location_for(index); end
-
-  def file(); end
-
-  def inc_bt_index(); end
-
-  def initialize(exception); end
-
-  def line(); end
-
-  def method_missing(name, *args, &block); end
-
-  def wrapped_exception(); end
-end
-
-class Pry::LastException
-end
-
-class Pry::Method
-  include ::Pry::Helpers::BaseHelpers
-  include ::Pry::Helpers::DocumentationHelpers
-  include ::Pry::CodeObject::Helpers
-  def ==(other); end
-
-  def alias?(); end
-
-  def aliases(); end
-
-  def bound_method?(); end
-
-  def comment(); end
-
-  def doc(); end
-
-  def dynamically_defined?(); end
-
-  def initialize(method, known_info=T.unsafe(nil)); end
-
-  def is_a?(klass); end
-
-  def kind_of?(klass); end
-
-  def method_missing(method_name, *args, &block); end
-
-  def name(); end
-
-  def name_with_owner(); end
-
-  def original_name(); end
-
-  def owner(*args, &block); end
-
-  def parameters(*args, &block); end
-
-  def pry_method?(); end
-
-  def receiver(*args, &block); end
-
-  def redefine(source); end
-
-  def respond_to?(method_name, include_all=T.unsafe(nil)); end
-
-  def signature(); end
-
-  def singleton_method?(); end
-
-  def source(); end
-
-  def source?(); end
-
-  def source_file(); end
-
-  def source_line(); end
-
-  def source_range(); end
-
-  def source_type(); end
-
-  def super(times=T.unsafe(nil)); end
-
-  def unbound_method?(); end
-
-  def undefined?(); end
-
-  def visibility(); end
-
-  def wrapped(); end
-
-  def wrapped_owner(); end
-end
-
-class Pry::Method::Disowned
-  def initialize(receiver, method_name); end
-
-  def owner(); end
-
-  def receiver(); end
-end
-
-class Pry::Method::Disowned
-end
-
-class Pry::Method::Patcher
-  def initialize(method); end
-
-  def method(); end
-
-  def method=(method); end
-
-  def patch_in_ram(source); end
-end
-
-class Pry::Method::Patcher
-  def self.code_for(filename); end
-end
-
-class Pry::Method::WeirdMethodLocator
-  def find_method(); end
-
-  def initialize(method, target); end
-
-  def lost_method?(); end
-
-  def method(); end
-
-  def method=(method); end
-
-  def target(); end
-
-  def target=(target); end
-end
-
-class Pry::Method::WeirdMethodLocator
-  def self.normal_method?(method, binding); end
-
-  def self.weird_method?(method, binding); end
-end
-
-class Pry::Method
-  extend ::Pry::Helpers::BaseHelpers
-  extend ::Pry::Forwardable
-  extend ::Forwardable
-  def self.all_from_class(klass, include_super=T.unsafe(nil)); end
-
-  def self.all_from_obj(obj, include_super=T.unsafe(nil)); end
-
-  def self.from_binding(binding); end
-
-  def self.from_class(klass, name, target=T.unsafe(nil)); end
-
-  def self.from_module(klass, name, target=T.unsafe(nil)); end
-
-  def self.from_obj(obj, name, target=T.unsafe(nil)); end
-
-  def self.from_str(name, target=T.unsafe(nil), options=T.unsafe(nil)); end
-
-  def self.instance_method_definition?(name, definition_line); end
-
-  def self.instance_resolution_order(klass); end
-
-  def self.lookup_method_via_binding(obj, method_name, method_type, target=T.unsafe(nil)); end
-
-  def self.method_definition?(name, definition_line); end
-
-  def self.resolution_order(obj); end
-
-  def self.singleton_class_of(obj); end
-
-  def self.singleton_class_resolution_order(klass); end
-
-  def self.singleton_method_definition?(name, definition_line); end
-end
-
-class Pry::MethodNotFound
-end
-
-class Pry::MethodNotFound
-end
-
-class Pry::NoCommandError
-  def initialize(match, owner); end
-end
-
-class Pry::NoCommandError
-end
-
-class Pry::ObjectPath
-  def initialize(path_string, current_stack); end
-
-  def resolve(); end
-  SPECIAL_TERMS = ::T.let(nil, ::T.untyped)
-end
-
-class Pry::ObjectPath
-end
-
-class Pry::ObsoleteError
-end
-
-class Pry::ObsoleteError
-end
-
-class Pry::Output
-  def <<(*objs); end
-
-  def decolorize_maybe(str); end
-
-  def height(); end
-
-  def initialize(pry_instance); end
-
-  def method_missing(method_name, *args, &block); end
-
-  def print(*objs); end
-
-  def pry_instance(); end
-
-  def puts(*objs); end
-
-  def size(); end
-
-  def tty?(); end
-
-  def width(); end
-
-  def write(*objs); end
-  DEFAULT_SIZE = ::T.let(nil, ::T.untyped)
-end
-
-class Pry::Output
-end
-
-class Pry::Pager
-  def initialize(pry_instance); end
-
-  def open(); end
-
-  def page(text); end
-
-  def pry_instance(); end
-end
-
-class Pry::Pager::NullPager
-  def <<(str); end
-
-  def close(); end
-
-  def initialize(out); end
-
-  def print(str); end
-
-  def puts(str); end
-
-  def write(str); end
-end
-
-class Pry::Pager::NullPager
-end
-
-class Pry::Pager::PageTracker
-  def initialize(rows, cols); end
-
-  def page?(); end
-
-  def record(str); end
-
-  def reset(); end
-end
-
-class Pry::Pager::PageTracker
-end
-
-class Pry::Pager::SimplePager
-  def initialize(*arg); end
-end
-
-class Pry::Pager::SimplePager
-end
-
-class Pry::Pager::StopPaging
-end
-
-class Pry::Pager::StopPaging
-end
-
-class Pry::Pager::SystemPager
-  def initialize(*arg); end
-end
-
-class Pry::Pager::SystemPager
-  def self.available?(); end
-
-  def self.default_pager(); end
-end
-
-class Pry::Pager
-end
-
-class Pry::Prompt
-  def [](key); end
-
-  def description(); end
-
-  def incomplete_proc(); end
-
-  def initialize(name, description, prompt_procs); end
-
-  def name(); end
-
-  def prompt_procs(); end
-
-  def wait_proc(); end
-end
-
-class Pry::Prompt
-  def self.[](name); end
-
-  def self.add(name, description=T.unsafe(nil), separators=T.unsafe(nil)); end
-
-  def self.all(); end
-end
-
-class Pry::REPL
-  def initialize(pry, options=T.unsafe(nil)); end
-
-  def input(*args, &block); end
-
-  def output(*args, &block); end
-
-  def pry(); end
-
-  def pry=(pry); end
-
-  def start(); end
-end
-
-class Pry::REPL
-  extend ::Pry::Forwardable
-  extend ::Forwardable
-  def self.start(options); end
-end
-
-class Pry::REPLFileLoader
-  def define_additional_commands(); end
-
-  def initialize(file_name); end
-
-  def interactive_mode(pry_instance); end
-
-  def load(); end
-
-  def non_interactive_mode(pry_instance, content); end
-end
-
-class Pry::REPLFileLoader
-end
-
-module Pry::RescuableException
-end
-
-module Pry::RescuableException
-  def self.===(exception); end
-end
-
-class Pry::Result
-  def command?(); end
-
-  def initialize(is_command, retval=T.unsafe(nil)); end
-
-  def retval(); end
-
-  def void_command?(); end
-end
-
-class Pry::Result
-end
-
-class Pry::Ring
-  def <<(value); end
-
-  def [](index); end
-
-  def clear(); end
-
-  def count(); end
-
-  def initialize(max_size); end
-
-  def max_size(); end
-
-  def size(); end
-
-  def to_a(); end
-end
-
-class Pry::Ring
-end
-
-class Pry::Slop
-  include ::Enumerable
-  def [](key); end
-
-  def add_callback(label, &block); end
-
-  def banner(banner=T.unsafe(nil)); end
-
-  def banner=(banner); end
-
-  def command(command, options=T.unsafe(nil), &block); end
-
-  def config(); end
-
-  def description(desc=T.unsafe(nil)); end
-
-  def description=(desc); end
-
-  def each(&block); end
-
-  def fetch_command(command); end
-
-  def fetch_option(key); end
-
-  def get(key); end
-
-  def help(); end
-
-  def initialize(config=T.unsafe(nil), &block); end
-
-  def missing(); end
-
-  def on(*objects, &block); end
-
-  def opt(*objects, &block); end
-
-  def option(*objects, &block); end
-
-  def options(); end
-
-  def parse(items=T.unsafe(nil), &block); end
-
-  def parse!(items=T.unsafe(nil), &block); end
-
-  def present?(*keys); end
-
-  def run(callable=T.unsafe(nil), &block); end
-
-  def separator(text); end
-
-  def strict?(); end
-
-  def to_h(include_commands=T.unsafe(nil)); end
-
-  def to_hash(include_commands=T.unsafe(nil)); end
-  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
-class Pry::Slop::Commands
-  include ::Enumerable
-  def [](key); end
-
-  def arguments(); end
-
-  def banner(banner=T.unsafe(nil)); end
-
-  def banner=(banner); end
-
-  def commands(); end
-
-  def config(); end
-
-  def default(config=T.unsafe(nil), &block); end
-
-  def each(&block); end
-
-  def get(key); end
-
-  def global(config=T.unsafe(nil), &block); end
-
-  def help(); end
-
-  def initialize(config=T.unsafe(nil), &block); end
-
-  def on(command, config=T.unsafe(nil), &block); end
-
-  def parse(items=T.unsafe(nil)); end
-
-  def parse!(items=T.unsafe(nil)); end
-
-  def present?(key); end
-
-  def to_hash(); end
-end
-
-class Pry::Slop::Commands
-end
-
-class Pry::Slop::Error
-end
-
-class Pry::Slop::Error
-end
-
-class Pry::Slop::InvalidArgumentError
-end
-
-class Pry::Slop::InvalidArgumentError
-end
-
-class Pry::Slop::InvalidCommandError
-end
-
-class Pry::Slop::InvalidCommandError
-end
-
-class Pry::Slop::InvalidOptionError
-end
-
-class Pry::Slop::InvalidOptionError
-end
-
-class Pry::Slop::MissingArgumentError
-end
-
-class Pry::Slop::MissingArgumentError
-end
-
-class Pry::Slop::MissingOptionError
-end
-
-class Pry::Slop::MissingOptionError
-end
-
-class Pry::Slop::Option
-  def accepts_optional_argument?(); end
-
-  def argument_in_value(); end
-
-  def argument_in_value=(argument_in_value); end
-
-  def call(*objects); end
-
-  def config(); end
-
-  def count(); end
-
-  def count=(count); end
-
-  def description(); end
-
-  def expects_argument?(); end
-
-  def help(); end
-
-  def initialize(slop, short, long, description, config=T.unsafe(nil), &block); end
-
-  def key(); end
-
-  def long(); end
-
-  def short(); end
-
-  def types(); end
-
-  def value(); end
-
-  def value=(new_value); end
-  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
-end
-
-class Pry::Slop::Option
-end
-
-class Pry::Slop
-  def self.optspec(string, config=T.unsafe(nil)); end
-
-  def self.parse(items=T.unsafe(nil), config=T.unsafe(nil), &block); end
-
-  def self.parse!(items=T.unsafe(nil), config=T.unsafe(nil), &block); end
-end
-
-class Pry::SyntaxHighlighter
-end
-
-class Pry::SyntaxHighlighter
-  def self.highlight(code, language=T.unsafe(nil)); end
-
-  def self.keyword_token_color(); end
-
-  def self.overwrite_coderay_comment_token!(); end
-
-  def self.tokenize(code, language=T.unsafe(nil)); end
-end
-
-module Pry::SystemCommandHandler
-end
-
-module Pry::SystemCommandHandler
-  def self.default(output, command, _pry_instance); end
-end
-
-module Pry::TooSafeException
-end
-
-module Pry::TooSafeException
-  def self.===(exception); end
-end
-
-module Pry::UserError
-end
-
-module Pry::UserError
-end
-
-module Pry::Warning
-end
-
-module Pry::Warning
-  def self.warn(message); end
-end
-
-class Pry::WrappedModule
-  include ::Pry::Helpers::BaseHelpers
-  include ::Pry::CodeObject::Helpers
-  def candidate(rank); end
-
-  def candidates(); end
-
-  def class?(); end
-
-  def constants(inherit=T.unsafe(nil)); end
-
-  def doc(); end
-
-  def file(); end
-
-  def initialize(mod); end
-
-  def line(); end
-
-  def method_missing(method_name, *args, &block); end
-
-  def method_prefix(); end
-
-  def module?(); end
-
-  def nonblank_name(); end
-
-  def number_of_candidates(); end
-
-  def singleton_class?(); end
-
-  def singleton_instance(); end
-
-  def source(); end
-
-  def source_file(); end
-
-  def source_line(); end
-
-  def source_location(); end
-
-  def super(times=T.unsafe(nil)); end
-
-  def wrapped(); end
-
-  def yard_doc(); end
-
-  def yard_docs?(); end
-
-  def yard_file(); end
-
-  def yard_line(); end
-end
-
-class Pry::WrappedModule::Candidate
-  include ::Pry::Helpers::DocumentationHelpers
-  include ::Pry::CodeObject::Helpers
-  def class?(*args, &block); end
-
-  def doc(); end
-
-  def file(); end
-
-  def initialize(wrapper, rank); end
-
-  def line(); end
-
-  def module?(*args, &block); end
-
-  def nonblank_name(*args, &block); end
-
-  def number_of_candidates(*args, &block); end
-
-  def source(); end
-
-  def source_file(); end
-
-  def source_line(); end
-
-  def source_location(); end
-
-  def wrapped(*args, &block); end
-end
-
-class Pry::WrappedModule::Candidate
-  extend ::Pry::Forwardable
-  extend ::Forwardable
-end
-
-class Pry::WrappedModule
-  def self.from_str(mod_name, target=T.unsafe(nil)); end
-end
-
-class Pry
-  extend ::Pry::Forwardable
-  extend ::Forwardable
-  def self.Code(obj); end
-
-  def self.Method(obj); end
-
-  def self.WrappedModule(obj); end
-
-  def self.auto_resize!(); end
-
-  def self.binding_for(target); end
-
-  def self.cli(); end
-
-  def self.cli=(cli); end
-
-  def self.color(*args, &block); end
-
-  def self.color=(*args, &block); end
-
-  def self.commands(*args, &block); end
-
-  def self.commands=(*args, &block); end
-
-  def self.config(); end
-
-  def self.config=(config); end
-
-  def self.configure(); end
-
-  def self.critical_section(); end
-
-  def self.current(); end
-
-  def self.current_line(); end
-
-  def self.current_line=(current_line); end
-
-  def self.custom_completions(); end
-
-  def self.custom_completions=(custom_completions); end
-
-  def self.editor(*args, &block); end
-
-  def self.editor=(*args, &block); end
-
-  def self.eval_path(); end
-
-  def self.eval_path=(eval_path); end
-
-  def self.exception_handler(*args, &block); end
-
-  def self.exception_handler=(*args, &block); end
-
-  def self.extra_sticky_locals(*args, &block); end
-
-  def self.extra_sticky_locals=(*args, &block); end
-
-  def self.final_session_setup(); end
-
-  def self.history(*args, &block); end
-
-  def self.history=(*args, &block); end
-
-  def self.hooks(*args, &block); end
-
-  def self.hooks=(*args, &block); end
-
-  def self.in_critical_section?(); end
-
-  def self.initial_session?(); end
-
-  def self.initial_session_setup(); end
-
-  def self.input(*args, &block); end
-
-  def self.input=(*args, &block); end
-
-  def self.last_internal_error(); end
-
-  def self.last_internal_error=(last_internal_error); end
-
-  def self.line_buffer(); end
-
-  def self.line_buffer=(line_buffer); end
-
-  def self.load_file_at_toplevel(file); end
-
-  def self.load_file_through_repl(file_name); end
-
-  def self.load_history(); end
-
-  def self.load_rc_files(); end
-
-  def self.load_requires(); end
-
-  def self.load_traps(); end
-
-  def self.load_win32console(); end
-
-  def self.main(); end
-
-  def self.memory_size(*args, &block); end
-
-  def self.memory_size=(*args, &block); end
-
-  def self.output(*args, &block); end
-
-  def self.output=(*args, &block); end
-
-  def self.pager(*args, &block); end
-
-  def self.pager=(*args, &block); end
-
-  def self.print(*args, &block); end
-
-  def self.print=(*args, &block); end
-
-  def self.prompt(*args, &block); end
-
-  def self.prompt=(*args, &block); end
-
-  def self.quiet(); end
-
-  def self.quiet=(quiet); end
-
-  def self.rc_files_to_load(); end
-
-  def self.real_path_to(file); end
-
-  def self.reset_defaults(); end
-
-  def self.run_command(command_string, options=T.unsafe(nil)); end
-
-  def self.start(target=T.unsafe(nil), options=T.unsafe(nil)); end
-
-  def self.toplevel_binding(); end
-
-  def self.toplevel_binding=(toplevel_binding); end
-
-  def self.view_clip(obj, options=T.unsafe(nil)); end
 end
 
 module Psych
@@ -19129,1780 +7072,25 @@ module PyPI
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
-class RDiscount
-  def autolink(); end
-
-  def autolink=(autolink); end
-
-  def filter_html(); end
-
-  def filter_html=(filter_html); end
-
-  def filter_styles(); end
-
-  def filter_styles=(filter_styles); end
-
-  def fold_lines(); end
-
-  def fold_lines=(fold_lines); end
-
-  def footnotes(); end
-
-  def footnotes=(footnotes); end
-
-  def generate_toc(); end
-
-  def generate_toc=(generate_toc); end
-
-  def initialize(text, *extensions); end
-
-  def no_image(); end
-
-  def no_image=(no_image); end
-
-  def no_links(); end
-
-  def no_links=(no_links); end
-
-  def no_pseudo_protocols(); end
-
-  def no_pseudo_protocols=(no_pseudo_protocols); end
-
-  def no_strikethrough(); end
-
-  def no_strikethrough=(no_strikethrough); end
-
-  def no_superscript(); end
-
-  def no_superscript=(no_superscript); end
-
-  def no_tables(); end
-
-  def no_tables=(no_tables); end
-
-  def safelink(); end
-
-  def safelink=(safelink); end
-
-  def smart(); end
-
-  def smart=(smart); end
-
-  def strict(); end
-
-  def strict=(strict); end
-
-  def text(); end
-
-  def to_html(*arg); end
-
-  def toc_content(*arg); end
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
-class RDiscount
-end
-
-class REXML::UndefinedNamespaceException
-  def initialize(prefix, source, parser); end
-end
-
-class REXML::Validation::ValidationException
-  def initialize(msg); end
-end
-
 class REXML::XPathParser
   DEBUG = ::T.let(nil, ::T.untyped)
 end
 
-module RSpec
-  MODULES_TO_AUTOLOAD = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::CallerFilter
-  ADDITIONAL_TOP_LEVEL_FILES = ::T.let(nil, ::T.untyped)
-  IGNORE_REGEX = ::T.let(nil, ::T.untyped)
-  LIB_REGEX = ::T.let(nil, ::T.untyped)
-  RSPEC_LIBS = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::CallerFilter
-  def self.first_non_rspec_line(skip_frames=T.unsafe(nil), increment=T.unsafe(nil)); end
-end
-
-module RSpec::Core
-end
-
-class RSpec::Core::AnonymousExampleGroup
-end
-
-class RSpec::Core::AnonymousExampleGroup
-end
-
-class RSpec::Core::BacktraceFormatter
-  def backtrace_line(line); end
-
-  def exclude?(line); end
-
-  def exclusion_patterns(); end
-
-  def exclusion_patterns=(exclusion_patterns); end
-
-  def filter_gem(gem_name); end
-
-  def format_backtrace(backtrace, options=T.unsafe(nil)); end
-
-  def full_backtrace=(full_backtrace); end
-
-  def full_backtrace?(); end
-
-  def inclusion_patterns(); end
-
-  def inclusion_patterns=(inclusion_patterns); end
-end
-
-class RSpec::Core::BacktraceFormatter
-end
-
-module RSpec::Core::Bisect
-end
-
-class RSpec::Core::Bisect::BisectFailedError
-end
-
-class RSpec::Core::Bisect::BisectFailedError
-  def self.for_failed_spec_run(spec_output); end
-end
-
-class RSpec::Core::Bisect::Channel
-  def close(); end
-
-  def receive(); end
-
-  def send(message); end
-end
-
-class RSpec::Core::Bisect::Channel
-end
-
-class RSpec::Core::Bisect::ExampleSetDescriptor
-  def all_example_ids(); end
-
-  def all_example_ids=(_); end
-
-  def failed_example_ids(); end
-
-  def failed_example_ids=(_); end
-end
-
-class RSpec::Core::Bisect::ExampleSetDescriptor
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class RSpec::Core::Bisect::Notifier
-  def initialize(formatter); end
-
-  def publish(event, *args); end
-end
-
-class RSpec::Core::Bisect::Notifier
-end
-
-module RSpec::Core::Bisect
-end
-
-class RSpec::Core::Configuration
-  include ::RSpec::Core::Hooks
-  include ::RSpec::Core::Configuration::Readers
-  def add_formatter(formatter, output=T.unsafe(nil)); end
-
-  def add_setting(name, opts=T.unsafe(nil)); end
-
-  def after(scope=T.unsafe(nil), *meta, &block); end
-
-  def alias_example_group_to(new_name, *args); end
-
-  def alias_example_to(name, *args); end
-
-  def alias_it_behaves_like_to(new_name, report_label=T.unsafe(nil)); end
-
-  def alias_it_should_behave_like_to(new_name, report_label=T.unsafe(nil)); end
-
-  def append_after(scope=T.unsafe(nil), *meta, &block); end
-
-  def append_before(scope=T.unsafe(nil), *meta, &block); end
-
-  def apply_derived_metadata_to(metadata); end
-
-  def around(scope=T.unsafe(nil), *meta, &block); end
-
-  def backtrace_exclusion_patterns(); end
-
-  def backtrace_exclusion_patterns=(patterns); end
-
-  def backtrace_formatter(); end
-
-  def backtrace_inclusion_patterns(); end
-
-  def backtrace_inclusion_patterns=(patterns); end
-
-  def before(scope=T.unsafe(nil), *meta, &block); end
-
-  def bisect_runner(); end
-
-  def bisect_runner=(value); end
-
-  def bisect_runner_class(); end
-
-  def color(); end
-
-  def color=(color); end
-
-  def color_enabled?(output=T.unsafe(nil)); end
-
-  def color_mode(); end
-
-  def color_mode=(color_mode); end
-
-  def configure_example(example, example_hooks); end
-
-  def configure_expectation_framework(); end
-
-  def configure_group(group); end
-
-  def configure_mock_framework(); end
-
-  def default_color=(default_color); end
-
-  def default_color?(); end
-
-  def default_formatter(); end
-
-  def default_formatter=(value); end
-
-  def default_path=(path); end
-
-  def default_path?(); end
-
-  def define_derived_metadata(*filters, &block); end
-
-  def deprecation_stream=(value); end
-
-  def detail_color=(detail_color); end
-
-  def detail_color?(); end
-
-  def disable_monkey_patching(); end
-
-  def disable_monkey_patching!(); end
-
-  def disable_monkey_patching=(disable_monkey_patching); end
-
-  def drb=(drb); end
-
-  def drb?(); end
-
-  def drb_port=(drb_port); end
-
-  def drb_port?(); end
-
-  def dry_run=(dry_run); end
-
-  def dry_run?(); end
-
-  def error_exit_code=(error_exit_code); end
-
-  def error_exit_code?(); end
-
-  def error_stream=(error_stream); end
-
-  def error_stream?(); end
-
-  def example_status_persistence_file_path=(value); end
-
-  def exclude_pattern=(value); end
-
-  def exclusion_filter(); end
-
-  def exclusion_filter=(filter); end
-
-  def expect_with(*frameworks); end
-
-  def expectation_framework=(framework); end
-
-  def expectation_frameworks(); end
-
-  def expose_current_running_example_as(method_name); end
-
-  def expose_dsl_globally=(value); end
-
-  def expose_dsl_globally?(); end
-
-  def extend(mod, *filters); end
-
-  def fail_fast=(value); end
-
-  def fail_if_no_examples=(fail_if_no_examples); end
-
-  def fail_if_no_examples?(); end
-
-  def failure_color=(failure_color); end
-
-  def failure_color?(); end
-
-  def failure_exit_code=(failure_exit_code); end
-
-  def failure_exit_code?(); end
-
-  def files_or_directories_to_run=(*files); end
-
-  def files_to_run(); end
-
-  def files_to_run=(files_to_run); end
-
-  def filter(); end
-
-  def filter=(filter); end
-
-  def filter_gems_from_backtrace(*gem_names); end
-
-  def filter_manager(); end
-
-  def filter_manager=(filter_manager); end
-
-  def filter_run(*args); end
-
-  def filter_run_excluding(*args); end
-
-  def filter_run_including(*args); end
-
-  def filter_run_when_matching(*args); end
-
-  def fixed_color=(fixed_color); end
-
-  def fixed_color?(); end
-
-  def force(hash); end
-
-  def format_docstrings(&block); end
-
-  def format_docstrings_block(); end
-
-  def formatter=(formatter, output=T.unsafe(nil)); end
-
-  def formatter_loader(); end
-
-  def formatters(); end
-
-  def full_backtrace=(true_or_false); end
-
-  def full_backtrace?(); end
-
-  def full_description(); end
-
-  def full_description=(description); end
-
-  def in_project_source_dir_regex(); end
-
-  def include(mod, *filters); end
-
-  def include_context(shared_group_name, *filters); end
-
-  def inclusion_filter(); end
-
-  def inclusion_filter=(filter); end
-
-  def last_run_statuses(); end
-
-  def libs=(libs); end
-
-  def load_spec_files(); end
-
-  def loaded_spec_files(); end
-
-  def max_displayed_failure_line_count=(max_displayed_failure_line_count); end
-
-  def max_displayed_failure_line_count?(); end
-
-  def mock_framework(); end
-
-  def mock_framework=(framework); end
-
-  def mock_with(framework); end
-
-  def on_example_group_definition(&block); end
-
-  def on_example_group_definition_callbacks(); end
-
-  def only_failures?(); end
-
-  def only_failures_but_not_configured?(); end
-
-  def order=(*args, &block); end
-
-  def ordering_manager(); end
-
-  def ordering_registry(*args, &block); end
-
-  def output_stream=(value); end
-
-  def pattern=(value); end
-
-  def pending_color=(pending_color); end
-
-  def pending_color?(); end
-
-  def prepend(mod, *filters); end
-
-  def prepend_after(scope=T.unsafe(nil), *meta, &block); end
-
-  def prepend_before(scope=T.unsafe(nil), *meta, &block); end
-
-  def profile_examples(); end
-
-  def profile_examples=(profile_examples); end
-
-  def profile_examples?(); end
-
-  def project_source_dirs=(project_source_dirs); end
-
-  def project_source_dirs?(); end
-
-  def raise_errors_for_deprecations!(); end
-
-  def raise_on_warning=(value); end
-
-  def register_ordering(*args, &block); end
-
-  def reporter(); end
-
-  def requires=(paths); end
-
-  def reset(); end
-
-  def reset_filters(); end
-
-  def reset_reporter(); end
-
-  def run_all_when_everything_filtered=(run_all_when_everything_filtered); end
-
-  def run_all_when_everything_filtered?(); end
-
-  def seed(*args, &block); end
-
-  def seed=(*args, &block); end
-
-  def seed_used?(*args, &block); end
-
-  def shared_context_metadata_behavior=(value); end
-
-  def silence_filter_announcements=(silence_filter_announcements); end
-
-  def silence_filter_announcements?(); end
-
-  def spec_files_with_failures(); end
-
-  def start_time=(start_time); end
-
-  def start_time?(); end
-
-  def static_config_filter_manager(); end
-
-  def static_config_filter_manager=(static_config_filter_manager); end
-
-  def success_color=(success_color); end
-
-  def success_color?(); end
-
-  def threadsafe=(threadsafe); end
-
-  def threadsafe?(); end
-
-  def treat_symbols_as_metadata_keys_with_true_values=(_value); end
-
-  def tty=(tty); end
-
-  def tty?(); end
-
-  def warnings=(value); end
-
-  def warnings?(); end
-
-  def when_first_matching_example_defined(*filters); end
-
-  def with_suite_hooks(); end
-
-  def world(); end
-
-  def world=(world); end
-  DEFAULT_FORMATTER = ::T.let(nil, ::T.untyped)
-  FAILED_STATUS = ::T.let(nil, ::T.untyped)
-  MOCKING_ADAPTERS = ::T.let(nil, ::T.untyped)
-  PASSED_STATUS = ::T.let(nil, ::T.untyped)
-  PENDING_STATUS = ::T.let(nil, ::T.untyped)
-  RAISE_ERROR_WARNING_NOTIFIER = ::T.let(nil, ::T.untyped)
-  UNKNOWN_STATUS = ::T.let(nil, ::T.untyped)
-  VALID_STATUSES = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Core::Configuration::DeprecationReporterBuffer
-  def deprecation(*args); end
-
-  def play_onto(reporter); end
-end
-
-class RSpec::Core::Configuration::DeprecationReporterBuffer
-end
-
-module RSpec::Core::Configuration::ExposeCurrentExample
-end
-
-module RSpec::Core::Configuration::ExposeCurrentExample
-end
-
-class RSpec::Core::Configuration::MustBeConfiguredBeforeExampleGroupsError
-end
-
-class RSpec::Core::Configuration::MustBeConfiguredBeforeExampleGroupsError
-end
-
-module RSpec::Core::Configuration::Readers
-  def clear_lets_on_failure(); end
-
-  def default_color(); end
-
-  def default_path(); end
-
-  def default_retry_count(); end
-
-  def default_sleep_interval(); end
-
-  def deprecation_stream(); end
-
-  def detail_color(); end
-
-  def display_try_failure_messages(); end
-
-  def drb(); end
-
-  def drb_port(); end
-
-  def dry_run(); end
-
-  def error_exit_code(); end
-
-  def error_stream(); end
-
-  def example_status_persistence_file_path(); end
-
-  def exceptions_to_hard_fail(); end
-
-  def exceptions_to_retry(); end
-
-  def exclude_pattern(); end
-
-  def exponential_backoff(); end
-
-  def fail_fast(); end
-
-  def fail_if_no_examples(); end
-
-  def failure_color(); end
-
-  def failure_exit_code(); end
-
-  def fixed_color(); end
-
-  def libs(); end
-
-  def max_displayed_failure_line_count(); end
-
-  def only_failures(); end
-
-  def output_stream(); end
-
-  def pattern(); end
-
-  def pending_color(); end
-
-  def project_source_dirs(); end
-
-  def requires(); end
-
-  def retry_callback(); end
-
-  def retry_count_condition(); end
-
-  def run_all_when_everything_filtered(); end
-
-  def shared_context_metadata_behavior(); end
-
-  def silence_filter_announcements(); end
-
-  def start_time(); end
-
-  def success_color(); end
-
-  def threadsafe(); end
-
-  def tty(); end
-
-  def verbose_retry(); end
-
-  def wait_delay(); end
-
-  def wait_timeout(); end
-end
-
-module RSpec::Core::Configuration::Readers
-end
-
-class RSpec::Core::Configuration
-  def self.add_read_only_setting(name, opts=T.unsafe(nil)); end
-
-  def self.add_setting(name, opts=T.unsafe(nil)); end
-
-  def self.define_alias(name, alias_name); end
-
-  def self.define_predicate(name); end
-
-  def self.define_reader(name); end
-
-  def self.delegate_to_ordering_manager(*methods); end
-end
-
-class RSpec::Core::ConfigurationOptions
-  def args(); end
-
-  def configure(config); end
-
-  def configure_filter_manager(filter_manager); end
-
-  def initialize(args); end
-
-  def options(); end
-  OPTIONS_ORDER = ::T.let(nil, ::T.untyped)
-  UNFORCED_OPTIONS = ::T.let(nil, ::T.untyped)
-  UNPROCESSABLE_OPTIONS = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Core::ConfigurationOptions
-end
-
-module RSpec::Core::DSL
-end
-
-module RSpec::Core::DSL
-  def self.change_global_dsl(&changes); end
-
-  def self.example_group_aliases(); end
-
-  def self.expose_example_group_alias(name); end
-
-  def self.expose_example_group_alias_globally(method_name); end
-
-  def self.expose_globally!(); end
-
-  def self.exposed_globally?(); end
-
-  def self.remove_globally!(); end
-
-  def self.top_level(); end
-
-  def self.top_level=(top_level); end
-end
-
-class RSpec::Core::DeprecationError
-end
-
-class RSpec::Core::DeprecationError
-end
-
-class RSpec::Core::DidYouMean
-  def call(); end
-
-  def initialize(relative_file_name); end
-
-  def relative_file_name(); end
-end
-
-class RSpec::Core::DidYouMean
-end
-
-class RSpec::Core::Example
-  def attempts(); end
-
-  def attempts=(attempts); end
-
-  def clear_exception(); end
-
-  def clock(); end
-
-  def clock=(clock); end
-
-  def description(); end
-
-  def display_exception(); end
-
-  def display_exception=(ex); end
-
-  def duplicate_with(metadata_overrides=T.unsafe(nil)); end
-
-  def example_group(); end
-
-  def example_group_instance(); end
-
-  def exception(); end
-
-  def execution_result(); end
-
-  def fail_with_exception(reporter, exception); end
-
-  def file_path(); end
-
-  def full_description(); end
-
-  def id(); end
-
-  def initialize(example_group_class, description, user_metadata, example_block=T.unsafe(nil)); end
-
-  def inspect_output(); end
-
-  def instance_exec(*args, &block); end
-
-  def location(); end
-
-  def location_rerun_argument(); end
-
-  def metadata(); end
-
-  def pending(); end
-
-  def pending?(); end
-
-  def reporter(); end
-
-  def rerun_argument(); end
-
-  def run(example_group_instance, reporter); end
-
-  def set_aggregate_failures_exception(exception); end
-
-  def set_exception(exception); end
-
-  def skip(); end
-
-  def skip_with_exception(reporter, exception); end
-
-  def skipped?(); end
-
-  def update_inherited_metadata(updates); end
-end
-
-RSpec::Core::Example::AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt = RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
-
-class RSpec::Core::Example::ExecutionResult
-  include ::RSpec::Core::HashImitatable
-  def ensure_timing_set(clock); end
-
-  def example_skipped?(); end
-
-  def exception(); end
-
-  def exception=(exception); end
-
-  def finished_at(); end
-
-  def finished_at=(finished_at); end
-
-  def pending_exception(); end
-
-  def pending_exception=(pending_exception); end
-
-  def pending_fixed(); end
-
-  def pending_fixed=(pending_fixed); end
-
-  def pending_fixed?(); end
-
-  def pending_message(); end
-
-  def pending_message=(pending_message); end
-
-  def record_finished(status, finished_at); end
-
-  def run_time(); end
-
-  def run_time=(run_time); end
-
-  def started_at(); end
-
-  def started_at=(started_at); end
-
-  def status(); end
-
-  def status=(status); end
-end
-
-class RSpec::Core::Example::ExecutionResult
-  extend ::RSpec::Core::HashImitatable::ClassMethods
-end
-
-class RSpec::Core::Example::Procsy
-  def <<(*a, &b); end
-
-  def ===(*a, &b); end
-
-  def >>(*a, &b); end
-
-  def [](*a, &b); end
-
-  def arity(*a, &b); end
-
-  def attempts(); end
-
-  def binding(*a, &b); end
-
-  def call(*args, &block); end
-
-  def clock(*a, &b); end
-
-  def clock=(*a, &b); end
-
-  def clone(*a, &b); end
-
-  def curry(*a, &b); end
-
-  def description(*a, &b); end
-
-  def dup(*a, &b); end
-
-  def duplicate_with(*a, &b); end
-
-  def example(); end
-
-  def example_group(*a, &b); end
-
-  def example_group_instance(*a, &b); end
-
-  def exception(*a, &b); end
-
-  def executed?(); end
-
-  def execution_result(*a, &b); end
-
-  def file_path(*a, &b); end
-
-  def full_description(*a, &b); end
-
-  def hash(*a, &b); end
-
-  def id(*a, &b); end
-
-  def initialize(example, &block); end
-
-  def inspect_output(*a, &b); end
-
-  def lambda?(*a, &b); end
-
-  def location(*a, &b); end
-
-  def location_rerun_argument(*a, &b); end
-
-  def metadata(*a, &b); end
-
-  def parameters(*a, &b); end
-
-  def pending(*a, &b); end
-
-  def pending?(*a, &b); end
-
-  def reporter(*a, &b); end
-
-  def rerun_argument(*a, &b); end
-
-  def run(*args, &block); end
-
-  def run_with_retry(opts=T.unsafe(nil)); end
-
-  def skip(*a, &b); end
-
-  def skipped?(*a, &b); end
-
-  def source_location(*a, &b); end
-
-  def to_proc(); end
-
-  def update_inherited_metadata(*a, &b); end
-
-  def wrap(&block); end
-
-  def yield(*a, &b); end
-end
-
-class RSpec::Core::Example::Procsy
-end
-
-class RSpec::Core::Example
-  def self.delegate_to_metadata(key); end
-
-  def self.parse_id(id); end
-end
-
 class RSpec::Core::ExampleGroup
-  include ::RSpec::Core::MemoizedHelpers
-  include ::RSpec::Core::Pending
   include ::RSpec::Core::MockingAdapters::RSpec
   include ::RSpec::Mocks::ExampleMethods
   include ::RSpec::Mocks::ArgumentMatchers
   include ::RSpec::Mocks::ExampleMethods::ExpectHost
   include ::RSpec::Matchers
-  def clear_lets(); end
-
-  def clear_memoized(); end
-
-  def described_class(); end
-
-  def initialize(inspect_output=T.unsafe(nil)); end
-  INSTANCE_VARIABLE_TO_IGNORE = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Core::ExampleGroup::WrongScopeError
-end
-
-class RSpec::Core::ExampleGroup::WrongScopeError
-end
-
-class RSpec::Core::ExampleGroup
-  extend ::RSpec::Core::Hooks
-  extend ::RSpec::Core::MemoizedHelpers::ClassMethods
-  extend ::RSpec::Core::SharedExampleGroup
-  def self.add_example(example); end
-
-  def self.before_context_ivars(); end
-
-  def self.children(); end
-
-  def self.context(*args, &example_group_block); end
-
-  def self.currently_executing_a_context_hook?(); end
-
-  def self.declaration_locations(); end
-
-  def self.define_example_group_method(name, metadata=T.unsafe(nil)); end
-
-  def self.define_example_method(name, extra_options=T.unsafe(nil)); end
-
-  def self.define_nested_shared_group_method(new_name, report_label=T.unsafe(nil)); end
-
-  def self.delegate_to_metadata(*names); end
-
-  def self.descendant_filtered_examples(); end
-
-  def self.descendants(); end
-
-  def self.describe(*args, &example_group_block); end
-
-  def self.described_class(); end
-
-  def self.description(); end
-
-  def self.each_instance_variable_for_example(group); end
-
-  def self.ensure_example_groups_are_configured(); end
-
-  def self.example(*all_args, &block); end
-
-  def self.example_group(*args, &example_group_block); end
-
-  def self.examples(); end
-
-  def self.fcontext(*args, &example_group_block); end
-
-  def self.fdescribe(*args, &example_group_block); end
-
-  def self.fexample(*all_args, &block); end
-
-  def self.file_path(); end
-
-  def self.filtered_examples(); end
-
-  def self.find_and_eval_shared(label, name, inclusion_location, *args, &customization_block); end
-
-  def self.fit(*all_args, &block); end
-
-  def self.focus(*all_args, &block); end
-
-  def self.for_filtered_examples(reporter, &block); end
-
-  def self.fspecify(*all_args, &block); end
-
-  def self.id(); end
-
-  def self.idempotently_define_singleton_method(name, &definition); end
-
-  def self.include_context(name, *args, &block); end
-
-  def self.include_examples(name, *args, &block); end
-
-  def self.it(*all_args, &block); end
-
-  def self.it_behaves_like(name, *args, &customization_block); end
-
-  def self.it_should_behave_like(name, *args, &customization_block); end
-
-  def self.location(); end
-
-  def self.metadata(); end
-
-  def self.next_runnable_index_for(file); end
-
-  def self.ordering_strategy(); end
-
-  def self.parent_groups(); end
-
-  def self.pending(*all_args, &block); end
-
-  def self.remove_example(example); end
-
-  def self.reset_memoized(); end
-
-  def self.run(reporter=T.unsafe(nil)); end
-
-  def self.run_after_context_hooks(example_group_instance); end
-
-  def self.run_before_context_hooks(example_group_instance); end
-
-  def self.run_examples(reporter); end
-
-  def self.set_it_up(description, args, registration_collection, &example_group_block); end
-
-  def self.set_ivars(instance, ivars); end
-
-  def self.skip(*all_args, &block); end
-
-  def self.specify(*all_args, &block); end
-
-  def self.store_before_context_ivars(example_group_instance); end
-
-  def self.subclass(parent, description, args, registration_collection, &example_group_block); end
-
-  def self.superclass_before_context_ivars(); end
-
-  def self.superclass_metadata(); end
-
-  def self.top_level?(); end
-
-  def self.top_level_description(); end
-
-  def self.traverse_tree_until(&block); end
-
-  def self.update_inherited_metadata(updates); end
-
-  def self.with_replaced_metadata(meta); end
-
-  def self.xcontext(*args, &example_group_block); end
-
-  def self.xdescribe(*args, &example_group_block); end
-
-  def self.xexample(*all_args, &block); end
-
-  def self.xit(*all_args, &block); end
-
-  def self.xspecify(*all_args, &block); end
-end
-
-class RSpec::Core::ExampleStatusDumper
-  def dump(); end
-
-  def initialize(examples); end
-end
-
-class RSpec::Core::ExampleStatusDumper
-  def self.dump(examples); end
-end
-
-class RSpec::Core::ExampleStatusMerger
-  def initialize(this_run, from_previous_runs); end
-
-  def merge(); end
-end
-
-class RSpec::Core::ExampleStatusMerger
-  def self.merge(this_run, from_previous_runs); end
-end
-
-class RSpec::Core::ExampleStatusParser
-  def initialize(string); end
-
-  def parse(); end
-end
-
-class RSpec::Core::ExampleStatusParser
-  def self.parse(string); end
-end
-
-class RSpec::Core::ExampleStatusPersister
-  def initialize(examples, file_name); end
-
-  def persist(); end
-end
-
-class RSpec::Core::ExampleStatusPersister
-  def self.load_from(file_name); end
-
-  def self.persist(examples, file_name); end
-end
-
-RSpec::Core::ExclusionRules = RSpec::Core::FilterRules
-
-class RSpec::Core::FilterManager
-  def add_ids(rerun_path, scoped_ids); end
-
-  def add_location(file_path, line_numbers); end
-
-  def empty?(); end
-
-  def exclude(*args); end
-
-  def exclude_only(*args); end
-
-  def exclude_with_low_priority(*args); end
-
-  def exclusions(); end
-
-  def include(*args); end
-
-  def include_only(*args); end
-
-  def include_with_low_priority(*args); end
-
-  def inclusions(); end
-
-  def prune(examples); end
-end
-
-class RSpec::Core::FilterManager
-end
-
-class RSpec::Core::FilterRules
-  def [](key); end
-
-  def add(updated); end
-
-  def add_with_low_priority(updated); end
-
-  def clear(); end
-
-  def delete(key); end
-
-  def description(); end
-
-  def each_pair(&block); end
-
-  def empty?(); end
-
-  def fetch(*args, &block); end
-
-  def include_example?(example); end
-
-  def initialize(rules=T.unsafe(nil)); end
-
-  def opposite(); end
-
-  def opposite=(opposite); end
-
-  def rules(); end
-
-  def use_only(updated); end
-  PROC_HEX_NUMBER = ::T.let(nil, ::T.untyped)
-  PROJECT_DIR = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Core::FilterRules
-  def self.build(); end
-end
-
-module RSpec::Core::FilterableItemRepository
-end
-
-class RSpec::Core::FilterableItemRepository::QueryOptimized
-  def items_for(metadata); end
-end
-
-class RSpec::Core::FilterableItemRepository::QueryOptimized
-end
-
-class RSpec::Core::FilterableItemRepository::UpdateOptimized
-  def append(item, metadata); end
-
-  def delete(item, metadata); end
-
-  def initialize(applies_predicate); end
-
-  def items_and_filters(); end
-
-  def items_for(request_meta); end
-
-  def prepend(item, metadata); end
-end
-
-class RSpec::Core::FilterableItemRepository::UpdateOptimized
-end
-
-module RSpec::Core::FilterableItemRepository
-end
-
-module RSpec::Core::FlatMap
-end
-
-module RSpec::Core::FlatMap
-  def self.flat_map(array, &block); end
-end
-
-module RSpec::Core::Formatters
-end
-
-class RSpec::Core::Formatters::BaseBisectFormatter
-  def example_failed(notification); end
-
-  def example_finished(notification); end
-
-  def initialize(expected_failures); end
-
-  def start_dump(_notification); end
-end
-
-class RSpec::Core::Formatters::BaseBisectFormatter
-  def self.inherited(formatter); end
-end
-
-class RSpec::Core::Formatters::BaseFormatter
-  def close(_notification); end
-
-  def example_group(); end
-
-  def example_group=(example_group); end
-
-  def example_group_started(notification); end
-
-  def initialize(output); end
-
-  def output(); end
-
-  def start(notification); end
-end
-
-class RSpec::Core::Formatters::BaseFormatter
-end
-
-class RSpec::Core::Formatters::BaseTextFormatter
-  def dump_failures(notification); end
-
-  def dump_pending(notification); end
-
-  def dump_summary(summary); end
-
-  def message(notification); end
-
-  def seed(notification); end
-end
-
-class RSpec::Core::Formatters::BaseTextFormatter
-end
-
-class RSpec::Core::Formatters::BisectDRbFormatter
-  def initialize(_output); end
-
-  def notify_results(results); end
-end
-
-class RSpec::Core::Formatters::BisectDRbFormatter
-end
-
-module RSpec::Core::Formatters::ConsoleCodes
-  VT100_CODES = ::T.let(nil, ::T.untyped)
-  VT100_CODE_VALUES = ::T.let(nil, ::T.untyped)
-end
-
-module RSpec::Core::Formatters::ConsoleCodes
-  def self.config_colors_to_methods(); end
-
-  def self.console_code_for(code_or_symbol); end
-
-  def self.wrap(text, code_or_symbol); end
-end
-
-class RSpec::Core::Formatters::DeprecationFormatter
-  def count(); end
-
-  def deprecation(notification); end
-
-  def deprecation_message_for(data); end
-
-  def deprecation_stream(); end
-
-  def deprecation_summary(_notification); end
-
-  def initialize(deprecation_stream, summary_stream); end
-
-  def output(); end
-
-  def printer(); end
-
-  def summary_stream(); end
-  DEPRECATION_STREAM_NOTICE = ::T.let(nil, ::T.untyped)
-  RAISE_ERROR_CONFIG_NOTICE = ::T.let(nil, ::T.untyped)
-  TOO_MANY_WARNINGS_NOTICE = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter
-  def deprecation_formatter(); end
-
-  def deprecation_stream(); end
-
-  def deprecation_summary(); end
-
-  def initialize(deprecation_stream, summary_stream, deprecation_formatter); end
-
-  def print_deferred_deprecation_warnings(); end
-
-  def print_deprecation_message(data); end
-
-  def stash_deprecation_message(deprecation_message); end
-
-  def summary_stream(); end
-  TOO_MANY_USES_LIMIT = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter
-end
-
-class RSpec::Core::Formatters::DeprecationFormatter::FileStream
-  def initialize(file); end
-
-  def puts(*args); end
-
-  def summarize(summary_stream, deprecation_count); end
-end
-
-class RSpec::Core::Formatters::DeprecationFormatter::FileStream
-end
-
-class RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage
-  def initialize(data); end
-
-  def too_many_warnings_message(); end
-
-  def type(); end
-
-  def type=(_); end
-end
-
-class RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class RSpec::Core::Formatters::DeprecationFormatter::ImmediatePrinter
-  def deprecation_formatter(); end
-
-  def deprecation_stream(); end
-
-  def deprecation_summary(); end
-
-  def initialize(deprecation_stream, summary_stream, deprecation_formatter); end
-
-  def print_deprecation_message(data); end
-
-  def summary_stream(); end
-end
-
-class RSpec::Core::Formatters::DeprecationFormatter::ImmediatePrinter
-end
-
-class RSpec::Core::Formatters::DeprecationFormatter::RaiseErrorStream
-  def puts(message); end
-
-  def summarize(summary_stream, deprecation_count); end
-end
-
-class RSpec::Core::Formatters::DeprecationFormatter::RaiseErrorStream
-end
-
-class RSpec::Core::Formatters::DeprecationFormatter::SpecifiedDeprecationMessage
-  def initialize(data); end
-
-  def too_many_warnings_message(); end
-
-  def type(); end
-
-  def type=(_); end
-end
-
-class RSpec::Core::Formatters::DeprecationFormatter::SpecifiedDeprecationMessage
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class RSpec::Core::Formatters::DeprecationFormatter
-end
-
-class RSpec::Core::Formatters::DocumentationFormatter
-  def example_failed(failure); end
-
-  def example_group_finished(_notification); end
-
-  def example_passed(passed); end
-
-  def example_pending(pending); end
-
-  def example_started(_notification); end
-end
-
-class RSpec::Core::Formatters::DocumentationFormatter
-end
-
-class RSpec::Core::Formatters::ExceptionPresenter
-  def colorized_formatted_backtrace(colorizer=T.unsafe(nil)); end
-
-  def colorized_message_lines(colorizer=T.unsafe(nil)); end
-
-  def description(); end
-
-  def example(); end
-
-  def exception(); end
-
-  def formatted_backtrace(exception=T.unsafe(nil)); end
-
-  def formatted_cause(exception); end
-
-  def fully_formatted(failure_number, colorizer=T.unsafe(nil)); end
-
-  def fully_formatted_lines(failure_number, colorizer); end
-
-  def initialize(exception, example, options=T.unsafe(nil)); end
-
-  def message_lines(); end
-  PENDING_DETAIL_FORMATTER = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Core::Formatters::ExceptionPresenter::Factory
-  def build(); end
-
-  def initialize(example); end
-end
-
-class RSpec::Core::Formatters::ExceptionPresenter::Factory::CommonBacktraceTruncater
-  def initialize(parent); end
-
-  def with_truncated_backtrace(child); end
-end
-
-class RSpec::Core::Formatters::ExceptionPresenter::Factory::CommonBacktraceTruncater
-end
-
-module RSpec::Core::Formatters::ExceptionPresenter::Factory::EmptyBacktraceFormatter
-end
-
-module RSpec::Core::Formatters::ExceptionPresenter::Factory::EmptyBacktraceFormatter
-  def self.format_backtrace(*arg); end
-end
-
-class RSpec::Core::Formatters::ExceptionPresenter::Factory
-end
-
-class RSpec::Core::Formatters::ExceptionPresenter
-end
-
-class RSpec::Core::Formatters::FailureListFormatter
-  def dump_profile(_profile); end
-
-  def example_failed(failure); end
-
-  def message(_message); end
-end
-
-class RSpec::Core::Formatters::FailureListFormatter
-end
-
-class RSpec::Core::Formatters::FallbackMessageFormatter
-  def initialize(output); end
-
-  def message(notification); end
-
-  def output(); end
-end
-
-class RSpec::Core::Formatters::FallbackMessageFormatter
-end
-
-module RSpec::Core::Formatters::Helpers
-  DEFAULT_PRECISION = ::T.let(nil, ::T.untyped)
-  SUB_SECOND_PRECISION = ::T.let(nil, ::T.untyped)
-end
-
-module RSpec::Core::Formatters::Helpers
-  def self.format_duration(duration); end
-
-  def self.format_seconds(float, precision=T.unsafe(nil)); end
-
-  def self.organize_ids(ids); end
-
-  def self.pluralize(count, string); end
-end
-
-class RSpec::Core::Formatters::HtmlFormatter
-  def dump_summary(summary); end
-
-  def example_failed(failure); end
-
-  def example_passed(passed); end
-
-  def example_pending(pending); end
-
-  def example_started(_notification); end
-
-  def start_dump(_notification); end
-end
-
-class RSpec::Core::Formatters::HtmlFormatter
-end
-
-class RSpec::Core::Formatters::HtmlPrinter
-  include ::ERB::Util
-  def flush(); end
-
-  def initialize(output); end
-
-  def make_example_group_header_red(group_id); end
-
-  def make_example_group_header_yellow(group_id); end
-
-  def make_header_red(); end
-
-  def make_header_yellow(); end
-
-  def move_progress(percent_done); end
-
-  def print_example_failed(pending_fixed, description, run_time, failure_id, exception, extra_content); end
-
-  def print_example_group_end(); end
-
-  def print_example_group_start(group_id, description, number_of_parents); end
-
-  def print_example_passed(description, run_time); end
-
-  def print_example_pending(description, pending_message); end
-
-  def print_html_start(); end
-
-  def print_summary(duration, example_count, failure_count, pending_count); end
-  GLOBAL_SCRIPTS = ::T.let(nil, ::T.untyped)
-  GLOBAL_STYLES = ::T.let(nil, ::T.untyped)
-  HTML_HEADER = ::T.let(nil, ::T.untyped)
-  REPORT_HEADER = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Core::Formatters::HtmlPrinter
-end
-
-class RSpec::Core::Formatters::JsonFormatter
-  def dump_profile(profile); end
-
-  def dump_profile_slowest_example_groups(profile); end
-
-  def dump_profile_slowest_examples(profile); end
-
-  def dump_summary(summary); end
-
-  def message(notification); end
-
-  def output_hash(); end
-
-  def seed(notification); end
-
-  def stop(notification); end
-end
-
-class RSpec::Core::Formatters::JsonFormatter
-end
-
-class RSpec::Core::Formatters::Loader
-  def add(formatter_to_use, *paths); end
-
-  def default_formatter(); end
-
-  def default_formatter=(default_formatter); end
-
-  def formatters(); end
-
-  def initialize(reporter); end
-
-  def prepare_default(output_stream, deprecation_stream); end
-
-  def reporter(); end
-
-  def setup_default(output_stream, deprecation_stream); end
-end
-
-class RSpec::Core::Formatters::Loader
-  def self.formatters(); end
-end
-
-class RSpec::Core::Formatters::ProfileFormatter
-  def dump_profile(profile); end
-
-  def initialize(output); end
-
-  def output(); end
-end
-
-class RSpec::Core::Formatters::ProfileFormatter
-end
-
-class RSpec::Core::Formatters::ProgressFormatter
-  def example_failed(_notification); end
-
-  def example_passed(_notification); end
-
-  def example_pending(_notification); end
-
-  def start_dump(_notification); end
-end
-
-class RSpec::Core::Formatters::ProgressFormatter
-end
-
-class RSpec::Core::Formatters::SnippetExtractor
-  def beginning_line_number(); end
-
-  def expression_lines(); end
-
-  def initialize(source, beginning_line_number, max_line_count=T.unsafe(nil)); end
-
-  def max_line_count(); end
-
-  def source(); end
-end
-
-class RSpec::Core::Formatters::SnippetExtractor::NoExpressionAtLineError
-end
-
-class RSpec::Core::Formatters::SnippetExtractor::NoExpressionAtLineError
-end
-
-class RSpec::Core::Formatters::SnippetExtractor::NoSuchFileError
-end
-
-class RSpec::Core::Formatters::SnippetExtractor::NoSuchFileError
-end
-
-class RSpec::Core::Formatters::SnippetExtractor::NoSuchLineError
-end
-
-class RSpec::Core::Formatters::SnippetExtractor::NoSuchLineError
-end
-
-class RSpec::Core::Formatters::SnippetExtractor
-  def self.extract_expression_lines_at(file_path, beginning_line_number, max_line_count=T.unsafe(nil)); end
-
-  def self.extract_line_at(file_path, line_number); end
-
-  def self.least_indentation_from(lines); end
-
-  def self.source_from_file(path); end
-end
-
-class RSpec::Core::Formatters::SyntaxHighlighter
-  def highlight(lines); end
-
-  def initialize(configuration); end
-end
-
-module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation
-  RESET_CODE = ::T.let(nil, ::T.untyped)
-end
-
-module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation
-  def self.highlight_syntax(lines); end
-end
-
-module RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
-end
-
-module RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
-  def self.highlight_syntax(lines); end
-end
-
-RSpec::Core::Formatters::SyntaxHighlighter::WindowsImplementation = RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
-
-class RSpec::Core::Formatters::SyntaxHighlighter
-  def self.attempt_to_add_rspec_terms_to_coderay_keywords(); end
-end
-
-module RSpec::Core::Formatters
-  def self.register(formatter_class, *notifications); end
 end
 
 module RSpec::Core::HashImitatable
-  def <(*args, &block); end
-
-  def <=(*args, &block); end
-
-  def >(*args, &block); end
-
-  def >=(*args, &block); end
-
-  def [](key); end
-
-  def []=(key, value); end
-
-  def all?(*args, &block); end
-
-  def any?(*args, &block); end
-
   def assert_valid_keys(*args, &block); end
 
-  def assoc(*args, &block); end
-
-  def chain(*args, &block); end
-
-  def chunk(*args, &block); end
-
-  def chunk_while(*args, &block); end
-
-  def clear(*args, &block); end
-
-  def collect(*args, &block); end
-
-  def collect_concat(*args, &block); end
-
-  def compact(*args, &block); end
-
-  def compact!(*args, &block); end
-
   def compact_blank(*args, &block); end
 
   def compact_blank!(*args, &block); end
 
-  def compare_by_identity(*args, &block); end
-
-  def compare_by_identity?(*args, &block); end
-
-  def count(*args, &block); end
-
-  def cycle(*args, &block); end
-
-  def deep_merge(*args, &block); end
-
-  def deep_merge!(*args, &block); end
-
   def deep_stringify_keys(*args, &block); end
 
   def deep_stringify_keys!(*args, &block); end
@@ -20915,568 +7103,37 @@ module RSpec::Core::HashImitatable
 
   def deep_transform_keys!(*args, &block); end
 
-  def default(*args, &block); end
-
-  def default=(*args, &block); end
-
-  def default_proc(*args, &block); end
-
-  def default_proc=(*args, &block); end
-
-  def delete(*args, &block); end
-
-  def delete_if(*args, &block); end
-
-  def detect(*args, &block); end
-
-  def dig(*args, &block); end
-
-  def drop(*args, &block); end
-
-  def drop_while(*args, &block); end
-
-  def each(*args, &block); end
-
-  def each_cons(*args, &block); end
-
-  def each_entry(*args, &block); end
-
-  def each_key(*args, &block); end
-
-  def each_pair(*args, &block); end
-
-  def each_slice(*args, &block); end
-
-  def each_value(*args, &block); end
-
-  def each_with_index(*args, &block); end
-
-  def each_with_object(*args, &block); end
-
-  def empty?(*args, &block); end
-
-  def entries(*args, &block); end
-
-  def except(*args, &block); end
-
-  def except!(*args, &block); end
-
   def exclude?(*args, &block); end
 
   def excluding(*args, &block); end
 
-  def extract!(*args, &block); end
-
   def extractable_options?(*args, &block); end
 
-  def fetch(*args, &block); end
-
-  def fetch_values(*args, &block); end
-
-  def filter(*args, &block); end
-
-  def filter!(*args, &block); end
-
-  def find(*args, &block); end
-
-  def find_all(*args, &block); end
-
-  def find_index(*args, &block); end
-
-  def first(*args, &block); end
-
-  def flat_map(*args, &block); end
-
-  def flatten(*args, &block); end
-
-  def grep(*args, &block); end
-
-  def grep_v(*args, &block); end
-
-  def group_by(*args, &block); end
-
-  def has_key?(*args, &block); end
-
-  def has_value?(*args, &block); end
-
-  def include?(*args, &block); end
-
   def including(*args, &block); end
 
-  def index(*args, &block); end
-
   def index_by(*args, &block); end
 
   def index_with(*args, &block); end
 
-  def inject(*args, &block); end
-
-  def invert(*args, &block); end
-
-  def keep_if(*args, &block); end
-
-  def key(*args, &block); end
-
-  def key?(*args, &block); end
-
-  def keys(*args, &block); end
-
-  def lazy(*args, &block); end
-
-  def length(*args, &block); end
-
   def many?(*args, &block); end
 
-  def map(*args, &block); end
-
-  def max(*args, &block); end
-
-  def max_by(*args, &block); end
-
-  def member?(*args, &block); end
-
-  def merge(*args, &block); end
-
-  def merge!(*args, &block); end
-
-  def min(*args, &block); end
-
-  def min_by(*args, &block); end
-
-  def minmax(*args, &block); end
-
-  def minmax_by(*args, &block); end
-
-  def none?(*args, &block); end
-
-  def one?(*args, &block); end
-
-  def partition(*args, &block); end
-
   def pick(*args, &block); end
 
   def pluck(*args, &block); end
 
-  def rassoc(*args, &block); end
-
-  def reduce(*args, &block); end
-
-  def rehash(*args, &block); end
-
-  def reject(*args, &block); end
-
-  def reject!(*args, &block); end
-
-  def replace(*args, &block); end
-
-  def reverse_each(*args, &block); end
-
-  def save_plist(*args, &block); end
-
-  def select(*args, &block); end
-
-  def select!(*args, &block); end
-
-  def shift(*args, &block); end
-
-  def size(*args, &block); end
-
-  def slice(*args, &block); end
-
-  def slice!(*args, &block); end
-
-  def slice_after(*args, &block); end
-
-  def slice_before(*args, &block); end
-
-  def slice_when(*args, &block); end
-
-  def sort(*args, &block); end
-
-  def sort_by(*args, &block); end
-
-  def store(*args, &block); end
-
   def stringify_keys(*args, &block); end
 
   def stringify_keys!(*args, &block); end
 
-  def sum(*args, &block); end
-
   def symbolize_keys(*args, &block); end
 
   def symbolize_keys!(*args, &block); end
 
-  def take(*args, &block); end
-
-  def take_while(*args, &block); end
-
-  def to_a(*args, &block); end
-
-  def to_h(); end
-
-  def to_hash(*args, &block); end
-
-  def to_msgpack(*args, &block); end
-
   def to_options(*args, &block); end
 
   def to_options!(*args, &block); end
 
-  def to_plist(*args, &block); end
-
-  def to_proc(*args, &block); end
-
-  def to_set(*args, &block); end
-
-  def transform_keys(*args, &block); end
-
-  def transform_keys!(*args, &block); end
-
-  def transform_values(*args, &block); end
-
-  def transform_values!(*args, &block); end
-
-  def uniq(*args, &block); end
-
-  def update(*args, &block); end
-
-  def value?(*args, &block); end
-
-  def values(*args, &block); end
-
-  def values_at(*args, &block); end
-
   def without(*args, &block); end
-
-  def zip(*args, &block); end
-end
-
-module RSpec::Core::HashImitatable::ClassMethods
-  def attr_accessor(*names); end
-
-  def hash_attribute_names(); end
-end
-
-module RSpec::Core::HashImitatable::ClassMethods
-end
-
-module RSpec::Core::HashImitatable
-  def self.included(klass); end
-end
-
-module RSpec::Core::Hooks
-  def after(*args, &block); end
-
-  def append_after(*args, &block); end
-
-  def append_before(*args, &block); end
-
-  def around(*args, &block); end
-
-  def before(*args, &block); end
-
-  def hooks(); end
-
-  def prepend_after(*args, &block); end
-
-  def prepend_before(*args, &block); end
-end
-
-class RSpec::Core::Hooks::AfterContextHook
-  def run(example); end
-end
-
-class RSpec::Core::Hooks::AfterContextHook
-end
-
-class RSpec::Core::Hooks::AfterHook
-  def run(example); end
-end
-
-class RSpec::Core::Hooks::AfterHook
-end
-
-class RSpec::Core::Hooks::AroundHook
-  def execute_with(example, procsy); end
-
-  def hook_description(); end
-end
-
-class RSpec::Core::Hooks::AroundHook
-end
-
-class RSpec::Core::Hooks::BeforeHook
-  def run(example); end
-end
-
-class RSpec::Core::Hooks::BeforeHook
-end
-
-class RSpec::Core::Hooks::Hook
-  def block(); end
-
-  def block=(_); end
-
-  def options(); end
-
-  def options=(_); end
-end
-
-class RSpec::Core::Hooks::Hook
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class RSpec::Core::Hooks::HookCollections
-  def all_hooks_for(position, scope); end
-
-  def initialize(owner, filterable_item_repo_class); end
-
-  def matching_hooks_for(position, scope, example_or_group); end
-
-  def processable_hooks_for(position, scope, host); end
-
-  def register(prepend_or_append, position, *args, &block); end
-
-  def register_global_singleton_context_hooks(example, globals); end
-
-  def register_globals(host, globals); end
-
-  def run(position, scope, example_or_group); end
-
-  def run_owned_hooks_for(position, scope, example_or_group); end
-  EMPTY_HOOK_ARRAY = ::T.let(nil, ::T.untyped)
-  HOOK_TYPES = ::T.let(nil, ::T.untyped)
-  SCOPES = ::T.let(nil, ::T.untyped)
-  SCOPE_ALIASES = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Core::Hooks::HookCollections
-end
-
-module RSpec::Core::Hooks
-end
-
-class RSpec::Core::InclusionRules
-  def add(*args); end
-
-  def add_with_low_priority(*args); end
-
-  def split_file_scoped_rules(); end
-
-  def standalone?(); end
-end
-
-class RSpec::Core::InclusionRules
-end
-
-module RSpec::Core::Invocations
-end
-
-class RSpec::Core::Invocations::Bisect
-  def call(options, err, out); end
-end
-
-class RSpec::Core::Invocations::Bisect
-end
-
-class RSpec::Core::Invocations::DRbWithFallback
-  def call(options, err, out); end
-end
-
-class RSpec::Core::Invocations::DRbWithFallback
-end
-
-class RSpec::Core::Invocations::InitializeProject
-  def call(*_args); end
-end
-
-class RSpec::Core::Invocations::InitializeProject
-end
-
-class RSpec::Core::Invocations::PrintHelp
-  def call(_options, _err, out); end
-
-  def hidden_options(); end
-
-  def hidden_options=(_); end
-
-  def parser(); end
-
-  def parser=(_); end
-end
-
-class RSpec::Core::Invocations::PrintHelp
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class RSpec::Core::Invocations::PrintVersion
-  def call(_options, _err, out); end
-end
-
-class RSpec::Core::Invocations::PrintVersion
-end
-
-module RSpec::Core::Invocations
-end
-
-class RSpec::Core::LegacyExampleGroupHash
-  include ::RSpec::Core::HashImitatable
-  def initialize(metadata); end
-end
-
-class RSpec::Core::LegacyExampleGroupHash
-  extend ::RSpec::Core::HashImitatable::ClassMethods
-end
-
-module RSpec::Core::MemoizedHelpers
-  def initialize(*arg); end
-
-  def is_expected(); end
-
-  def should(matcher=T.unsafe(nil), message=T.unsafe(nil)); end
-
-  def should_not(matcher=T.unsafe(nil), message=T.unsafe(nil)); end
-
-  def subject(); end
-end
-
-module RSpec::Core::MemoizedHelpers::ClassMethods
-  def let(name, &block); end
-
-  def let!(name, &block); end
-
-  def subject(name=T.unsafe(nil), &block); end
-
-  def subject!(name=T.unsafe(nil), &block); end
-end
-
-module RSpec::Core::MemoizedHelpers::ClassMethods
-end
-
-class RSpec::Core::MemoizedHelpers::ContextHookMemoized
-end
-
-class RSpec::Core::MemoizedHelpers::ContextHookMemoized::After
-end
-
-class RSpec::Core::MemoizedHelpers::ContextHookMemoized::After
-  def self.article(); end
-
-  def self.hook_expression(); end
-
-  def self.hook_intention(); end
-end
-
-class RSpec::Core::MemoizedHelpers::ContextHookMemoized::Before
-end
-
-class RSpec::Core::MemoizedHelpers::ContextHookMemoized::Before
-  def self.article(); end
-
-  def self.hook_expression(); end
-
-  def self.hook_intention(); end
-end
-
-class RSpec::Core::MemoizedHelpers::ContextHookMemoized
-  def self.fetch_or_store(key, &_block); end
-
-  def self.isolate_for_context_hook(example_group_instance); end
-end
-
-class RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized
-  def fetch_or_store(key); end
-end
-
-class RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized
-end
-
-class RSpec::Core::MemoizedHelpers::ThreadsafeMemoized
-  def fetch_or_store(key); end
-end
-
-class RSpec::Core::MemoizedHelpers::ThreadsafeMemoized
-end
-
-module RSpec::Core::MemoizedHelpers
-  def self.define_helpers_on(example_group); end
-
-  def self.get_constant_or_yield(example_group, name); end
-
-  def self.module_for(example_group); end
-end
-
-module RSpec::Core::Metadata
-  RESERVED_KEYS = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Core::Metadata::ExampleGroupHash
-end
-
-class RSpec::Core::Metadata::ExampleGroupHash
-  def self.backwards_compatibility_default_proc(&example_group_selector); end
-
-  def self.create(parent_group_metadata, user_metadata, example_group_index, *args, &block); end
-
-  def self.hash_with_backwards_compatibility_default_proc(); end
-end
-
-class RSpec::Core::Metadata::ExampleHash
-end
-
-class RSpec::Core::Metadata::ExampleHash
-  def self.create(group_metadata, user_metadata, index_provider, description, block); end
-end
-
-class RSpec::Core::Metadata::HashPopulator
-  def block(); end
-
-  def description_args(); end
-
-  def initialize(metadata, user_metadata, index_provider, description_args, block); end
-
-  def metadata(); end
-
-  def populate(); end
-
-  def user_metadata(); end
-end
-
-class RSpec::Core::Metadata::HashPopulator
-end
-
-module RSpec::Core::Metadata
-  def self.ascend(metadata); end
-
-  def self.ascending(metadata); end
-
-  def self.build_hash_from(args, warn_about_example_group_filtering=T.unsafe(nil)); end
-
-  def self.deep_hash_dup(object); end
-
-  def self.id_from(metadata); end
-
-  def self.location_tuple_from(metadata); end
-
-  def self.relative_path(line); end
-
-  def self.relative_path_regex(); end
-end
-
-module RSpec::Core::MetadataFilter
-end
-
-module RSpec::Core::MetadataFilter
-  def self.apply?(predicate, filters, metadata); end
-
-  def self.filter_applies?(key, filter_value, metadata); end
-
-  def self.silence_metadata_example_group_deprecations(); end
 end
 
 module RSpec::Core::MockingAdapters
@@ -21502,5050 +7159,12 @@ end
 module RSpec::Core::MockingAdapters
 end
 
-class RSpec::Core::MultipleExceptionError
-  include ::RSpec::Core::MultipleExceptionError::InterfaceTag
-  def aggregation_block_label(); end
-
-  def aggregation_metadata(); end
-
-  def all_exceptions(); end
-
-  def exception_count_description(); end
-
-  def failures(); end
-
-  def initialize(*exceptions); end
-
-  def other_errors(); end
-
-  def summary(); end
-end
-
-module RSpec::Core::MultipleExceptionError::InterfaceTag
-  def add(exception); end
-end
-
-module RSpec::Core::MultipleExceptionError::InterfaceTag
-  def self.for(ex); end
-end
-
-class RSpec::Core::MultipleExceptionError
-end
-
-module RSpec::Core::Notifications
-end
-
-class RSpec::Core::Notifications::CustomNotification
-end
-
-class RSpec::Core::Notifications::CustomNotification
-  def self.for(options=T.unsafe(nil)); end
-end
-
-class RSpec::Core::Notifications::DeprecationNotification
-  def call_site(); end
-
-  def call_site=(_); end
-
-  def deprecated(); end
-
-  def deprecated=(_); end
-
-  def message(); end
-
-  def message=(_); end
-
-  def replacement(); end
-
-  def replacement=(_); end
-end
-
-class RSpec::Core::Notifications::DeprecationNotification
-  def self.[](*arg); end
-
-  def self.from_hash(data); end
-
-  def self.members(); end
-end
-
-class RSpec::Core::Notifications::ExampleNotification
-  def example(); end
-
-  def example=(_); end
-end
-
-class RSpec::Core::Notifications::ExampleNotification
-  def self.[](*arg); end
-
-  def self.for(example); end
-
-  def self.members(); end
-end
-
-class RSpec::Core::Notifications::ExamplesNotification
-  def examples(); end
-
-  def failed_examples(); end
-
-  def failure_notifications(); end
-
-  def fully_formatted_failed_examples(colorizer=T.unsafe(nil)); end
-
-  def fully_formatted_pending_examples(colorizer=T.unsafe(nil)); end
-
-  def initialize(reporter); end
-
-  def notifications(); end
-
-  def pending_examples(); end
-
-  def pending_notifications(); end
-end
-
-class RSpec::Core::Notifications::ExamplesNotification
-end
-
-class RSpec::Core::Notifications::FailedExampleNotification
-  def colorized_formatted_backtrace(colorizer=T.unsafe(nil)); end
-
-  def colorized_message_lines(colorizer=T.unsafe(nil)); end
-
-  def description(); end
-
-  def exception(); end
-
-  def formatted_backtrace(); end
-
-  def fully_formatted(failure_number, colorizer=T.unsafe(nil)); end
-
-  def fully_formatted_lines(failure_number, colorizer=T.unsafe(nil)); end
-
-  def initialize(example, exception_presenter=T.unsafe(nil)); end
-
-  def message_lines(); end
-end
-
-class RSpec::Core::Notifications::FailedExampleNotification
-end
-
-class RSpec::Core::Notifications::GroupNotification
-  def group(); end
-
-  def group=(_); end
-end
-
-class RSpec::Core::Notifications::GroupNotification
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class RSpec::Core::Notifications::MessageNotification
-  def message(); end
-
-  def message=(_); end
-end
-
-class RSpec::Core::Notifications::MessageNotification
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-module RSpec::Core::Notifications::NullColorizer
-end
-
-module RSpec::Core::Notifications::NullColorizer
-  def self.wrap(line, _code_or_symbol); end
-end
-
-class RSpec::Core::Notifications::NullNotification
-end
-
-class RSpec::Core::Notifications::NullNotification
-end
-
-class RSpec::Core::Notifications::PendingExampleFailedAsExpectedNotification
-end
-
-class RSpec::Core::Notifications::PendingExampleFailedAsExpectedNotification
-end
-
-class RSpec::Core::Notifications::PendingExampleFixedNotification
-end
-
-class RSpec::Core::Notifications::PendingExampleFixedNotification
-end
-
-class RSpec::Core::Notifications::ProfileNotification
-  def duration(); end
-
-  def examples(); end
-
-  def initialize(duration, examples, number_of_examples, example_groups); end
-
-  def number_of_examples(); end
-
-  def percentage(); end
-
-  def slow_duration(); end
-
-  def slowest_examples(); end
-
-  def slowest_groups(); end
-end
-
-class RSpec::Core::Notifications::ProfileNotification
-end
-
-class RSpec::Core::Notifications::SeedNotification
-  def fully_formatted(); end
-
-  def seed(); end
-
-  def seed=(_); end
-
-  def seed_used?(); end
-
-  def used=(_); end
-end
-
-class RSpec::Core::Notifications::SeedNotification
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class RSpec::Core::Notifications::SkippedExampleNotification
-  def fully_formatted(pending_number, colorizer=T.unsafe(nil)); end
-end
-
-class RSpec::Core::Notifications::SkippedExampleNotification
-end
-
-class RSpec::Core::Notifications::StartNotification
-  def count(); end
-
-  def count=(_); end
-
-  def load_time(); end
-
-  def load_time=(_); end
-end
-
-class RSpec::Core::Notifications::StartNotification
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class RSpec::Core::Notifications::SummaryNotification
-  include ::RSpec::Core::ShellEscape
-  def colorized_rerun_commands(colorizer=T.unsafe(nil)); end
-
-  def colorized_totals_line(colorizer=T.unsafe(nil)); end
-
-  def duration(); end
-
-  def duration=(_); end
-
-  def errors_outside_of_examples_count(); end
-
-  def errors_outside_of_examples_count=(_); end
-
-  def example_count(); end
-
-  def examples(); end
-
-  def examples=(_); end
-
-  def failed_examples(); end
-
-  def failed_examples=(_); end
-
-  def failure_count(); end
-
-  def formatted_duration(); end
-
-  def formatted_load_time(); end
-
-  def fully_formatted(colorizer=T.unsafe(nil)); end
-
-  def load_time(); end
-
-  def load_time=(_); end
-
-  def pending_count(); end
-
-  def pending_examples(); end
-
-  def pending_examples=(_); end
-
-  def totals_line(); end
-end
-
-class RSpec::Core::Notifications::SummaryNotification
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-module RSpec::Core::Notifications
-end
-
-class RSpec::Core::NullReporter
-end
-
-class RSpec::Core::NullReporter
-end
-
-module RSpec::Core::Ordering
-end
-
-class RSpec::Core::Ordering::ConfigurationManager
-  def force(hash); end
-
-  def order=(type); end
-
-  def ordering_registry(); end
-
-  def register_ordering(name, strategy=T.unsafe(nil)); end
-
-  def seed(); end
-
-  def seed=(seed); end
-
-  def seed_used?(); end
-end
-
-class RSpec::Core::Ordering::ConfigurationManager
-end
-
-class RSpec::Core::Ordering::Custom
-  def initialize(callable); end
-
-  def order(list); end
-end
-
-class RSpec::Core::Ordering::Custom
-end
-
-class RSpec::Core::Ordering::Identity
-  def order(items); end
-end
-
-class RSpec::Core::Ordering::Identity
-end
-
-class RSpec::Core::Ordering::Random
-  def initialize(configuration); end
-
-  def order(items); end
-
-  def used?(); end
-  MAX_32_BIT = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Core::Ordering::Random
-end
-
-class RSpec::Core::Ordering::Registry
-  def fetch(name, &fallback); end
-
-  def initialize(configuration); end
-
-  def register(sym, strategy); end
-
-  def used_random_seed?(); end
-end
-
-class RSpec::Core::Ordering::Registry
-end
-
-module RSpec::Core::Ordering
-end
-
 class RSpec::Core::OutputWrapper
-  def <<(*args, &block); end
-
-  def advise(*args, &block); end
-
   def as_json(*args, &block); end
-
-  def autoclose=(*args, &block); end
-
-  def autoclose?(*args, &block); end
-
-  def beep(*args, &block); end
-
-  def binmode(*args, &block); end
-
-  def binmode?(*args, &block); end
-
-  def bytes(*args, &block); end
-
-  def chars(*args, &block); end
-
-  def close(*args, &block); end
-
-  def close_on_exec=(*args, &block); end
-
-  def close_on_exec?(*args, &block); end
-
-  def close_read(*args, &block); end
-
-  def close_write(*args, &block); end
-
-  def closed?(*args, &block); end
-
-  def codepoints(*args, &block); end
-
-  def cooked(*args, &block); end
-
-  def cooked!(*args, &block); end
-
-  def cursor(*args, &block); end
-
-  def cursor=(*args, &block); end
-
-  def each(*args, &block); end
-
-  def each_byte(*args, &block); end
-
-  def each_char(*args, &block); end
-
-  def each_codepoint(*args, &block); end
-
-  def each_line(*args, &block); end
-
-  def echo=(*args, &block); end
-
-  def echo?(*args, &block); end
-
-  def eof(*args, &block); end
-
-  def eof?(*args, &block); end
-
-  def external_encoding(*args, &block); end
-
-  def fcntl(*args, &block); end
-
-  def fdatasync(*args, &block); end
-
-  def fileno(*args, &block); end
-
-  def flush(*args, &block); end
-
-  def fsync(*args, &block); end
-
-  def getbyte(*args, &block); end
-
-  def getc(*args, &block); end
-
-  def getch(*args, &block); end
-
-  def getpass(*args, &block); end
-
-  def gets(*args, &block); end
-
-  def goto(*args, &block); end
-
-  def iflush(*args, &block); end
-
-  def initialize(output); end
-
-  def inspect(*args, &block); end
-
-  def internal_encoding(*args, &block); end
-
-  def ioctl(*args, &block); end
-
-  def ioflush(*args, &block); end
-
-  def isatty(*args, &block); end
-
-  def lineno(*args, &block); end
-
-  def lineno=(*args, &block); end
-
-  def lines(*args, &block); end
-
-  def method_missing(name, *args, &block); end
-
-  def noecho(*args, &block); end
-
-  def nonblock(*args, &block); end
-
-  def nonblock=(*args, &block); end
-
-  def nonblock?(*args, &block); end
-
-  def nread(*args, &block); end
-
-  def oflush(*args, &block); end
-
-  def output(); end
-
-  def output=(output); end
-
-  def pathconf(*args, &block); end
-
-  def pid(*args, &block); end
-
-  def pos(*args, &block); end
-
-  def pos=(*args, &block); end
-
-  def pread(*args, &block); end
-
-  def pressed?(*args, &block); end
-
-  def print(*args, &block); end
-
-  def printf(*args, &block); end
-
-  def putc(*args, &block); end
-
-  def puts(*args, &block); end
-
-  def pwrite(*args, &block); end
-
-  def raw(*args, &block); end
-
-  def raw!(*args, &block); end
-
-  def read(*args, &block); end
-
-  def read_nonblock(*args, &block); end
-
-  def readbyte(*args, &block); end
-
-  def readchar(*args, &block); end
-
-  def readline(*args, &block); end
-
-  def readlines(*args, &block); end
-
-  def readpartial(*args, &block); end
-
-  def ready?(*args, &block); end
-
-  def reopen(*args, &block); end
-
-  def respond_to?(name, priv=T.unsafe(nil)); end
-
-  def rewind(*args, &block); end
-
-  def seek(*args, &block); end
-
-  def set_encoding(*args, &block); end
-
-  def stat(*args, &block); end
-
-  def sync(*args, &block); end
-
-  def sync=(*args, &block); end
-
-  def sysread(*args, &block); end
-
-  def sysseek(*args, &block); end
-
-  def syswrite(*args, &block); end
-
-  def tell(*args, &block); end
-
-  def to_i(*args, &block); end
-
-  def to_io(*args, &block); end
-
-  def tty?(*args, &block); end
-
-  def ungetbyte(*args, &block); end
-
-  def ungetc(*args, &block); end
-
-  def wait(*args, &block); end
-
-  def wait_readable(*args, &block); end
-
-  def wait_writable(*args, &block); end
-
-  def winsize(*args, &block); end
-
-  def winsize=(*args, &block); end
-
-  def write(*args, &block); end
-
-  def write_nonblock(*args, &block); end
-end
-
-class RSpec::Core::OutputWrapper
-end
-
-class RSpec::Core::Parser
-  def initialize(original_args); end
-
-  def original_args(); end
-
-  def parse(source=T.unsafe(nil)); end
-end
-
-class RSpec::Core::Parser
-  def self.parse(args, source=T.unsafe(nil)); end
-end
-
-module RSpec::Core::Pending
-  def pending(message=T.unsafe(nil)); end
-
-  def skip(message=T.unsafe(nil)); end
-  NOT_YET_IMPLEMENTED = ::T.let(nil, ::T.untyped)
-  NO_REASON_GIVEN = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Core::Pending::PendingExampleFixedError
-end
-
-class RSpec::Core::Pending::PendingExampleFixedError
-end
-
-class RSpec::Core::Pending::SkipDeclaredInExample
-  def argument(); end
-
-  def initialize(argument); end
-end
-
-class RSpec::Core::Pending::SkipDeclaredInExample
-end
-
-module RSpec::Core::Pending
-  def self.mark_fixed!(example); end
-
-  def self.mark_pending!(example, message_or_bool); end
-
-  def self.mark_skipped!(example, message_or_bool); end
-end
-
-class RSpec::Core::Profiler
-  def example_group_finished(notification); end
-
-  def example_group_started(notification); end
-
-  def example_groups(); end
-
-  def example_started(notification); end
-  NOTIFICATIONS = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Core::Profiler
-end
-
-class RSpec::Core::Reporter
-  def abort_with(msg, exit_status); end
-
-  def close_after(); end
-
-  def deprecation(hash); end
-
-  def example_failed(example); end
-
-  def example_finished(example); end
-
-  def example_group_finished(group); end
-
-  def example_group_started(group); end
-
-  def example_passed(example); end
-
-  def example_pending(example); end
-
-  def example_started(example); end
-
-  def examples(); end
-
-  def exit_early(exit_code); end
-
-  def fail_fast_limit_met?(); end
-
-  def failed_examples(); end
-
-  def finish(); end
-
-  def initialize(configuration); end
-
-  def message(message); end
-
-  def notify(event, notification); end
-
-  def notify_non_example_exception(exception, context_description); end
-
-  def pending_examples(); end
-
-  def prepare_default(loader, output_stream, deprecation_stream); end
-
-  def publish(event, options=T.unsafe(nil)); end
-
-  def register_listener(listener, *notifications); end
-
-  def registered_listeners(notification); end
-
-  def report(expected_example_count); end
-
-  def start(expected_example_count, time=T.unsafe(nil)); end
-
-  def stop(); end
-  RSPEC_NOTIFICATIONS = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Core::Reporter
-end
-
-module RSpec::Core::RubyProject
-end
-
-module RSpec::Core::RubyProject
-  def self.add_dir_to_load_path(dir); end
-
-  def self.add_to_load_path(*dirs); end
-
-  def self.ascend_until(); end
-
-  def self.determine_root(); end
-
-  def self.find_first_parent_containing(dir); end
-
-  def self.root(); end
-end
-
-class RSpec::Core::Runner
-  def configuration(); end
-
-  def configure(err, out); end
-
-  def exit_code(examples_passed=T.unsafe(nil)); end
-
-  def initialize(options, configuration=T.unsafe(nil), world=T.unsafe(nil)); end
-
-  def options(); end
-
-  def run(err, out); end
-
-  def run_specs(example_groups); end
-
-  def setup(err, out); end
-
-  def world(); end
-end
-
-class RSpec::Core::Runner
-  def self.autorun(); end
-
-  def self.autorun_disabled?(); end
-
-  def self.disable_autorun!(); end
-
-  def self.handle_interrupt(); end
-
-  def self.installed_at_exit?(); end
-
-  def self.invoke(); end
-
-  def self.perform_at_exit(); end
-
-  def self.run(args, err=T.unsafe(nil), out=T.unsafe(nil)); end
-
-  def self.running_in_drb?(); end
-
-  def self.trap_interrupt(); end
-end
-
-class RSpec::Core::Set
-  include ::Enumerable
-  def <<(key); end
-
-  def clear(); end
-
-  def delete(key); end
-
-  def each(&block); end
-
-  def empty?(); end
-
-  def include?(key); end
-
-  def initialize(array=T.unsafe(nil)); end
-
-  def merge(values); end
-end
-
-class RSpec::Core::Set
-end
-
-module RSpec::Core::SharedContext
-  include ::RSpec::Its
-  def __shared_context_recordings(); end
-
-  def after(*args, &block); end
-
-  def append_after(*args, &block); end
-
-  def append_before(*args, &block); end
-
-  def around(*args, &block); end
-
-  def before(*args, &block); end
-
-  def context(*args, &block); end
-
-  def describe(*args, &block); end
-
-  def hooks(*args, &block); end
-
-  def included(group); end
-
-  def let(*args, &block); end
-
-  def let!(*args, &block); end
-
-  def prepend_after(*args, &block); end
-
-  def prepend_before(*args, &block); end
-
-  def subject(*args, &block); end
-
-  def subject!(*args, &block); end
-end
-
-class RSpec::Core::SharedContext::Recording
-  def args(); end
-
-  def args=(_); end
-
-  def block(); end
-
-  def block=(_); end
-
-  def method_name(); end
-
-  def method_name=(_); end
-
-  def playback_onto(group); end
-end
-
-class RSpec::Core::SharedContext::Recording
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-module RSpec::Core::SharedContext
-  def self.record(methods); end
-end
-
-module RSpec::Core::SharedExampleGroup
-  def shared_context(name, *args, &block); end
-
-  def shared_examples(name, *args, &block); end
-
-  def shared_examples_for(name, *args, &block); end
-end
-
-class RSpec::Core::SharedExampleGroup::Registry
-  def add(context, name, *metadata_args, &block); end
-
-  def find(lookup_contexts, name); end
-end
-
-class RSpec::Core::SharedExampleGroup::Registry
-end
-
-module RSpec::Core::SharedExampleGroup::TopLevelDSL
-end
-
-module RSpec::Core::SharedExampleGroup::TopLevelDSL
-  def self.definitions(); end
-
-  def self.expose_globally!(); end
-
-  def self.exposed_globally?(); end
-
-  def self.remove_globally!(); end
-end
-
-module RSpec::Core::SharedExampleGroup
-end
-
-class RSpec::Core::SharedExampleGroupInclusionStackFrame
-  def description(); end
-
-  def formatted_inclusion_location(); end
-
-  def inclusion_location(); end
-
-  def initialize(shared_group_name, inclusion_location); end
-
-  def shared_group_name(); end
-end
-
-class RSpec::Core::SharedExampleGroupInclusionStackFrame
-  def self.current_backtrace(); end
-
-  def self.shared_example_group_inclusions(); end
-
-  def self.with_frame(name, location); end
-end
-
-class RSpec::Core::SharedExampleGroupModule
-  def definition(); end
-
-  def include_in(klass, inclusion_line, args, customization_block); end
-
-  def included(klass); end
-
-  def initialize(description, definition, metadata); end
-end
-
-class RSpec::Core::SharedExampleGroupModule
-end
-
-module RSpec::Core::ShellEscape
-  SHELLS_ALLOWING_UNQUOTED_IDS = ::T.let(nil, ::T.untyped)
-end
-
-module RSpec::Core::ShellEscape
-  def self.conditionally_quote(id); end
-
-  def self.escape(shell_command); end
-
-  def self.quote(argument); end
-
-  def self.shell_allows_unquoted_ids?(); end
-end
-
-class RSpec::Core::SuiteHookContext
-  def initialize(hook_description, reporter); end
-end
-
-class RSpec::Core::SuiteHookContext
-end
-
-class RSpec::Core::Time
-end
-
-class RSpec::Core::Time
-  def self.now(); end
-end
-
-module RSpec::Core::Version
-  STRING = ::T.let(nil, ::T.untyped)
-end
-
-module RSpec::Core::Version
-end
-
-module RSpec::Core::Warnings
-  def deprecate(deprecated, data=T.unsafe(nil)); end
-
-  def warn_deprecation(message, opts=T.unsafe(nil)); end
-
-  def warn_with(message, options=T.unsafe(nil)); end
-end
-
-module RSpec::Core::Warnings
-end
-
-class RSpec::Core::World
-  def all_example_groups(); end
-
-  def all_examples(); end
-
-  def announce_exclusion_filter(announcements); end
-
-  def announce_filters(); end
-
-  def announce_inclusion_filter(announcements); end
-
-  def everything_filtered_message(); end
-
-  def example_count(groups=T.unsafe(nil)); end
-
-  def example_group_counts_by_spec_file(); end
-
-  def example_groups(); end
-
-  def exclusion_filter(); end
-
-  def filter_manager(); end
-
-  def filtered_examples(); end
-
-  def inclusion_filter(); end
-
-  def initialize(configuration=T.unsafe(nil)); end
-
-  def non_example_failure(); end
-
-  def non_example_failure=(non_example_failure); end
-
-  def num_example_groups_defined_in(file); end
-
-  def ordered_example_groups(); end
-
-  def preceding_declaration_line(absolute_file_name, filter_line); end
-
-  def prepare_example_filtering(); end
-
-  def record(example_group); end
-
-  def registered_example_group_files(); end
-
-  def report_filter_message(message); end
-
-  def reporter(); end
-
-  def reset(); end
-
-  def shared_example_group_registry(); end
-
-  def source_from_file(path); end
-
-  def syntax_highlighter(); end
-
-  def traverse_example_group_trees_until(&block); end
-
-  def wants_to_quit(); end
-
-  def wants_to_quit=(wants_to_quit); end
-end
-
-module RSpec::Core::World::Null
-end
-
-module RSpec::Core::World::Null
-  def self.all_example_groups(); end
-
-  def self.example_groups(); end
-
-  def self.non_example_failure(); end
-
-  def self.non_example_failure=(_); end
-
-  def self.registered_example_group_files(); end
-
-  def self.traverse_example_group_trees_until(); end
-end
-
-class RSpec::Core::World
-end
-
-module RSpec::Core
-  def self.path_to_executable(); end
-end
-
-module RSpec::ExampleGroups
-end
-
-module RSpec::ExampleGroups
-  extend ::RSpec::Support::RecursiveConstMethods
-  def self.assign_const(group); end
-
-  def self.base_name_for(group); end
-
-  def self.constant_scope_for(group); end
-
-  def self.disambiguate(name, const_scope); end
-
-  def self.remove_all_constants(); end
-end
-
-module RSpec::Expectations
-end
-
-class RSpec::Expectations::BlockExpectationTarget
-  def not_to(matcher, message=T.unsafe(nil), &block); end
-
-  def to(matcher, message=T.unsafe(nil), &block); end
-
-  def to_not(matcher, message=T.unsafe(nil), &block); end
-end
-
-class RSpec::Expectations::BlockExpectationTarget
-end
-
-class RSpec::Expectations::BlockSnippetExtractor
-  def body_content_lines(); end
-
-  def initialize(proc, method_name); end
-
-  def method_name(); end
-end
-
-class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError
-end
-
-class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError
-end
-
-class RSpec::Expectations::BlockSnippetExtractor::BlockLocator
-  def beginning_line_number(); end
-
-  def beginning_line_number=(_); end
-
-  def body_content_locations(); end
-
-  def method_call_location(); end
-
-  def method_name(); end
-
-  def method_name=(_); end
-
-  def source(); end
-
-  def source=(_); end
-end
-
-class RSpec::Expectations::BlockSnippetExtractor::BlockLocator
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor
-  def beginning_line_number(); end
-
-  def beginning_line_number=(_); end
-
-  def body_tokens(); end
-
-  def method_name(); end
-
-  def method_name=(_); end
-
-  def source(); end
-
-  def source=(_); end
-
-  def state(); end
-end
-
-class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class RSpec::Expectations::BlockSnippetExtractor::Error
-end
-
-class RSpec::Expectations::BlockSnippetExtractor::Error
-end
-
-class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError
-end
-
-class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError
-end
-
-class RSpec::Expectations::BlockSnippetExtractor
-  def self.try_extracting_single_line_body_of(proc, method_name); end
-end
-
-class RSpec::Expectations::Configuration
-  def add_should_and_should_not_to(*modules); end
-
-  def backtrace_formatter(); end
-
-  def backtrace_formatter=(backtrace_formatter); end
-
-  def color?(); end
-
-  def false_positives_handler(); end
-
-  def include_chain_clauses_in_custom_matcher_descriptions=(include_chain_clauses_in_custom_matcher_descriptions); end
-
-  def include_chain_clauses_in_custom_matcher_descriptions?(); end
-
-  def max_formatted_output_length=(length); end
-
-  def on_potential_false_positives(); end
-
-  def on_potential_false_positives=(behavior); end
-
-  def reset_syntaxes_to_default(); end
-
-  def strict_predicate_matchers(); end
-
-  def strict_predicate_matchers=(flag); end
-
-  def strict_predicate_matchers?(); end
-
-  def syntax(); end
-
-  def syntax=(values); end
-
-  def warn_about_potential_false_positives=(boolean); end
-
-  def warn_about_potential_false_positives?(); end
-  FALSE_POSITIVE_BEHAVIOURS = ::T.let(nil, ::T.untyped)
-end
-
-module RSpec::Expectations::Configuration::NullBacktraceFormatter
-end
-
-module RSpec::Expectations::Configuration::NullBacktraceFormatter
-  def self.format_backtrace(backtrace); end
-end
-
-class RSpec::Expectations::Configuration
-end
-
-module RSpec::Expectations::ExpectationHelper
-end
-
-module RSpec::Expectations::ExpectationHelper
-  def self.check_message(msg); end
-
-  def self.handle_failure(matcher, message, failure_message_method); end
-
-  def self.modern_matcher_from(matcher); end
-
-  def self.with_matcher(handler, matcher, message); end
-end
-
-class RSpec::Expectations::ExpectationNotMetError
-end
-
-class RSpec::Expectations::ExpectationNotMetError
-end
-
-class RSpec::Expectations::ExpectationTarget
-  include ::RSpec::Expectations::ExpectationTarget::InstanceMethods
-  def initialize(value); end
-
-  def target(); end
-end
-
-module RSpec::Expectations::ExpectationTarget::InstanceMethods
-  def not_to(matcher=T.unsafe(nil), message=T.unsafe(nil), &block); end
-
-  def to(matcher=T.unsafe(nil), message=T.unsafe(nil), &block); end
-
-  def to_not(matcher=T.unsafe(nil), message=T.unsafe(nil), &block); end
-end
-
-module RSpec::Expectations::ExpectationTarget::InstanceMethods
-end
-
-module RSpec::Expectations::ExpectationTarget::UndefinedValue
-end
-
-module RSpec::Expectations::ExpectationTarget::UndefinedValue
-end
-
-class RSpec::Expectations::ExpectationTarget
-  def self.for(value, block); end
-end
-
-class RSpec::Expectations::FailureAggregator
-  def aggregate(); end
-
-  def block_label(); end
-
-  def call(failure, options); end
-
-  def failures(); end
-
-  def initialize(block_label, metadata); end
-
-  def metadata(); end
-
-  def other_errors(); end
-end
-
-class RSpec::Expectations::FailureAggregator
-end
-
-RSpec::Expectations::LegacyMacherAdapter = RSpec::Expectations::LegacyMatcherAdapter
-
-class RSpec::Expectations::LegacyMatcherAdapter
-  def initialize(matcher); end
-end
-
-class RSpec::Expectations::LegacyMatcherAdapter::RSpec1
-  def failure_message(); end
-
-  def failure_message_when_negated(); end
-end
-
-class RSpec::Expectations::LegacyMatcherAdapter::RSpec1
-  def self.interface_matches?(matcher); end
-end
-
-class RSpec::Expectations::LegacyMatcherAdapter::RSpec2
-  def failure_message(); end
-
-  def failure_message_when_negated(); end
-end
-
-class RSpec::Expectations::LegacyMatcherAdapter::RSpec2
-  def self.interface_matches?(matcher); end
-end
-
-class RSpec::Expectations::LegacyMatcherAdapter
-  def self.wrap(matcher); end
 end
 
 class RSpec::Expectations::MultipleExpectationsNotMetError
   include ::RSpec::Core::MultipleExceptionError::InterfaceTag
-  def aggregation_block_label(); end
-
-  def aggregation_metadata(); end
-
-  def all_exceptions(); end
-
-  def exception_count_description(); end
-
-  def failures(); end
-
-  def initialize(failure_aggregator); end
-
-  def other_errors(); end
-
-  def summary(); end
-end
-
-class RSpec::Expectations::MultipleExpectationsNotMetError
-end
-
-class RSpec::Expectations::NegativeExpectationHandler
-end
-
-class RSpec::Expectations::NegativeExpectationHandler
-  def self.does_not_match?(matcher, actual, &block); end
-
-  def self.handle_matcher(actual, initial_matcher, custom_message=T.unsafe(nil), &block); end
-
-  def self.opposite_should_method(); end
-
-  def self.should_method(); end
-
-  def self.verb(); end
-end
-
-class RSpec::Expectations::PositiveExpectationHandler
-end
-
-class RSpec::Expectations::PositiveExpectationHandler
-  def self.handle_matcher(actual, initial_matcher, custom_message=T.unsafe(nil), &block); end
-
-  def self.opposite_should_method(); end
-
-  def self.should_method(); end
-
-  def self.verb(); end
-end
-
-module RSpec::Expectations::Syntax
-end
-
-module RSpec::Expectations::Syntax
-  def self.default_should_host(); end
-
-  def self.disable_expect(syntax_host=T.unsafe(nil)); end
-
-  def self.disable_should(syntax_host=T.unsafe(nil)); end
-
-  def self.enable_expect(syntax_host=T.unsafe(nil)); end
-
-  def self.enable_should(syntax_host=T.unsafe(nil)); end
-
-  def self.expect_enabled?(syntax_host=T.unsafe(nil)); end
-
-  def self.should_enabled?(syntax_host=T.unsafe(nil)); end
-
-  def self.warn_about_should!(); end
-
-  def self.warn_about_should_unless_configured(method_name); end
-end
-
-module RSpec::Expectations::Version
-  STRING = ::T.let(nil, ::T.untyped)
-end
-
-module RSpec::Expectations::Version
-end
-
-module RSpec::Expectations
-  def self.configuration(); end
-
-  def self.differ(); end
-
-  def self.fail_with(message, expected=T.unsafe(nil), actual=T.unsafe(nil)); end
-end
-
-module RSpec::Github
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Github::Formatter
-  def example_failed(failure); end
-
-  def example_pending(pending); end
-end
-
-class RSpec::Github::Formatter
-end
-
-class RSpec::Github::NotificationDecorator
-  def annotation(); end
-
-  def initialize(notification); end
-
-  def line(); end
-
-  def path(); end
-  ESCAPE_MAP = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Github::NotificationDecorator
-end
-
-module RSpec::Github
-end
-
-module RSpec::Its
-  def its(attribute, *options, &block); end
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
-module RSpec::Its
-end
-
-module RSpec::Matchers
-  def a_block_changing(*args, &block); end
-
-  def a_block_outputting(*args, &block); end
-
-  def a_block_raising(*args, &block); end
-
-  def a_block_throwing(*args, &block); end
-
-  def a_block_yielding_control(*args, &block); end
-
-  def a_block_yielding_successive_args(*args, &block); end
-
-  def a_block_yielding_with_args(*args, &block); end
-
-  def a_block_yielding_with_no_args(*args, &block); end
-
-  def a_collection_containing_exactly(*args, &block); end
-
-  def a_collection_ending_with(*args, &block); end
-
-  def a_collection_including(*args, &block); end
-
-  def a_collection_starting_with(*args, &block); end
-
-  def a_falsey_value(*args, &block); end
-
-  def a_falsy_value(*args, &block); end
-
-  def a_hash_including(*args, &block); end
-
-  def a_kind_of(*args, &block); end
-
-  def a_nil_value(*args, &block); end
-
-  def a_range_covering(*args, &block); end
-
-  def a_string_ending_with(*args, &block); end
-
-  def a_string_including(*args, &block); end
-
-  def a_string_matching(*args, &block); end
-
-  def a_string_starting_with(*args, &block); end
-
-  def a_truthy_value(*args, &block); end
-
-  def a_value(*args, &block); end
-
-  def a_value_between(*args, &block); end
-
-  def a_value_within(*args, &block); end
-
-  def aggregate_failures(label=T.unsafe(nil), metadata=T.unsafe(nil), &block); end
-
-  def all(expected); end
-
-  def an_instance_of(*args, &block); end
-
-  def an_object_eq_to(*args, &block); end
-
-  def an_object_eql_to(*args, &block); end
-
-  def an_object_equal_to(*args, &block); end
-
-  def an_object_existing(*args, &block); end
-
-  def an_object_having_attributes(*args, &block); end
-
-  def an_object_matching(*args, &block); end
-
-  def an_object_responding_to(*args, &block); end
-
-  def an_object_satisfying(*args, &block); end
-
-  def be(*args); end
-
-  def be_a(klass); end
-
-  def be_a_kind_of(expected); end
-
-  def be_an(klass); end
-
-  def be_an_instance_of(expected); end
-
-  def be_between(min, max); end
-
-  def be_falsey(); end
-
-  def be_falsy(*args, &block); end
-
-  def be_instance_of(expected); end
-
-  def be_kind_of(expected); end
-
-  def be_nil(); end
-
-  def be_truthy(); end
-
-  def be_within(delta); end
-
-  def change(receiver=T.unsafe(nil), message=T.unsafe(nil), &block); end
-
-  def changing(*args, &block); end
-
-  def contain_exactly(*items); end
-
-  def containing_exactly(*args, &block); end
-
-  def cover(*values); end
-
-  def covering(*args, &block); end
-
-  def end_with(*expected); end
-
-  def ending_with(*args, &block); end
-
-  def eq(expected); end
-
-  def eq_to(*args, &block); end
-
-  def eql(expected); end
-
-  def eql_to(*args, &block); end
-
-  def equal(expected); end
-
-  def equal_to(*args, &block); end
-
-  def exist(*args); end
-
-  def existing(*args, &block); end
-
-  def expect(value=T.unsafe(nil), &block); end
-
-  def have_attributes(expected); end
-
-  def having_attributes(*args, &block); end
-
-  def include(*expected); end
-
-  def including(*args, &block); end
-
-  def match(expected); end
-
-  def match_array(items); end
-
-  def match_regex(*args, &block); end
-
-  def matching(*args, &block); end
-
-  def output(expected=T.unsafe(nil)); end
-
-  def raise_error(error=T.unsafe(nil), message=T.unsafe(nil), &block); end
-
-  def raise_exception(error=T.unsafe(nil), message=T.unsafe(nil), &block); end
-
-  def raising(*args, &block); end
-
-  def respond_to(*names); end
-
-  def responding_to(*args, &block); end
-
-  def satisfy(description=T.unsafe(nil), &block); end
-
-  def satisfying(*args, &block); end
-
-  def start_with(*expected); end
-
-  def starting_with(*args, &block); end
-
-  def throw_symbol(expected_symbol=T.unsafe(nil), expected_arg=T.unsafe(nil)); end
-
-  def throwing(*args, &block); end
-
-  def within(*args, &block); end
-
-  def yield_control(); end
-
-  def yield_successive_args(*args); end
-
-  def yield_with_args(*args); end
-
-  def yield_with_no_args(); end
-
-  def yielding_control(*args, &block); end
-
-  def yielding_successive_args(*args, &block); end
-
-  def yielding_with_args(*args, &block); end
-
-  def yielding_with_no_args(*args, &block); end
-  BE_PREDICATE_REGEX = ::T.let(nil, ::T.untyped)
-  DYNAMIC_MATCHER_REGEX = ::T.let(nil, ::T.untyped)
-  HAS_REGEX = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Matchers::AliasedMatcher
-  def description(); end
-
-  def failure_message(); end
-
-  def failure_message_when_negated(); end
-
-  def initialize(base_matcher, description_block); end
-
-  def method_missing(*arg); end
-end
-
-class RSpec::Matchers::AliasedMatcher
-end
-
-class RSpec::Matchers::AliasedMatcherWithOperatorSupport
-end
-
-class RSpec::Matchers::AliasedMatcherWithOperatorSupport
-end
-
-class RSpec::Matchers::AliasedNegatedMatcher
-  def does_not_match?(*args, &block); end
-
-  def matches?(*args, &block); end
-end
-
-RSpec::Matchers::AliasedNegatedMatcher::DefaultFailureMessages = RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
-
-class RSpec::Matchers::AliasedNegatedMatcher
-end
-
-module RSpec::Matchers::BuiltIn
-end
-
-class RSpec::Matchers::BuiltIn::All
-  def does_not_match?(_actual); end
-
-  def failed_objects(); end
-
-  def initialize(matcher); end
-
-  def matcher(); end
-end
-
-class RSpec::Matchers::BuiltIn::All
-end
-
-class RSpec::Matchers::BuiltIn::BaseMatcher
-  include ::RSpec::Matchers::Composable
-  include ::RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
-  include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
-  def actual(); end
-
-  def actual_formatted(); end
-
-  def description(); end
-
-  def diffable?(); end
-
-  def expected(); end
-
-  def expected_formatted(); end
-
-  def expects_call_stack_jump?(); end
-
-  def initialize(expected=T.unsafe(nil)); end
-
-  def match_unless_raises(*exceptions); end
-
-  def matcher_name(); end
-
-  def matcher_name=(matcher_name); end
-
-  def matches?(actual); end
-
-  def present_ivars(); end
-
-  def rescued_exception(); end
-
-  def supports_block_expectations?(); end
-  UNDEFINED = ::T.let(nil, ::T.untyped)
-end
-
-module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
-  def failure_message(); end
-
-  def failure_message_when_negated(); end
-end
-
-module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
-  def self.has_default_failure_messages?(matcher); end
-end
-
-module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
-end
-
-module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
-  def self.improve_hash_formatting(inspect_string); end
-end
-
-class RSpec::Matchers::BuiltIn::BaseMatcher
-  def self.matcher_name(); end
-end
-
-class RSpec::Matchers::BuiltIn::Be
-  include ::RSpec::Matchers::BuiltIn::BeHelpers
-  def <(operand); end
-
-  def <=(operand); end
-
-  def ==(operand); end
-
-  def ===(operand); end
-
-  def =~(operand); end
-
-  def >(operand); end
-
-  def >=(operand); end
-
-  def initialize(*args); end
-end
-
-class RSpec::Matchers::BuiltIn::Be
-end
-
-class RSpec::Matchers::BuiltIn::BeAKindOf
-end
-
-class RSpec::Matchers::BuiltIn::BeAKindOf
-end
-
-class RSpec::Matchers::BuiltIn::BeAnInstanceOf
-end
-
-class RSpec::Matchers::BuiltIn::BeAnInstanceOf
-end
-
-class RSpec::Matchers::BuiltIn::BeBetween
-  def exclusive(); end
-
-  def inclusive(); end
-
-  def initialize(min, max); end
-end
-
-class RSpec::Matchers::BuiltIn::BeBetween
-end
-
-class RSpec::Matchers::BuiltIn::BeComparedTo
-  include ::RSpec::Matchers::BuiltIn::BeHelpers
-  def does_not_match?(actual); end
-
-  def initialize(operand, operator); end
-end
-
-class RSpec::Matchers::BuiltIn::BeComparedTo
-end
-
-class RSpec::Matchers::BuiltIn::BeFalsey
-end
-
-class RSpec::Matchers::BuiltIn::BeFalsey
-end
-
-module RSpec::Matchers::BuiltIn::BeHelpers
-end
-
-module RSpec::Matchers::BuiltIn::BeHelpers
-end
-
-class RSpec::Matchers::BuiltIn::BeNil
-end
-
-class RSpec::Matchers::BuiltIn::BeNil
-end
-
-class RSpec::Matchers::BuiltIn::BePredicate
-  REGEX = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Matchers::BuiltIn::BePredicate
-end
-
-class RSpec::Matchers::BuiltIn::BeTruthy
-end
-
-class RSpec::Matchers::BuiltIn::BeTruthy
-end
-
-class RSpec::Matchers::BuiltIn::BeWithin
-  def initialize(delta); end
-
-  def of(expected); end
-
-  def percent_of(expected); end
-end
-
-class RSpec::Matchers::BuiltIn::BeWithin
-end
-
-module RSpec::Matchers::BuiltIn::CaptureStderr
-end
-
-module RSpec::Matchers::BuiltIn::CaptureStderr
-  def self.capture(block); end
-end
-
-module RSpec::Matchers::BuiltIn::CaptureStdout
-end
-
-module RSpec::Matchers::BuiltIn::CaptureStdout
-  def self.capture(block); end
-end
-
-class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile
-  def capture(block); end
-end
-
-class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile
-end
-
-class RSpec::Matchers::BuiltIn::Change
-  def by(expected_delta); end
-
-  def by_at_least(minimum); end
-
-  def by_at_most(maximum); end
-
-  def does_not_match?(event_proc); end
-
-  def from(value); end
-
-  def initialize(receiver=T.unsafe(nil), message=T.unsafe(nil), &block); end
-
-  def matches?(event_proc); end
-
-  def to(value); end
-end
-
-class RSpec::Matchers::BuiltIn::Change
-end
-
-class RSpec::Matchers::BuiltIn::ChangeDetails
-  def actual_after(); end
-
-  def actual_delta(); end
-
-  def changed?(); end
-
-  def initialize(matcher_name, receiver=T.unsafe(nil), message=T.unsafe(nil), &block); end
-
-  def perform_change(event_proc); end
-
-  def value_representation(); end
-end
-
-class RSpec::Matchers::BuiltIn::ChangeDetails
-end
-
-class RSpec::Matchers::BuiltIn::ChangeFromValue
-  def does_not_match?(event_proc); end
-
-  def initialize(change_details, expected_before); end
-
-  def to(value); end
-end
-
-class RSpec::Matchers::BuiltIn::ChangeFromValue
-end
-
-class RSpec::Matchers::BuiltIn::ChangeRelatively
-  def does_not_match?(_event_proc); end
-
-  def initialize(change_details, expected_delta, relativity, &comparer); end
-
-  def matches?(event_proc); end
-end
-
-class RSpec::Matchers::BuiltIn::ChangeRelatively
-end
-
-class RSpec::Matchers::BuiltIn::ChangeToValue
-  def does_not_match?(_event_proc); end
-
-  def from(value); end
-
-  def initialize(change_details, expected_after); end
-end
-
-class RSpec::Matchers::BuiltIn::ChangeToValue
-end
-
-class RSpec::Matchers::BuiltIn::Compound
-  def diffable_matcher_list(); end
-
-  def does_not_match?(_actual); end
-
-  def evaluator(); end
-
-  def initialize(matcher_1, matcher_2); end
-
-  def matcher_1(); end
-
-  def matcher_2(); end
-end
-
-class RSpec::Matchers::BuiltIn::Compound::And
-end
-
-class RSpec::Matchers::BuiltIn::Compound::And
-end
-
-class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator
-  def initialize(actual, matcher_1, matcher_2); end
-
-  def matcher_matches?(matcher); end
-end
-
-class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator
-  def self.matcher_expects_call_stack_jump?(matcher); end
-end
-
-class RSpec::Matchers::BuiltIn::Compound::Or
-end
-
-class RSpec::Matchers::BuiltIn::Compound::Or
-end
-
-class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator
-  def initialize(actual, *arg); end
-
-  def matcher_matches?(matcher); end
-end
-
-class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator
-end
-
-class RSpec::Matchers::BuiltIn::Compound
-end
-
-class RSpec::Matchers::BuiltIn::ContainExactly
-end
-
-class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer
-  def actual_to_expected_matched_indexes(); end
-
-  def expected_to_actual_matched_indexes(); end
-
-  def find_best_solution(); end
-
-  def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes); end
-
-  def solution(); end
-end
-
-class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution
-end
-
-class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution
-  def self.worse_than?(_other); end
-end
-
-class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution
-  def +(derived_candidate_solution); end
-
-  def candidate?(); end
-
-  def ideal?(); end
-
-  def indeterminate_actual_indexes(); end
-
-  def indeterminate_actual_indexes=(_); end
-
-  def indeterminate_expected_indexes(); end
-
-  def indeterminate_expected_indexes=(_); end
-
-  def unmatched_actual_indexes(); end
-
-  def unmatched_actual_indexes=(_); end
-
-  def unmatched_expected_indexes(); end
-
-  def unmatched_expected_indexes=(_); end
-
-  def unmatched_item_count(); end
-
-  def worse_than?(other); end
-end
-
-class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer
-end
-
-class RSpec::Matchers::BuiltIn::ContainExactly
-end
-
-module RSpec::Matchers::BuiltIn::CountExpectation
-  def at_least(number); end
-
-  def at_most(number); end
-
-  def count_expectation_type(); end
-
-  def exactly(number); end
-
-  def expected_count(); end
-
-  def once(); end
-
-  def thrice(); end
-
-  def times(); end
-
-  def twice(); end
-end
-
-module RSpec::Matchers::BuiltIn::CountExpectation
-end
-
-class RSpec::Matchers::BuiltIn::Cover
-  def does_not_match?(range); end
-
-  def initialize(*expected); end
-
-  def matches?(range); end
-end
-
-class RSpec::Matchers::BuiltIn::Cover
-end
-
-class RSpec::Matchers::BuiltIn::DynamicPredicate
-  include ::RSpec::Matchers::BuiltIn::BeHelpers
-  def does_not_match?(actual, &block); end
-
-  def initialize(method_name, *args, &block); end
-
-  def matches?(actual, &block); end
-end
-
-class RSpec::Matchers::BuiltIn::DynamicPredicate
-end
-
-class RSpec::Matchers::BuiltIn::EndWith
-end
-
-class RSpec::Matchers::BuiltIn::EndWith
-end
-
-class RSpec::Matchers::BuiltIn::Eq
-end
-
-class RSpec::Matchers::BuiltIn::Eq
-end
-
-class RSpec::Matchers::BuiltIn::Eql
-end
-
-class RSpec::Matchers::BuiltIn::Eql
-end
-
-class RSpec::Matchers::BuiltIn::Equal
-  LITERAL_SINGLETONS = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Matchers::BuiltIn::Equal
-end
-
-class RSpec::Matchers::BuiltIn::Exist
-  def does_not_match?(actual); end
-
-  def initialize(*expected); end
-end
-
-class RSpec::Matchers::BuiltIn::Exist::ExistenceTest
-  def actual_exists?(); end
-
-  def valid_test?(); end
-
-  def validity_message(); end
-end
-
-class RSpec::Matchers::BuiltIn::Exist::ExistenceTest
-end
-
-class RSpec::Matchers::BuiltIn::Exist
-end
-
-class RSpec::Matchers::BuiltIn::Has
-  REGEX = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Matchers::BuiltIn::Has
-end
-
-class RSpec::Matchers::BuiltIn::HaveAttributes
-  def does_not_match?(actual); end
-
-  def initialize(expected); end
-
-  def respond_to_failed(); end
-end
-
-class RSpec::Matchers::BuiltIn::HaveAttributes
-end
-
-class RSpec::Matchers::BuiltIn::Include
-  include ::RSpec::Matchers::BuiltIn::CountExpectation
-  def does_not_match?(actual); end
-
-  def expecteds(); end
-
-  def initialize(*expecteds); end
-end
-
-class RSpec::Matchers::BuiltIn::Include
-end
-
-class RSpec::Matchers::BuiltIn::Match
-  def initialize(expected); end
-
-  def with_captures(*captures); end
-end
-
-class RSpec::Matchers::BuiltIn::Match
-end
-
-class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher
-  def __delegate_operator(actual, operator, expected); end
-end
-
-class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher
-end
-
-module RSpec::Matchers::BuiltIn::NullCapture
-end
-
-module RSpec::Matchers::BuiltIn::NullCapture
-  def self.capture(_block); end
-end
-
-class RSpec::Matchers::BuiltIn::OperatorMatcher
-  def !=(_expected); end
-
-  def !~(_expected); end
-
-  def <(expected); end
-
-  def <=(expected); end
-
-  def ==(expected); end
-
-  def ===(expected); end
-
-  def =~(expected); end
-
-  def >(expected); end
-
-  def >=(expected); end
-
-  def description(); end
-
-  def fail_with_message(message); end
-
-  def initialize(actual); end
-end
-
-class RSpec::Matchers::BuiltIn::OperatorMatcher
-  def self.get(klass, operator); end
-
-  def self.register(klass, operator, matcher); end
-
-  def self.registry(); end
-
-  def self.unregister(klass, operator); end
-
-  def self.use_custom_matcher_or_delegate(operator); end
-end
-
-class RSpec::Matchers::BuiltIn::Output
-  def does_not_match?(block); end
-
-  def initialize(expected); end
-
-  def matches?(block); end
-
-  def to_stderr(); end
-
-  def to_stderr_from_any_process(); end
-
-  def to_stdout(); end
-
-  def to_stdout_from_any_process(); end
-end
-
-class RSpec::Matchers::BuiltIn::Output
-end
-
-class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher
-  def __delegate_operator(actual, operator, expected); end
-end
-
-class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher
-end
-
-class RSpec::Matchers::BuiltIn::RaiseError
-  include ::RSpec::Matchers::Composable
-  def description(); end
-
-  def does_not_match?(given_proc); end
-
-  def expects_call_stack_jump?(); end
-
-  def failure_message(); end
-
-  def failure_message_when_negated(); end
-
-  def initialize(expected_error_or_message, expected_message, &block); end
-
-  def matches?(given_proc, negative_expectation=T.unsafe(nil), &block); end
-
-  def supports_block_expectations?(); end
-
-  def with_message(expected_message); end
-  UndefinedValue = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Matchers::BuiltIn::RaiseError
-end
-
-class RSpec::Matchers::BuiltIn::ReliableMatchData
-  def captures(); end
-
-  def initialize(match_data); end
-
-  def match_data(); end
-
-  def names(); end
-end
-
-class RSpec::Matchers::BuiltIn::ReliableMatchData
-end
-
-class RSpec::Matchers::BuiltIn::RespondTo
-  def and_any_keywords(); end
-
-  def and_keywords(*keywords); end
-
-  def and_unlimited_arguments(); end
-
-  def argument(); end
-
-  def arguments(); end
-
-  def does_not_match?(actual); end
-
-  def ignoring_method_signature_failure!(); end
-
-  def initialize(*names); end
-
-  def with(n); end
-
-  def with_any_keywords(); end
-
-  def with_keywords(*keywords); end
-
-  def with_unlimited_arguments(); end
-end
-
-class RSpec::Matchers::BuiltIn::RespondTo::ArityCheck
-  def initialize(expected_arity, expected_keywords, arbitrary_keywords, unlimited_arguments); end
-
-  def matches?(actual, name); end
-
-  def method_signature_for(actual, name); end
-
-  def verifier_for(actual, name); end
-end
-
-class RSpec::Matchers::BuiltIn::RespondTo::ArityCheck
-end
-
-class RSpec::Matchers::BuiltIn::RespondTo
-end
-
-class RSpec::Matchers::BuiltIn::Satisfy
-  def initialize(description=T.unsafe(nil), &block); end
-
-  def matches?(actual, &block); end
-end
-
-class RSpec::Matchers::BuiltIn::Satisfy
-end
-
-class RSpec::Matchers::BuiltIn::SpecificValuesChange
-  def initialize(change_details, from, to); end
-
-  def matches?(event_proc); end
-end
-
-RSpec::Matchers::BuiltIn::SpecificValuesChange::MATCH_ANYTHING = BasicObject
-
-class RSpec::Matchers::BuiltIn::SpecificValuesChange
-end
-
-RSpec::Matchers::BuiltIn::StartAndEndWith = RSpec::Matchers::BuiltIn::StartOrEndWith
-
-class RSpec::Matchers::BuiltIn::StartOrEndWith
-  def initialize(*expected); end
-end
-
-class RSpec::Matchers::BuiltIn::StartOrEndWith
-end
-
-class RSpec::Matchers::BuiltIn::StartWith
-end
-
-class RSpec::Matchers::BuiltIn::StartWith
-end
-
-class RSpec::Matchers::BuiltIn::ThrowSymbol
-  include ::RSpec::Matchers::Composable
-  def description(); end
-
-  def does_not_match?(given_proc); end
-
-  def expects_call_stack_jump?(); end
-
-  def failure_message(); end
-
-  def failure_message_when_negated(); end
-
-  def initialize(expected_symbol=T.unsafe(nil), expected_arg=T.unsafe(nil)); end
-
-  def matches?(given_proc); end
-
-  def supports_block_expectations?(); end
-end
-
-class RSpec::Matchers::BuiltIn::ThrowSymbol
-end
-
-class RSpec::Matchers::BuiltIn::YieldControl
-  include ::RSpec::Matchers::BuiltIn::CountExpectation
-  def does_not_match?(block); end
-
-  def matches?(block); end
-end
-
-class RSpec::Matchers::BuiltIn::YieldControl
-end
-
-class RSpec::Matchers::BuiltIn::YieldProbe
-  def assert_used!(); end
-
-  def assert_valid_expect_block!(); end
-
-  def has_block?(); end
-
-  def initialize(block, &callback); end
-
-  def num_yields(); end
-
-  def num_yields=(num_yields); end
-
-  def probe(); end
-
-  def single_yield_args(); end
-
-  def to_proc(); end
-
-  def yielded_args(); end
-
-  def yielded_args=(yielded_args); end
-
-  def yielded_once?(matcher_name); end
-end
-
-class RSpec::Matchers::BuiltIn::YieldProbe
-  def self.probe(block, &callback); end
-end
-
-class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs
-  def does_not_match?(block); end
-
-  def initialize(*args); end
-
-  def matches?(block); end
-end
-
-class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs
-end
-
-class RSpec::Matchers::BuiltIn::YieldWithArgs
-  def does_not_match?(block); end
-
-  def initialize(*args); end
-
-  def matches?(block); end
-end
-
-class RSpec::Matchers::BuiltIn::YieldWithArgs
-end
-
-class RSpec::Matchers::BuiltIn::YieldWithNoArgs
-  def does_not_match?(block); end
-
-  def matches?(block); end
-end
-
-class RSpec::Matchers::BuiltIn::YieldWithNoArgs
-end
-
-module RSpec::Matchers::BuiltIn
-end
-
-module RSpec::Matchers::Composable
-  def &(matcher); end
-
-  def ===(value); end
-
-  def and(matcher); end
-
-  def or(matcher); end
-
-  def |(matcher); end
-end
-
-module RSpec::Matchers::Composable
-  def self.should_enumerate?(item); end
-
-  def self.surface_descriptions_in(item); end
-
-  def self.unreadable_io?(object); end
-end
-
-module RSpec::Matchers::DSL
-  def alias_matcher(new_name, old_name, options=T.unsafe(nil), &description_override); end
-
-  def define(name, &declarations); end
-
-  def define_negated_matcher(negated_name, base_name, &description_override); end
-
-  def matcher(name, &declarations); end
-end
-
-module RSpec::Matchers::DSL::DefaultImplementations
-  include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
-  def description(); end
-
-  def diffable?(); end
-
-  def expects_call_stack_jump?(); end
-
-  def supports_block_expectations?(); end
-end
-
-module RSpec::Matchers::DSL::DefaultImplementations
-end
-
-module RSpec::Matchers::DSL::Macros
-  def chain(method_name, *attr_names, &definition); end
-
-  def description(&definition); end
-
-  def diffable(); end
-
-  def failure_message(&definition); end
-
-  def failure_message_when_negated(&definition); end
-
-  def match(options=T.unsafe(nil), &match_block); end
-
-  def match_unless_raises(expected_exception=T.unsafe(nil), &match_block); end
-
-  def match_when_negated(options=T.unsafe(nil), &match_block); end
-
-  def supports_block_expectations(); end
-  RAISE_NOTIFIER = ::T.let(nil, ::T.untyped)
-end
-
-module RSpec::Matchers::DSL::Macros::Deprecated
-  def failure_message_for_should(&definition); end
-
-  def failure_message_for_should_not(&definition); end
-
-  def match_for_should(&definition); end
-
-  def match_for_should_not(&definition); end
-end
-
-module RSpec::Matchers::DSL::Macros::Deprecated
-end
-
-module RSpec::Matchers::DSL::Macros
-end
-
-class RSpec::Matchers::DSL::Matcher
-  include ::RSpec::Matchers::DSL::DefaultImplementations
-  include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
-  include ::RSpec::Matchers
-  include ::RSpec::Matchers::Composable
-  def actual(); end
-
-  def block_arg(); end
-
-  def expected(); end
-
-  def expected_as_array(); end
-
-  def initialize(name, declarations, matcher_execution_context, *expected, &block_arg); end
-
-  def name(); end
-
-  def rescued_exception(); end
-end
-
-class RSpec::Matchers::DSL::Matcher
-  extend ::RSpec::Matchers::DSL::Macros
-  extend ::RSpec::Matchers::DSL::Macros::Deprecated
-end
-
-module RSpec::Matchers::DSL
-end
-
-module RSpec::Matchers::EnglishPhrasing
-end
-
-module RSpec::Matchers::EnglishPhrasing
-  def self.list(obj); end
-
-  def self.split_words(sym); end
-end
-
-class RSpec::Matchers::ExpectedsForMultipleDiffs
-  def initialize(expected_list); end
-
-  def message_with_diff(message, differ, actual); end
-  DEFAULT_DIFF_LABEL = ::T.let(nil, ::T.untyped)
-  DESCRIPTION_MAX_LENGTH = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Matchers::ExpectedsForMultipleDiffs
-  def self.for_many_matchers(matchers); end
-
-  def self.from(expected); end
-end
-
-class RSpec::Matchers::MatcherDelegator
-  include ::RSpec::Matchers::Composable
-  def base_matcher(); end
-
-  def initialize(base_matcher); end
-
-  def method_missing(*args, &block); end
-end
-
-class RSpec::Matchers::MatcherDelegator
-end
-
-module RSpec::Matchers
-  extend ::RSpec::Matchers::DSL
-  def self.alias_matcher(*args, &block); end
-
-  def self.clear_generated_description(); end
-
-  def self.configuration(); end
-
-  def self.generated_description(); end
-
-  def self.is_a_describable_matcher?(obj); end
-
-  def self.is_a_matcher?(obj); end
-
-  def self.last_description(); end
-
-  def self.last_expectation_handler(); end
-
-  def self.last_expectation_handler=(last_expectation_handler); end
-
-  def self.last_matcher(); end
-
-  def self.last_matcher=(last_matcher); end
-end
-
-module RSpec::Mocks
-  DEFAULT_CALLBACK_INVOCATION_STRATEGY = ::T.let(nil, ::T.untyped)
-  IGNORED_BACKTRACE_LINE = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Mocks::AllowanceTarget
-  def expression(); end
-
-  def not_to(matcher, *_args); end
-
-  def to(matcher, &block); end
-
-  def to_not(matcher, *_args); end
-end
-
-class RSpec::Mocks::AllowanceTarget
-end
-
-class RSpec::Mocks::AndReturnImplementation
-  def call(*_args_to_ignore, &_block); end
-
-  def initialize(values_to_return); end
-end
-
-class RSpec::Mocks::AndReturnImplementation
-end
-
-class RSpec::Mocks::AndWrapOriginalImplementation
-  def call(*args, &block); end
-
-  def initial_action=(_value); end
-
-  def initialize(method, block); end
-
-  def inner_action(); end
-
-  def inner_action=(_value); end
-
-  def terminal_action=(_value); end
-end
-
-class RSpec::Mocks::AndWrapOriginalImplementation::CannotModifyFurtherError
-end
-
-class RSpec::Mocks::AndWrapOriginalImplementation::CannotModifyFurtherError
-end
-
-class RSpec::Mocks::AndWrapOriginalImplementation
-end
-
-class RSpec::Mocks::AndYieldImplementation
-  def call(*_args_to_ignore, &block); end
-
-  def initialize(args_to_yield, eval_context, error_generator); end
-end
-
-class RSpec::Mocks::AndYieldImplementation
-end
-
-module RSpec::Mocks::AnyInstance
-end
-
-class RSpec::Mocks::AnyInstance::Chain
-  include ::RSpec::Mocks::AnyInstance::Chain::Customizations
-  def constrained_to_any_of?(*constraints); end
-
-  def expectation_fulfilled!(); end
-
-  def initialize(recorder, *args, &block); end
-
-  def matches_args?(*args); end
-
-  def never(); end
-
-  def playback!(instance); end
-end
-
-module RSpec::Mocks::AnyInstance::Chain::Customizations
-  def and_call_original(*args, &block); end
-
-  def and_raise(*args, &block); end
-
-  def and_return(*args, &block); end
-
-  def and_throw(*args, &block); end
-
-  def and_wrap_original(*args, &block); end
-
-  def and_yield(*args, &block); end
-
-  def at_least(*args, &block); end
-
-  def at_most(*args, &block); end
-
-  def exactly(*args, &block); end
-
-  def never(*args, &block); end
-
-  def once(*args, &block); end
-
-  def thrice(*args, &block); end
-
-  def time(*args, &block); end
-
-  def times(*args, &block); end
-
-  def twice(*args, &block); end
-
-  def with(*args, &block); end
-end
-
-module RSpec::Mocks::AnyInstance::Chain::Customizations
-  def self.record(method_name); end
-end
-
-class RSpec::Mocks::AnyInstance::Chain
-end
-
-class RSpec::Mocks::AnyInstance::ErrorGenerator
-  def raise_does_not_implement_error(klass, method_name); end
-
-  def raise_message_already_received_by_other_instance_error(method_name, object_inspect, invoked_instance); end
-
-  def raise_not_supported_with_prepend_error(method_name, problem_mod); end
-
-  def raise_second_instance_received_message_error(unfulfilled_expectations); end
-end
-
-class RSpec::Mocks::AnyInstance::ErrorGenerator
-end
-
-class RSpec::Mocks::AnyInstance::ExpectChainChain
-  def initialize(*args); end
-end
-
-class RSpec::Mocks::AnyInstance::ExpectChainChain
-end
-
-class RSpec::Mocks::AnyInstance::ExpectationChain
-  def expectation_fulfilled?(); end
-
-  def initialize(*args, &block); end
-end
-
-class RSpec::Mocks::AnyInstance::ExpectationChain
-end
-
-class RSpec::Mocks::AnyInstance::FluentInterfaceProxy
-  def initialize(targets); end
-
-  def method_missing(*args, &block); end
-end
-
-class RSpec::Mocks::AnyInstance::FluentInterfaceProxy
-end
-
-class RSpec::Mocks::AnyInstance::MessageChains
-  def [](method_name); end
-
-  def add(method_name, chain); end
-
-  def all_expectations_fulfilled?(); end
-
-  def each_unfulfilled_expectation_matching(method_name, *args); end
-
-  def has_expectation?(method_name); end
-
-  def playback!(instance, method_name); end
-
-  def received_expected_message!(method_name); end
-
-  def remove_stub_chains_for!(method_name); end
-
-  def unfulfilled_expectations(); end
-end
-
-class RSpec::Mocks::AnyInstance::MessageChains
-end
-
-class RSpec::Mocks::AnyInstance::PositiveExpectationChain
-  ExpectationInvocationOrder = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Mocks::AnyInstance::PositiveExpectationChain
-end
-
-class RSpec::Mocks::AnyInstance::Proxy
-  def expect_chain(*chain, &block); end
-
-  def initialize(recorder, target_proxies); end
-
-  def klass(); end
-
-  def should_not_receive(method_name, &block); end
-
-  def should_receive(method_name, &block); end
-
-  def stub(method_name_or_method_map, &block); end
-
-  def stub_chain(*chain, &block); end
-
-  def unstub(method_name); end
-end
-
-class RSpec::Mocks::AnyInstance::Proxy
-end
-
-class RSpec::Mocks::AnyInstance::Recorder
-  def already_observing?(method_name); end
-
-  def build_alias_method_name(method_name); end
-
-  def expect_chain(*method_names_and_optional_return_values, &block); end
-
-  def initialize(klass); end
-
-  def instance_that_received(method_name); end
-
-  def klass(); end
-
-  def message_chains(); end
-
-  def notify_received_message(_object, message, args, _blk); end
-
-  def playback!(instance, method_name); end
-
-  def should_not_receive(method_name, &block); end
-
-  def should_receive(method_name, &block); end
-
-  def stop_all_observation!(); end
-
-  def stop_observing!(method_name); end
-
-  def stub(method_name, &block); end
-
-  def stub_chain(*method_names_and_optional_return_values, &block); end
-
-  def stubs(); end
-
-  def unstub(method_name); end
-
-  def verify(); end
-end
-
-class RSpec::Mocks::AnyInstance::Recorder
-end
-
-class RSpec::Mocks::AnyInstance::StubChain
-  def expectation_fulfilled?(); end
-  EmptyInvocationOrder = ::T.let(nil, ::T.untyped)
-  InvocationOrder = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Mocks::AnyInstance::StubChain
-end
-
-class RSpec::Mocks::AnyInstance::StubChainChain
-  def initialize(*args); end
-end
-
-class RSpec::Mocks::AnyInstance::StubChainChain
-end
-
-module RSpec::Mocks::AnyInstance
-  def self.error_generator(); end
-end
-
-class RSpec::Mocks::AnyInstanceAllowanceTarget
-  def expression(); end
-
-  def not_to(matcher, *_args); end
-
-  def to(matcher, &block); end
-
-  def to_not(matcher, *_args); end
-end
-
-class RSpec::Mocks::AnyInstanceAllowanceTarget
-end
-
-class RSpec::Mocks::AnyInstanceExpectationTarget
-  def expression(); end
-
-  def not_to(matcher, &block); end
-
-  def to(matcher, &block); end
-
-  def to_not(matcher, &block); end
-end
-
-class RSpec::Mocks::AnyInstanceExpectationTarget
-end
-
-class RSpec::Mocks::ArgumentListMatcher
-  def args_match?(*args); end
-
-  def expected_args(); end
-
-  def initialize(*expected_args); end
-
-  def resolve_expected_args_based_on(actual_args); end
-  MATCH_ALL = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Mocks::ArgumentListMatcher
-end
-
-module RSpec::Mocks::ArgumentMatchers
-  def a_kind_of(klass); end
-
-  def an_instance_of(klass); end
-
-  def any_args(); end
-
-  def anything(); end
-
-  def array_including(*args); end
-
-  def boolean(); end
-
-  def duck_type(*args); end
-
-  def hash_excluding(*args); end
-
-  def hash_including(*args); end
-
-  def hash_not_including(*args); end
-
-  def instance_of(klass); end
-
-  def kind_of(klass); end
-
-  def no_args(); end
-end
-
-module RSpec::Mocks::ArgumentMatchers
-  def self.anythingize_lonely_keys(*args); end
-end
-
-class RSpec::Mocks::CallbackInvocationStrategy
-  def call(doubled_module); end
-end
-
-class RSpec::Mocks::CallbackInvocationStrategy
-end
-
-class RSpec::Mocks::CannotSupportArgMutationsError
-end
-
-class RSpec::Mocks::CannotSupportArgMutationsError
-end
-
-class RSpec::Mocks::ClassNewMethodReference
-end
-
-class RSpec::Mocks::ClassNewMethodReference
-  def self.applies_to?(method_name); end
-end
-
-class RSpec::Mocks::ClassVerifyingDouble
-  include ::RSpec::Mocks::ObjectVerifyingDoubleMethods
-  include ::RSpec::Mocks::TestDouble
-  include ::RSpec::Mocks::VerifyingDouble
-end
-
-class RSpec::Mocks::ClassVerifyingDouble
-end
-
-class RSpec::Mocks::Configuration
-  def add_stub_and_should_receive_to(*modules); end
-
-  def allow_message_expectations_on_nil(); end
-
-  def allow_message_expectations_on_nil=(allow_message_expectations_on_nil); end
-
-  def before_verifying_doubles(&block); end
-
-  def color?(); end
-
-  def patch_marshal_to_support_partial_doubles=(val); end
-
-  def reset_syntaxes_to_default(); end
-
-  def syntax(); end
-
-  def syntax=(*values); end
-
-  def temporarily_suppress_partial_double_verification(); end
-
-  def temporarily_suppress_partial_double_verification=(temporarily_suppress_partial_double_verification); end
-
-  def transfer_nested_constants=(transfer_nested_constants); end
-
-  def transfer_nested_constants?(); end
-
-  def verify_doubled_constant_names=(verify_doubled_constant_names); end
-
-  def verify_doubled_constant_names?(); end
-
-  def verify_partial_doubles=(val); end
-
-  def verify_partial_doubles?(); end
-
-  def verifying_double_callbacks(); end
-
-  def when_declaring_verifying_double(&block); end
-
-  def yield_receiver_to_any_instance_implementation_blocks=(yield_receiver_to_any_instance_implementation_blocks); end
-
-  def yield_receiver_to_any_instance_implementation_blocks?(); end
-end
-
-class RSpec::Mocks::Configuration
-end
-
-class RSpec::Mocks::Constant
-  def hidden=(hidden); end
-
-  def hidden?(); end
-
-  def initialize(name); end
-
-  def mutated?(); end
-
-  def name(); end
-
-  def original_value(); end
-
-  def original_value=(original_value); end
-
-  def previously_defined=(previously_defined); end
-
-  def previously_defined?(); end
-
-  def stubbed=(stubbed); end
-
-  def stubbed?(); end
-
-  def valid_name=(valid_name); end
-
-  def valid_name?(); end
-end
-
-class RSpec::Mocks::Constant
-  extend ::RSpec::Support::RecursiveConstMethods
-  def self.original(name); end
-
-  def self.unmutated(name); end
-end
-
-class RSpec::Mocks::ConstantMutator
-end
-
-class RSpec::Mocks::ConstantMutator::BaseMutator
-  include ::RSpec::Support::RecursiveConstMethods
-  def full_constant_name(); end
-
-  def idempotently_reset(); end
-
-  def initialize(full_constant_name, mutated_value, transfer_nested_constants); end
-
-  def original_value(); end
-
-  def to_constant(); end
-end
-
-class RSpec::Mocks::ConstantMutator::BaseMutator
-end
-
-class RSpec::Mocks::ConstantMutator::ConstantHider
-  def mutate(); end
-
-  def reset(); end
-end
-
-class RSpec::Mocks::ConstantMutator::ConstantHider
-end
-
-class RSpec::Mocks::ConstantMutator::DefinedConstantReplacer
-  def initialize(*args); end
-
-  def mutate(); end
-
-  def reset(); end
-
-  def should_transfer_nested_constants?(); end
-
-  def transfer_nested_constants(); end
-
-  def verify_constants_to_transfer!(); end
-end
-
-class RSpec::Mocks::ConstantMutator::DefinedConstantReplacer
-end
-
-class RSpec::Mocks::ConstantMutator::UndefinedConstantSetter
-  def mutate(); end
-
-  def reset(); end
-end
-
-class RSpec::Mocks::ConstantMutator::UndefinedConstantSetter
-end
-
-class RSpec::Mocks::ConstantMutator
-  extend ::RSpec::Support::RecursiveConstMethods
-  def self.hide(constant_name); end
-
-  def self.mutate(mutator); end
-
-  def self.raise_on_invalid_const(); end
-
-  def self.stub(constant_name, value, options=T.unsafe(nil)); end
-end
-
-class RSpec::Mocks::DirectObjectReference
-  def const_to_replace(); end
-
-  def defined?(); end
-
-  def description(); end
-
-  def initialize(object); end
-
-  def target(); end
-
-  def when_loaded(); end
-end
-
-class RSpec::Mocks::DirectObjectReference
-end
-
-class RSpec::Mocks::Double
-  include ::RSpec::Mocks::TestDouble
-end
-
-class RSpec::Mocks::Double
-end
-
-class RSpec::Mocks::ErrorGenerator
-  def default_error_message(expectation, expected_args, actual_args); end
-
-  def describe_expectation(verb, message, expected_received_count, _actual_received_count, args); end
-
-  def expectation_on_nil_message(method_name); end
-
-  def initialize(target=T.unsafe(nil)); end
-
-  def intro(unwrapped=T.unsafe(nil)); end
-
-  def method_call_args_description(args, generic_prefix=T.unsafe(nil), matcher_prefix=T.unsafe(nil)); end
-
-  def opts(); end
-
-  def opts=(opts); end
-
-  def raise_already_invoked_error(message, calling_customization); end
-
-  def raise_cant_constrain_count_for_negated_have_received_error(count_constraint); end
-
-  def raise_double_negation_error(wrapped_expression); end
-
-  def raise_expectation_error(message, expected_received_count, argument_list_matcher, actual_received_count, expectation_count_type, args, backtrace_line=T.unsafe(nil), source_id=T.unsafe(nil)); end
-
-  def raise_expectation_on_mocked_method(method); end
-
-  def raise_expectation_on_nil_error(method_name); end
-
-  def raise_expectation_on_unstubbed_method(method); end
-
-  def raise_expired_test_double_error(); end
-
-  def raise_have_received_disallowed(type, reason); end
-
-  def raise_invalid_arguments_error(verifier); end
-
-  def raise_method_not_stubbed_error(method_name); end
-
-  def raise_missing_block_error(args_to_yield); end
-
-  def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end
-
-  def raise_non_public_error(method_name, visibility); end
-
-  def raise_only_valid_on_a_partial_double(method); end
-
-  def raise_out_of_order_error(message); end
-
-  def raise_similar_message_args_error(expectation, args_for_multiple_calls, backtrace_line=T.unsafe(nil)); end
-
-  def raise_unexpected_message_args_error(expectation, args_for_multiple_calls, source_id=T.unsafe(nil)); end
-
-  def raise_unexpected_message_error(message, args); end
-
-  def raise_unimplemented_error(doubled_module, method_name, object); end
-
-  def raise_verifying_double_not_defined_error(ref); end
-
-  def raise_wrong_arity_error(args_to_yield, signature); end
-end
-
-class RSpec::Mocks::ErrorGenerator
-end
-
-module RSpec::Mocks::ExampleMethods
-  include ::RSpec::Mocks::ArgumentMatchers
-  def allow(target); end
-
-  def allow_any_instance_of(klass); end
-
-  def allow_message_expectations_on_nil(); end
-
-  def class_double(doubled_class, *args); end
-
-  def class_spy(*args); end
-
-  def double(*args); end
-
-  def expect_any_instance_of(klass); end
-
-  def have_received(method_name, &block); end
-
-  def hide_const(constant_name); end
-
-  def instance_double(doubled_class, *args); end
-
-  def instance_spy(*args); end
-
-  def object_double(object_or_name, *args); end
-
-  def object_spy(*args); end
-
-  def receive(method_name, &block); end
-
-  def receive_message_chain(*messages, &block); end
-
-  def receive_messages(message_return_value_hash); end
-
-  def spy(*args); end
-
-  def stub_const(constant_name, value, options=T.unsafe(nil)); end
-
-  def without_partial_double_verification(); end
-end
-
-module RSpec::Mocks::ExampleMethods::ExpectHost
-  def expect(target); end
-end
-
-module RSpec::Mocks::ExampleMethods::ExpectHost
-end
-
-module RSpec::Mocks::ExampleMethods
-  def self.declare_double(type, *args); end
-
-  def self.declare_verifying_double(type, ref, *args); end
-
-  def self.extended(object); end
-
-  def self.included(klass); end
-end
-
-class RSpec::Mocks::ExpectChain
-end
-
-class RSpec::Mocks::ExpectChain
-  def self.expect_chain_on(object, *chain, &blk); end
-end
-
-class RSpec::Mocks::ExpectationTarget
-  include ::RSpec::Mocks::ExpectationTargetMethods
-end
-
-class RSpec::Mocks::ExpectationTarget
-end
-
-module RSpec::Mocks::ExpectationTargetMethods
-  include ::RSpec::Mocks::TargetDelegationInstanceMethods
-  def expression(); end
-
-  def not_to(matcher, &block); end
-
-  def to(matcher, &block); end
-
-  def to_not(matcher, &block); end
-end
-
-module RSpec::Mocks::ExpectationTargetMethods
-  extend ::RSpec::Mocks::TargetDelegationClassMethods
-end
-
-class RSpec::Mocks::ExpiredTestDoubleError
-end
-
-class RSpec::Mocks::ExpiredTestDoubleError
-end
-
-class RSpec::Mocks::Implementation
-  def call(*args, &block); end
-
-  def initial_action(); end
-
-  def initial_action=(initial_action); end
-
-  def inner_action(); end
-
-  def inner_action=(inner_action); end
-
-  def terminal_action(); end
-
-  def terminal_action=(terminal_action); end
-end
-
-class RSpec::Mocks::Implementation
-end
-
-class RSpec::Mocks::InstanceMethodReference
-end
-
-class RSpec::Mocks::InstanceMethodReference
-end
-
-class RSpec::Mocks::InstanceMethodStasher
-  def handle_restoration_failures(); end
-
-  def initialize(object, method); end
-
-  def method_is_stashed?(); end
-
-  def original_method(); end
-
-  def restore(); end
-
-  def stash(); end
-end
-
-class RSpec::Mocks::InstanceMethodStasher
-end
-
-class RSpec::Mocks::InstanceVerifyingDouble
-  include ::RSpec::Mocks::TestDouble
-  include ::RSpec::Mocks::VerifyingDouble
-end
-
-class RSpec::Mocks::InstanceVerifyingDouble
-end
-
-class RSpec::Mocks::MarshalExtension
-end
-
-class RSpec::Mocks::MarshalExtension
-  def self.patch!(); end
-
-  def self.unpatch!(); end
-end
-
-module RSpec::Mocks::Matchers
-end
-
-class RSpec::Mocks::Matchers::ExpectationCustomization
-  def block(); end
-
-  def block=(block); end
-
-  def initialize(method_name, args, block); end
-
-  def playback_onto(expectation); end
-end
-
-class RSpec::Mocks::Matchers::ExpectationCustomization
-end
-
-class RSpec::Mocks::Matchers::HaveReceived
-  include ::RSpec::Mocks::Matchers::Matcher
-  def at_least(*args); end
-
-  def at_most(*args); end
-
-  def description(); end
-
-  def does_not_match?(subject); end
-
-  def exactly(*args); end
-
-  def failure_message(); end
-
-  def failure_message_when_negated(); end
-
-  def initialize(method_name, &block); end
-
-  def matches?(subject, &block); end
-
-  def name(); end
-
-  def once(*args); end
-
-  def ordered(*args); end
-
-  def setup_allowance(_subject, &_block); end
-
-  def setup_any_instance_allowance(_subject, &_block); end
-
-  def setup_any_instance_expectation(_subject, &_block); end
-
-  def setup_any_instance_negative_expectation(_subject, &_block); end
-
-  def setup_expectation(subject, &block); end
-
-  def setup_negative_expectation(subject, &block); end
-
-  def thrice(*args); end
-
-  def time(*args); end
-
-  def times(*args); end
-
-  def twice(*args); end
-
-  def with(*args); end
-  ARGS_CONSTRAINTS = ::T.let(nil, ::T.untyped)
-  CONSTRAINTS = ::T.let(nil, ::T.untyped)
-  COUNT_CONSTRAINTS = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Mocks::Matchers::HaveReceived
-end
-
-module RSpec::Mocks::Matchers::Matcher
-end
-
-module RSpec::Mocks::Matchers::Matcher
-end
-
-class RSpec::Mocks::Matchers::Receive
-  include ::RSpec::Mocks::Matchers::Matcher
-  def and_call_original(*args, &block); end
-
-  def and_raise(*args, &block); end
-
-  def and_return(*args, &block); end
-
-  def and_throw(*args, &block); end
-
-  def and_wrap_original(*args, &block); end
-
-  def and_yield(*args, &block); end
-
-  def at_least(*args, &block); end
-
-  def at_most(*args, &block); end
-
-  def description(); end
-
-  def does_not_match?(subject, &block); end
-
-  def exactly(*args, &block); end
-
-  def initialize(message, block); end
-
-  def matches?(subject, &block); end
-
-  def name(); end
-
-  def never(*args, &block); end
-
-  def once(*args, &block); end
-
-  def ordered(*args, &block); end
-
-  def setup_allowance(subject, &block); end
-
-  def setup_any_instance_allowance(subject, &block); end
-
-  def setup_any_instance_expectation(subject, &block); end
-
-  def setup_any_instance_negative_expectation(subject, &block); end
-
-  def setup_expectation(subject, &block); end
-
-  def setup_negative_expectation(subject, &block); end
-
-  def thrice(*args, &block); end
-
-  def time(*args, &block); end
-
-  def times(*args, &block); end
-
-  def twice(*args, &block); end
-
-  def with(*args, &block); end
-end
-
-class RSpec::Mocks::Matchers::Receive::DefaultDescribable
-  def description_for(verb); end
-
-  def initialize(message); end
-end
-
-class RSpec::Mocks::Matchers::Receive::DefaultDescribable
-end
-
-class RSpec::Mocks::Matchers::Receive
-end
-
-class RSpec::Mocks::Matchers::ReceiveMessageChain
-  include ::RSpec::Mocks::Matchers::Matcher
-  def and_call_original(*args, &block); end
-
-  def and_raise(*args, &block); end
-
-  def and_return(*args, &block); end
-
-  def and_throw(*args, &block); end
-
-  def and_yield(*args, &block); end
-
-  def description(); end
-
-  def does_not_match?(*_args); end
-
-  def initialize(chain, &block); end
-
-  def matches?(subject, &block); end
-
-  def name(); end
-
-  def setup_allowance(subject, &block); end
-
-  def setup_any_instance_allowance(subject, &block); end
-
-  def setup_any_instance_expectation(subject, &block); end
-
-  def setup_expectation(subject, &block); end
-
-  def setup_negative_expectation(*_args); end
-
-  def with(*args, &block); end
-end
-
-class RSpec::Mocks::Matchers::ReceiveMessageChain
-end
-
-class RSpec::Mocks::Matchers::ReceiveMessages
-  include ::RSpec::Mocks::Matchers::Matcher
-  def description(); end
-
-  def does_not_match?(_subject); end
-
-  def initialize(message_return_value_hash); end
-
-  def matches?(subject); end
-
-  def name(); end
-
-  def setup_allowance(subject); end
-
-  def setup_any_instance_allowance(subject); end
-
-  def setup_any_instance_expectation(subject); end
-
-  def setup_expectation(subject); end
-
-  def setup_negative_expectation(_subject); end
-
-  def warn_about_block(); end
-end
-
-class RSpec::Mocks::Matchers::ReceiveMessages
-end
-
-module RSpec::Mocks::Matchers
-end
-
-class RSpec::Mocks::MessageChain
-  def block(); end
-
-  def chain(); end
-
-  def initialize(object, *chain, &blk); end
-
-  def object(); end
-
-  def setup_chain(); end
-end
-
-class RSpec::Mocks::MessageChain
-end
-
-class RSpec::Mocks::MessageExpectation
-  include ::RSpec::Mocks::MessageExpectation::ImplementationDetails
-  def and_call_original(); end
-
-  def and_raise(*args); end
-
-  def and_return(first_value, *values); end
-
-  def and_throw(*args); end
-
-  def and_wrap_original(&block); end
-
-  def and_yield(*args, &block); end
-
-  def at_least(n, &block); end
-
-  def at_most(n, &block); end
-
-  def exactly(n, &block); end
-
-  def never(); end
-
-  def once(&block); end
-
-  def ordered(&block); end
-
-  def thrice(&block); end
-
-  def time(&block); end
-
-  def times(&block); end
-
-  def twice(&block); end
-
-  def with(*args, &block); end
-end
-
-module RSpec::Mocks::MessageExpectation::ImplementationDetails
-  def actual_received_count_matters?(); end
-
-  def additional_expected_calls(); end
-
-  def advise(*args); end
-
-  def and_yield_receiver_to_implementation(); end
-
-  def argument_list_matcher=(argument_list_matcher); end
-
-  def called_max_times?(); end
-
-  def description_for(verb); end
-
-  def ensure_expected_ordering_received!(); end
-
-  def error_generator(); end
-
-  def error_generator=(error_generator); end
-
-  def expectation_count_type(); end
-
-  def expected_args(); end
-
-  def expected_from=(expected_from); end
-
-  def expected_messages_received?(); end
-
-  def expected_received_count=(expected_received_count); end
-
-  def generate_error(); end
-
-  def ignoring_args?(); end
-
-  def implementation(); end
-
-  def implementation=(implementation); end
-
-  def increase_actual_received_count!(); end
-
-  def initialize(error_generator, expectation_ordering, expected_from, method_double, type=T.unsafe(nil), opts=T.unsafe(nil), &implementation_block); end
-
-  def invoke(parent_stub, *args, &block); end
-
-  def invoke_without_incrementing_received_count(parent_stub, *args, &block); end
-
-  def matches?(message, *args); end
-
-  def matches_at_least_count?(); end
-
-  def matches_at_most_count?(); end
-
-  def matches_exact_count?(); end
-
-  def matches_name_but_not_args(message, *args); end
-
-  def message(); end
-
-  def negative?(); end
-
-  def negative_expectation_for?(message); end
-
-  def ordered?(); end
-
-  def orig_object(); end
-
-  def raise_out_of_order_error(); end
-
-  def raise_unexpected_message_args_error(args_for_multiple_calls); end
-
-  def safe_invoke(parent_stub, *args, &block); end
-
-  def similar_messages(); end
-
-  def type(); end
-
-  def unadvise(args); end
-
-  def verify_messages_received(); end
-
-  def yield_receiver_to_implementation_block?(); end
-end
-
-module RSpec::Mocks::MessageExpectation::ImplementationDetails
-end
-
-class RSpec::Mocks::MessageExpectation
-end
-
-class RSpec::Mocks::MethodDouble
-  def add_default_stub(*args, &implementation); end
-
-  def add_expectation(error_generator, expectation_ordering, expected_from, opts, &implementation); end
-
-  def add_simple_expectation(method_name, response, error_generator, backtrace_line); end
-
-  def add_simple_stub(method_name, response); end
-
-  def add_stub(error_generator, expectation_ordering, expected_from, opts=T.unsafe(nil), &implementation); end
-
-  def build_expectation(error_generator, expectation_ordering); end
-
-  def clear(); end
-
-  def configure_method(); end
-
-  def define_proxy_method(); end
-
-  def expectations(); end
-
-  def initialize(object, method_name, proxy); end
-
-  def message_expectation_class(); end
-
-  def method_name(); end
-
-  def method_stasher(); end
-
-  def object(); end
-
-  def object_singleton_class(); end
-
-  def original_implementation_callable(); end
-
-  def original_method(); end
-
-  def proxy_method_invoked(_obj, *args, &block); end
-
-  def raise_method_not_stubbed_error(); end
-
-  def remove_stub(); end
-
-  def remove_stub_if_present(); end
-
-  def reset(); end
-
-  def restore_original_method(); end
-
-  def restore_original_visibility(); end
-
-  def save_original_implementation_callable!(); end
-
-  def setup_simple_method_double(method_name, response, collection, error_generator=T.unsafe(nil), backtrace_line=T.unsafe(nil)); end
-
-  def show_frozen_warning(); end
-
-  def stubs(); end
-
-  def verify(); end
-
-  def visibility(); end
-end
-
-class RSpec::Mocks::MethodDouble::RSpecPrependedModule
-end
-
-class RSpec::Mocks::MethodDouble::RSpecPrependedModule
-end
-
-class RSpec::Mocks::MethodDouble
-end
-
-class RSpec::Mocks::MethodReference
-  def defined?(); end
-
-  def implemented?(); end
-
-  def initialize(object_reference, method_name); end
-
-  def unimplemented?(); end
-
-  def visibility(); end
-
-  def with_signature(); end
-end
-
-class RSpec::Mocks::MethodReference
-  def self.for(object_reference, method_name); end
-
-  def self.instance_method_visibility_for(klass, method_name); end
-
-  def self.method_defined_at_any_visibility?(klass, method_name); end
-
-  def self.method_visibility_for(object, method_name); end
-end
-
-class RSpec::Mocks::MockExpectationAlreadyInvokedError
-end
-
-class RSpec::Mocks::MockExpectationAlreadyInvokedError
-end
-
-class RSpec::Mocks::MockExpectationError
-end
-
-class RSpec::Mocks::MockExpectationError
-end
-
-class RSpec::Mocks::NamedObjectReference
-  def const_to_replace(); end
-
-  def defined?(); end
-
-  def description(); end
-
-  def initialize(const_name); end
-
-  def target(); end
-
-  def when_loaded(); end
-end
-
-class RSpec::Mocks::NamedObjectReference
-end
-
-class RSpec::Mocks::NegationUnsupportedError
-end
-
-class RSpec::Mocks::NegationUnsupportedError
-end
-
-class RSpec::Mocks::NestedSpace
-  def initialize(parent); end
-end
-
-class RSpec::Mocks::NestedSpace
-end
-
-class RSpec::Mocks::NoCallbackInvocationStrategy
-  def call(_doubled_module); end
-end
-
-class RSpec::Mocks::NoCallbackInvocationStrategy
-end
-
-class RSpec::Mocks::ObjectMethodReference
-end
-
-class RSpec::Mocks::ObjectMethodReference
-end
-
-class RSpec::Mocks::ObjectReference
-  MODULE_NAME_METHOD = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Mocks::ObjectReference
-  def self.for(object_module_or_name, allow_direct_object_refs=T.unsafe(nil)); end
-end
-
-class RSpec::Mocks::ObjectVerifyingDouble
-  include ::RSpec::Mocks::ObjectVerifyingDoubleMethods
-  include ::RSpec::Mocks::TestDouble
-  include ::RSpec::Mocks::VerifyingDouble
-end
-
-class RSpec::Mocks::ObjectVerifyingDouble
-end
-
-module RSpec::Mocks::ObjectVerifyingDoubleMethods
-  include ::RSpec::Mocks::TestDouble
-  include ::RSpec::Mocks::VerifyingDouble
-  def as_stubbed_const(options=T.unsafe(nil)); end
-end
-
-module RSpec::Mocks::ObjectVerifyingDoubleMethods
-end
-
-class RSpec::Mocks::OrderGroup
-  def clear(); end
-
-  def consume(); end
-
-  def empty?(); end
-
-  def handle_order_constraint(expectation); end
-
-  def invoked(message); end
-
-  def ready_for?(expectation); end
-
-  def register(expectation); end
-
-  def verify_invocation_order(expectation); end
-end
-
-class RSpec::Mocks::OrderGroup
-end
-
-class RSpec::Mocks::OutsideOfExampleError
-end
-
-class RSpec::Mocks::OutsideOfExampleError
-end
-
-class RSpec::Mocks::PartialClassDoubleProxy
-  include ::RSpec::Mocks::PartialClassDoubleProxyMethods
-end
-
-class RSpec::Mocks::PartialClassDoubleProxy
-end
-
-module RSpec::Mocks::PartialClassDoubleProxyMethods
-  def initialize(source_space, *args); end
-
-  def method_double_from_ancestor_for(message); end
-
-  def original_method_handle_for(message); end
-
-  def original_unbound_method_handle_from_ancestor_for(message); end
-
-  def superclass_proxy(); end
-end
-
-module RSpec::Mocks::PartialClassDoubleProxyMethods
-end
-
-class RSpec::Mocks::PartialDoubleProxy
-  def original_method_handle_for(message); end
-
-  def visibility_for(method_name); end
-end
-
-class RSpec::Mocks::PartialDoubleProxy
-end
-
-class RSpec::Mocks::Proxy
-  def add_message_expectation(method_name, opts=T.unsafe(nil), &block); end
-
-  def add_simple_expectation(method_name, response, location); end
-
-  def add_simple_stub(method_name, response); end
-
-  def add_stub(method_name, opts=T.unsafe(nil), &implementation); end
-
-  def build_expectation(method_name); end
-
-  def check_for_unexpected_arguments(expectation); end
-
-  def ensure_can_be_proxied!(object); end
-
-  def ensure_implemented(*_args); end
-
-  def has_negative_expectation?(message); end
-
-  def initialize(object, order_group, options=T.unsafe(nil)); end
-
-  def message_received(message, *args, &block); end
-
-  def messages_arg_list(); end
-
-  def method_double_if_exists_for_message(message); end
-
-  def object(); end
-
-  def original_method_handle_for(_message); end
-
-  def prepended_modules_of_singleton_class(); end
-
-  def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end
-
-  def raise_unexpected_message_error(method_name, args); end
-
-  def received_message?(method_name, *args, &block); end
-
-  def record_message_received(message, *args, &block); end
-
-  def remove_stub(method_name); end
-
-  def remove_stub_if_present(method_name); end
-
-  def replay_received_message_on(expectation, &block); end
-
-  def reset(); end
-
-  def verify(); end
-
-  def visibility_for(_method_name); end
-  DEFAULT_MESSAGE_EXPECTATION_OPTS = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Mocks::Proxy::SpecificMessage
-  def ==(expectation); end
-
-  def args(); end
-
-  def args=(_); end
-
-  def message(); end
-
-  def message=(_); end
-
-  def object(); end
-
-  def object=(_); end
-end
-
-class RSpec::Mocks::Proxy::SpecificMessage
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class RSpec::Mocks::Proxy
-  def self.prepended_modules_of(klass); end
-end
-
-class RSpec::Mocks::ProxyForNil
-  def disallow_expectations(); end
-
-  def disallow_expectations=(disallow_expectations); end
-
-  def initialize(order_group); end
-
-  def warn_about_expectations(); end
-
-  def warn_about_expectations=(warn_about_expectations); end
-end
-
-class RSpec::Mocks::ProxyForNil
-end
-
-class RSpec::Mocks::RootSpace
-  def any_instance_proxy_for(*_args); end
-
-  def any_instance_recorder_for(*_args); end
-
-  def any_instance_recorders_from_ancestry_of(_object); end
-
-  def new_scope(); end
-
-  def proxy_for(*_args); end
-
-  def register_constant_mutator(_mutator); end
-
-  def registered?(_object); end
-
-  def reset_all(); end
-
-  def superclass_proxy_for(*_args); end
-
-  def verify_all(); end
-end
-
-class RSpec::Mocks::RootSpace
-end
-
-class RSpec::Mocks::SimpleMessageExpectation
-  def called_max_times?(); end
-
-  def initialize(message, response, error_generator, backtrace_line=T.unsafe(nil)); end
-
-  def invoke(*_); end
-
-  def matches?(message, *_); end
-
-  def unadvise(_); end
-
-  def verify_messages_received(); end
-end
-
-class RSpec::Mocks::SimpleMessageExpectation
-end
-
-class RSpec::Mocks::Space
-  def any_instance_mutex(); end
-
-  def any_instance_proxy_for(klass); end
-
-  def any_instance_recorder_for(klass, only_return_existing=T.unsafe(nil)); end
-
-  def any_instance_recorders(); end
-
-  def any_instance_recorders_from_ancestry_of(object); end
-
-  def constant_mutator_for(name); end
-
-  def ensure_registered(object); end
-
-  def new_scope(); end
-
-  def proxies(); end
-
-  def proxies_of(klass); end
-
-  def proxy_for(object); end
-
-  def proxy_mutex(); end
-
-  def register_constant_mutator(mutator); end
-
-  def registered?(object); end
-
-  def reset_all(); end
-
-  def superclass_proxy_for(klass); end
-
-  def verify_all(); end
-end
-
-class RSpec::Mocks::Space
-end
-
-class RSpec::Mocks::StubChain
-end
-
-class RSpec::Mocks::StubChain
-  def self.stub_chain_on(object, *chain, &blk); end
-end
-
-module RSpec::Mocks::Syntax
-end
-
-module RSpec::Mocks::Syntax
-  def self.default_should_syntax_host(); end
-
-  def self.disable_expect(syntax_host=T.unsafe(nil)); end
-
-  def self.disable_should(syntax_host=T.unsafe(nil)); end
-
-  def self.enable_expect(syntax_host=T.unsafe(nil)); end
-
-  def self.enable_should(syntax_host=T.unsafe(nil)); end
-
-  def self.expect_enabled?(syntax_host=T.unsafe(nil)); end
-
-  def self.should_enabled?(syntax_host=T.unsafe(nil)); end
-
-  def self.warn_about_should!(); end
-
-  def self.warn_unless_should_configured(method_name, replacement=T.unsafe(nil)); end
-end
-
-class RSpec::Mocks::TargetBase
-  include ::RSpec::Mocks::TargetDelegationInstanceMethods
-  def initialize(target); end
-end
-
-class RSpec::Mocks::TargetBase
-  extend ::RSpec::Mocks::TargetDelegationClassMethods
-end
-
-module RSpec::Mocks::TargetDelegationClassMethods
-  def delegate_not_to(matcher_method, options=T.unsafe(nil)); end
-
-  def delegate_to(matcher_method); end
-
-  def disallow_negation(method_name); end
-end
-
-module RSpec::Mocks::TargetDelegationClassMethods
-end
-
-module RSpec::Mocks::TargetDelegationInstanceMethods
-  def target(); end
-end
-
-module RSpec::Mocks::TargetDelegationInstanceMethods
-end
-
-module RSpec::Mocks::TestDouble
-  def ==(other); end
-
-  def __build_mock_proxy_unless_expired(order_group); end
-
-  def __disallow_further_usage!(); end
-
-  def as_null_object(); end
-
-  def freeze(); end
-
-  def initialize(name=T.unsafe(nil), stubs=T.unsafe(nil)); end
-
-  def inspect(); end
-
-  def null_object?(); end
-
-  def respond_to?(message, incl_private=T.unsafe(nil)); end
-
-  def to_s(); end
-end
-
-module RSpec::Mocks::TestDouble
-end
-
-module RSpec::Mocks::TestDoubleFormatter
-end
-
-module RSpec::Mocks::TestDoubleFormatter
-  def self.format(dbl, unwrap=T.unsafe(nil)); end
-end
-
-class RSpec::Mocks::TestDoubleProxy
-end
-
-class RSpec::Mocks::TestDoubleProxy
-end
-
-class RSpec::Mocks::UnsupportedMatcherError
-end
-
-class RSpec::Mocks::UnsupportedMatcherError
-end
-
-module RSpec::Mocks::VerifyingDouble
-  def __send__(name, *args, &block); end
-
-  def initialize(doubled_module, *args); end
-
-  def method_missing(message, *args, &block); end
-
-  def respond_to?(message, include_private=T.unsafe(nil)); end
-
-  def send(name, *args, &block); end
-end
-
-module RSpec::Mocks::VerifyingDouble::SilentIO
-end
-
-module RSpec::Mocks::VerifyingDouble::SilentIO
-end
-
-module RSpec::Mocks::VerifyingDouble
-end
-
-class RSpec::Mocks::VerifyingDoubleNotDefinedError
-end
-
-class RSpec::Mocks::VerifyingDoubleNotDefinedError
-end
-
-class RSpec::Mocks::VerifyingExistingClassNewMethodDouble
-end
-
-class RSpec::Mocks::VerifyingExistingClassNewMethodDouble
-end
-
-class RSpec::Mocks::VerifyingExistingMethodDouble
-  def initialize(object, method_name, proxy); end
-
-  def unimplemented?(); end
-
-  def with_signature(); end
-end
-
-class RSpec::Mocks::VerifyingExistingMethodDouble
-  def self.for(object, method_name, proxy); end
-end
-
-class RSpec::Mocks::VerifyingMessageExpectation
-  def initialize(*args); end
-
-  def method_reference(); end
-
-  def method_reference=(method_reference); end
-end
-
-class RSpec::Mocks::VerifyingMessageExpectation
-end
-
-class RSpec::Mocks::VerifyingMethodDouble
-  def add_expectation(*args, &block); end
-
-  def add_stub(*args, &block); end
-
-  def initialize(object, method_name, proxy, method_reference); end
-
-  def proxy_method_invoked(obj, *args, &block); end
-
-  def validate_arguments!(actual_args); end
-end
-
-class RSpec::Mocks::VerifyingMethodDouble
-end
-
-class RSpec::Mocks::VerifyingPartialClassDoubleProxy
-  include ::RSpec::Mocks::PartialClassDoubleProxyMethods
-end
-
-class RSpec::Mocks::VerifyingPartialClassDoubleProxy
-end
-
-class RSpec::Mocks::VerifyingPartialDoubleProxy
-  include ::RSpec::Mocks::VerifyingProxyMethods
-  def ensure_implemented(_method_name); end
-
-  def initialize(object, expectation_ordering, optional_callback_invocation_strategy=T.unsafe(nil)); end
-
-  def method_reference(); end
-end
-
-class RSpec::Mocks::VerifyingPartialDoubleProxy
-end
-
-class RSpec::Mocks::VerifyingProxy
-  include ::RSpec::Mocks::VerifyingProxyMethods
-  def initialize(object, order_group, doubled_module, method_reference_class); end
-
-  def method_reference(); end
-
-  def validate_arguments!(method_name, args); end
-
-  def visibility_for(method_name); end
-end
-
-class RSpec::Mocks::VerifyingProxy
-end
-
-module RSpec::Mocks::VerifyingProxyMethods
-  def add_message_expectation(method_name, opts=T.unsafe(nil), &block); end
-
-  def add_simple_stub(method_name, *args); end
-
-  def add_stub(method_name, opts=T.unsafe(nil), &implementation); end
-
-  def ensure_implemented(method_name); end
-
-  def ensure_publicly_implemented(method_name, _object); end
-end
-
-module RSpec::Mocks::VerifyingProxyMethods
-end
-
-module RSpec::Mocks::Version
-  STRING = ::T.let(nil, ::T.untyped)
-end
-
-module RSpec::Mocks::Version
-end
-
-module RSpec::Mocks
-  def self.allow_message(subject, message, opts=T.unsafe(nil), &block); end
-
-  def self.configuration(); end
-
-  def self.error_generator(); end
-
-  def self.expect_message(subject, message, opts=T.unsafe(nil), &block); end
-
-  def self.setup(); end
-
-  def self.space(); end
-
-  def self.teardown(); end
-
-  def self.verify(); end
-
-  def self.with_temporary_scope(); end
-end
-
-class RSpec::Retry
-  def attempts(); end
-
-  def attempts=(val); end
-
-  def clear_lets(); end
-
-  def context(); end
-
-  def current_example(); end
-
-  def display_try_failure_messages?(); end
-
-  def ex(); end
-
-  def exceptions_to_hard_fail(); end
-
-  def exceptions_to_retry(); end
-
-  def initialize(ex, opts=T.unsafe(nil)); end
-
-  def retry_count(); end
-
-  def run(); end
-
-  def sleep_interval(); end
-
-  def verbose_retry?(); end
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Retry
-  def self.setup(); end
-end
-
-RSpec::SharedContext = RSpec::Core::SharedContext
-
-module RSpec::Sorbet
-end
-
-module RSpec::Sorbet::Doubles
-  def allow_doubles!(); end
-
-  def allow_instance_doubles!(); end
-  INLINE_DOUBLE_REGEX = ::T.let(nil, ::T.untyped)
-  TYPED_ARRAY_MESSAGE = ::T.let(nil, ::T.untyped)
-  VERIFYING_DOUBLE_OR_DOUBLE = ::T.let(nil, ::T.untyped)
-end
-
-module RSpec::Sorbet::Doubles
-end
-
-module RSpec::Sorbet
-  extend ::RSpec::Sorbet::Doubles
-end
-
-module RSpec::Support
-  DEFAULT_FAILURE_NOTIFIER = ::T.let(nil, ::T.untyped)
-  DEFAULT_WARNING_NOTIFIER = ::T.let(nil, ::T.untyped)
-  KERNEL_METHOD_METHOD = ::T.let(nil, ::T.untyped)
-end
-
-module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
-  AVOID_RESCUING = ::T.let(nil, ::T.untyped)
-end
-
-module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
-  def self.===(exception); end
-end
-
-class RSpec::Support::BlockSignature
-end
-
-class RSpec::Support::BlockSignature
-end
-
-class RSpec::Support::ComparableVersion
-  include ::Comparable
-  def initialize(string); end
-
-  def segments(); end
-
-  def string(); end
-end
-
-class RSpec::Support::ComparableVersion
-end
-
-class RSpec::Support::Differ
-  def color?(); end
-
-  def diff(actual, expected); end
-
-  def diff_as_object(actual, expected); end
-
-  def diff_as_string(actual, expected); end
-
-  def initialize(opts=T.unsafe(nil)); end
-end
-
-class RSpec::Support::Differ
-end
-
-class RSpec::Support::DirectoryMaker
-end
-
-class RSpec::Support::DirectoryMaker
-  def self.mkdir_p(path); end
-end
-
-class RSpec::Support::EncodedString
-  def <<(string); end
-
-  def ==(*args, &block); end
-
-  def empty?(*args, &block); end
-
-  def encoding(*args, &block); end
-
-  def eql?(*args, &block); end
-
-  def initialize(string, encoding=T.unsafe(nil)); end
-
-  def lines(*args, &block); end
-
-  def source_encoding(); end
-
-  def split(regex_or_string); end
-
-  def to_str(); end
-  REPLACE = ::T.let(nil, ::T.untyped)
-  US_ASCII = ::T.let(nil, ::T.untyped)
-  UTF_8 = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Support::EncodedString
-  def self.pick_encoding(source_a, source_b); end
-end
-
-module RSpec::Support::FuzzyMatcher
-end
-
-module RSpec::Support::FuzzyMatcher
-  def self.values_match?(expected, actual); end
-end
-
-class RSpec::Support::LooseSignatureVerifier
-end
-
-class RSpec::Support::LooseSignatureVerifier::SignatureWithKeywordArgumentsMatcher
-  def has_kw_args_in?(args); end
-
-  def initialize(signature); end
-
-  def invalid_kw_args_from(_kw_args); end
-
-  def missing_kw_args_from(_kw_args); end
-
-  def non_kw_args_arity_description(); end
-
-  def valid_non_kw_args?(*args); end
-end
-
-class RSpec::Support::LooseSignatureVerifier::SignatureWithKeywordArgumentsMatcher
-end
-
-class RSpec::Support::LooseSignatureVerifier
-end
-
-class RSpec::Support::MethodSignature
-  def arbitrary_kw_args?(); end
-
-  def classify_arity(arity=T.unsafe(nil)); end
-
-  def classify_parameters(); end
-
-  def could_contain_kw_args?(args); end
-
-  def description(); end
-
-  def has_kw_args_in?(args); end
-
-  def initialize(method); end
-
-  def invalid_kw_args_from(given_kw_args); end
-
-  def max_non_kw_args(); end
-
-  def min_non_kw_args(); end
-
-  def missing_kw_args_from(given_kw_args); end
-
-  def non_kw_args_arity_description(); end
-
-  def optional_kw_args(); end
-
-  def required_kw_args(); end
-
-  def unlimited_args?(); end
-
-  def valid_non_kw_args?(positional_arg_count, optional_max_arg_count=T.unsafe(nil)); end
-  INFINITY = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Support::MethodSignature
-end
-
-class RSpec::Support::MethodSignatureExpectation
-  def empty?(); end
-
-  def expect_arbitrary_keywords(); end
-
-  def expect_arbitrary_keywords=(expect_arbitrary_keywords); end
-
-  def expect_unlimited_arguments(); end
-
-  def expect_unlimited_arguments=(expect_unlimited_arguments); end
-
-  def keywords(); end
-
-  def keywords=(values); end
-
-  def max_count(); end
-
-  def max_count=(number); end
-
-  def min_count(); end
-
-  def min_count=(number); end
-end
-
-class RSpec::Support::MethodSignatureExpectation
-end
-
-class RSpec::Support::MethodSignatureVerifier
-  def error_message(); end
-
-  def initialize(signature, args=T.unsafe(nil)); end
-
-  def kw_args(); end
-
-  def max_non_kw_args(); end
-
-  def min_non_kw_args(); end
-
-  def non_kw_args(); end
-
-  def valid?(); end
-
-  def with_expectation(expectation); end
-end
-
-class RSpec::Support::MethodSignatureVerifier
-end
-
-class RSpec::Support::Mutex
-  NEW_MUTEX_METHOD = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Support::Mutex
-  def self.new(); end
-end
-
-module RSpec::Support::OS
-end
-
-module RSpec::Support::OS
-  def self.windows?(); end
-
-  def self.windows_file_path?(); end
-end
-
-class RSpec::Support::ObjectFormatter
-  def format(object); end
-
-  def initialize(max_formatted_output_length=T.unsafe(nil)); end
-
-  def max_formatted_output_length(); end
-
-  def max_formatted_output_length=(max_formatted_output_length); end
-
-  def prepare_array(array); end
-
-  def prepare_element(element); end
-
-  def prepare_for_inspection(object); end
-
-  def prepare_hash(input_hash); end
-
-  def recursive_structure?(object); end
-
-  def sort_hash_keys(input_hash); end
-
-  def with_entering_structure(structure); end
-  ELLIPSIS = ::T.let(nil, ::T.untyped)
-  INSPECTOR_CLASSES = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Support::ObjectFormatter::BaseInspector
-  def formatter(); end
-
-  def formatter=(_); end
-
-  def object(); end
-
-  def object=(_); end
-
-  def pretty_print(pp); end
-end
-
-class RSpec::Support::ObjectFormatter::BaseInspector
-  def self.[](*arg); end
-
-  def self.can_inspect?(_object); end
-
-  def self.members(); end
-end
-
-class RSpec::Support::ObjectFormatter::BigDecimalInspector
-end
-
-class RSpec::Support::ObjectFormatter::BigDecimalInspector
-  def self.can_inspect?(object); end
-end
-
-class RSpec::Support::ObjectFormatter::DateTimeInspector
-  FORMAT = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Support::ObjectFormatter::DateTimeInspector
-  def self.can_inspect?(object); end
-end
-
-class RSpec::Support::ObjectFormatter::DelegatorInspector
-end
-
-class RSpec::Support::ObjectFormatter::DelegatorInspector
-  def self.can_inspect?(object); end
-end
-
-class RSpec::Support::ObjectFormatter::DescribableMatcherInspector
-end
-
-class RSpec::Support::ObjectFormatter::DescribableMatcherInspector
-  def self.can_inspect?(object); end
-end
-
-class RSpec::Support::ObjectFormatter::InspectableItem
-  def pretty_print(pp); end
-
-  def text(); end
-
-  def text=(_); end
-end
-
-class RSpec::Support::ObjectFormatter::InspectableItem
-  def self.[](*arg); end
-
-  def self.members(); end
-end
-
-class RSpec::Support::ObjectFormatter::InspectableObjectInspector
-end
-
-class RSpec::Support::ObjectFormatter::InspectableObjectInspector
-  def self.can_inspect?(object); end
-end
-
-class RSpec::Support::ObjectFormatter::TimeInspector
-  FORMAT = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Support::ObjectFormatter::TimeInspector
-  def self.can_inspect?(object); end
-end
-
-class RSpec::Support::ObjectFormatter::UninspectableObjectInspector
-  def klass(); end
-
-  def native_object_id(); end
-  OBJECT_ID_FORMAT = ::T.let(nil, ::T.untyped)
-end
-
-class RSpec::Support::ObjectFormatter::UninspectableObjectInspector
-  def self.can_inspect?(object); end
-end
-
-class RSpec::Support::ObjectFormatter
-  def self.default_instance(); end
-
-  def self.format(object); end
-
-  def self.prepare_for_inspection(object); end
-end
-
-module RSpec::Support::RecursiveConstMethods
-  def const_defined_on?(mod, const_name); end
-
-  def constants_defined_on(mod); end
-
-  def get_const_defined_on(mod, const_name); end
-
-  def normalize_const_name(const_name); end
-
-  def recursive_const_defined?(const_name); end
-
-  def recursive_const_get(const_name); end
-end
-
-module RSpec::Support::RecursiveConstMethods
-end
-
-class RSpec::Support::ReentrantMutex
-  def synchronize(); end
-end
-
-class RSpec::Support::ReentrantMutex
-end
-
-module RSpec::Support::Ruby
-end
-
-module RSpec::Support::Ruby
-  def self.jruby?(); end
-
-  def self.jruby_9000?(); end
-
-  def self.jruby_version(); end
-
-  def self.mri?(); end
-
-  def self.non_mri?(); end
-
-  def self.rbx?(); end
-
-  def self.truffleruby?(); end
-end
-
-module RSpec::Support::RubyFeatures
-end
-
-module RSpec::Support::RubyFeatures
-  def self.caller_locations_supported?(); end
-
-  def self.fork_supported?(); end
-
-  def self.kw_args_supported?(); end
-
-  def self.module_prepends_supported?(); end
-
-  def self.module_refinement_supported?(); end
-
-  def self.optional_and_splat_args_supported?(); end
-
-  def self.required_kw_args_supported?(); end
-
-  def self.ripper_supported?(); end
-
-  def self.supports_exception_cause?(); end
-
-  def self.supports_rebinding_module_methods?(); end
-
-  def self.supports_taint?(); end
-end
-
-RSpec::Support::StrictSignatureVerifier = RSpec::Support::MethodSignatureVerifier
-
-module RSpec::Support::Version
-  STRING = ::T.let(nil, ::T.untyped)
-end
-
-module RSpec::Support::Version
-end
-
-module RSpec::Support::Warnings
-  def deprecate(deprecated, options=T.unsafe(nil)); end
-
-  def warn_deprecation(message, options=T.unsafe(nil)); end
-
-  def warn_with(message, options=T.unsafe(nil)); end
-
-  def warning(text, options=T.unsafe(nil)); end
-end
-
-module RSpec::Support::Warnings
-end
-
-module RSpec::Support::WithKeywordsWhenNeeded
-end
-
-module RSpec::Support::WithKeywordsWhenNeeded
-  def self.class_exec(klass, *args, &block); end
-end
-
-module RSpec::Support
-  def self.class_of(object); end
-
-  def self.define_optimized_require_for_rspec(lib, &require_relative); end
-
-  def self.deregister_matcher_definition(&block); end
-
-  def self.failure_notifier(); end
-
-  def self.failure_notifier=(callable); end
-
-  def self.is_a_matcher?(object); end
-
-  def self.matcher_definitions(); end
-
-  def self.method_handle_for(object, method_name); end
-
-  def self.notify_failure(failure, options=T.unsafe(nil)); end
-
-  def self.register_matcher_definition(&block); end
-
-  def self.require_rspec_core(f); end
-
-  def self.require_rspec_expectations(f); end
-
-  def self.require_rspec_matchers(f); end
-
-  def self.require_rspec_mocks(f); end
-
-  def self.require_rspec_support(f); end
-
-  def self.rspec_description_for_object(object); end
-
-  def self.thread_local_data(); end
-
-  def self.warning_notifier(); end
-
-  def self.warning_notifier=(warning_notifier); end
-
-  def self.with_failure_notifier(callable); end
-end
-
-module RSpec::Version
-  STRING = ::T.let(nil, ::T.untyped)
-end
-
-module RSpec::Version
-end
-
-module RSpec::Wait
-end
-
-class RSpec::Wait::Error
-end
-
-class RSpec::Wait::Error
-end
-
-module RSpec::Wait::Handler
-  def handle_matcher(target, *args, &block); end
-end
-
-module RSpec::Wait::Handler
-end
-
-class RSpec::Wait::NegativeHandler
-end
-
-class RSpec::Wait::NegativeHandler
-  extend ::RSpec::Wait::Handler
-end
-
-class RSpec::Wait::PositiveHandler
-end
-
-class RSpec::Wait::PositiveHandler
-  extend ::RSpec::Wait::Handler
-end
-
-class RSpec::Wait::Proxy
-  def for(value=T.unsafe(nil), &block); end
-
-  def initialize(options); end
-end
-
-class RSpec::Wait::Proxy
-end
-
-class RSpec::Wait::Target
-  def initialize(target, options); end
-end
-
-module RSpec::Wait::Target::UndefinedValue
-end
-
-module RSpec::Wait::Target::UndefinedValue
-end
-
-class RSpec::Wait::Target
-  def self.for(value, block, options=T.unsafe(nil)); end
-end
-
-class RSpec::Wait::TimeoutError
-end
-
-class RSpec::Wait::TimeoutError
-end
-
-module RSpec::Wait
-  def self.wait(timeout=T.unsafe(nil), options=T.unsafe(nil)); end
-
-  def self.wait_for(value=T.unsafe(nil), &block); end
-
-  def self.with_wait(options); end
-end
-
-module RSpec
-  extend ::RSpec::Support::Warnings
-  extend ::RSpec::Core::Warnings
-  def self.clear_examples(); end
-
-  def self.configuration(); end
-
-  def self.configuration=(configuration); end
-
-  def self.configure(); end
-
-  def self.const_missing(name); end
-
-  def self.context(*args, &example_group_block); end
-
-  def self.current_example(); end
-
-  def self.current_example=(example); end
-
-  def self.describe(*args, &example_group_block); end
-
-  def self.example_group(*args, &example_group_block); end
-
-  def self.fcontext(*args, &example_group_block); end
-
-  def self.fdescribe(*args, &example_group_block); end
-
-  def self.reset(); end
-
-  def self.world(); end
-
-  def self.world=(world); end
-
-  def self.xcontext(*args, &example_group_block); end
-
-  def self.xdescribe(*args, &example_group_block); end
-end
-
-class RSpecJUnitFormatter
-  def dump_summary(notification); end
-
-  def stop(notification); end
-  DISCOURAGED_REGEXP = ::T.let(nil, ::T.untyped)
-  DISCOURAGED_REPLACEMENTS = ::T.let(nil, ::T.untyped)
-  ILLEGAL_REGEXP = ::T.let(nil, ::T.untyped)
-  ILLEGAL_REPLACEMENT = ::T.let(nil, ::T.untyped)
-  STRIP_DIFF_COLORS_BLOCK_REGEXP = ::T.let(nil, ::T.untyped)
-  STRIP_DIFF_COLORS_CODES_REGEXP = ::T.let(nil, ::T.untyped)
-end
-
-class RSpecJUnitFormatter
 end
 
 module Racc
@@ -26558,1755 +7177,6 @@ end
 class Racc::CparseParams
 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
-
-module Rack::Auth
-end
-
-class Rack::Auth::AbstractHandler
-  def initialize(app, realm=T.unsafe(nil), &authenticator); end
-
-  def realm(); end
-
-  def realm=(realm); end
-end
-
-class Rack::Auth::AbstractHandler
-end
-
-class Rack::Auth::AbstractRequest
-  def initialize(env); end
-
-  def params(); end
-
-  def parts(); end
-
-  def provided?(); end
-
-  def request(); end
-
-  def scheme(); end
-
-  def valid?(); end
-  AUTHORIZATION_KEYS = ::T.let(nil, ::T.untyped)
-end
-
-class Rack::Auth::AbstractRequest
-end
-
-class Rack::Auth::Basic
-  def call(env); end
-end
-
-class Rack::Auth::Basic::Request
-  def basic?(); end
-
-  def credentials(); end
-
-  def username(); end
-end
-
-class Rack::Auth::Basic::Request
-end
-
-class Rack::Auth::Basic
-end
-
-module Rack::Auth::Digest
-end
-
-class Rack::Auth::Digest::MD5
-  def call(env); end
-
-  def initialize(app, realm=T.unsafe(nil), opaque=T.unsafe(nil), &authenticator); end
-
-  def opaque(); end
-
-  def opaque=(opaque); end
-
-  def passwords_hashed=(passwords_hashed); end
-
-  def passwords_hashed?(); end
-  QOP = ::T.let(nil, ::T.untyped)
-end
-
-class Rack::Auth::Digest::MD5
-end
-
-class Rack::Auth::Digest::Nonce
-  def digest(); end
-
-  def fresh?(); end
-
-  def initialize(timestamp=T.unsafe(nil), given_digest=T.unsafe(nil)); end
-
-  def stale?(); end
-
-  def valid?(); end
-end
-
-class Rack::Auth::Digest::Nonce
-  def self.parse(string); end
-
-  def self.private_key(); end
-
-  def self.private_key=(private_key); end
-
-  def self.time_limit(); end
-
-  def self.time_limit=(time_limit); end
-end
-
-class Rack::Auth::Digest::Params
-  def [](k); end
-
-  def []=(k, v); end
-
-  def initialize(); end
-
-  def quote(str); end
-  UNQUOTED = ::T.let(nil, ::T.untyped)
-end
-
-class Rack::Auth::Digest::Params
-  def self.dequote(str); end
-
-  def self.parse(str); end
-
-  def self.split_header_value(str); end
-end
-
-class Rack::Auth::Digest::Request
-  def correct_uri?(); end
-
-  def digest?(); end
-
-  def method(); end
-
-  def method_missing(sym, *args); end
-
-  def nonce(); end
-
-  def respond_to?(sym, *arg); end
-end
-
-class Rack::Auth::Digest::Request
-end
-
-module Rack::Auth::Digest
-end
-
-module Rack::Auth
-end
-
-class Rack::BodyProxy
-  def close(); end
-
-  def closed?(); end
-
-  def initialize(body, &block); end
-
-  def method_missing(method_name, *args, &block); end
-end
-
-class Rack::BodyProxy
-end
-
-class Rack::Builder
-  def call(env); end
-
-  def freeze_app(); end
-
-  def initialize(default_app=T.unsafe(nil), &block); end
-
-  def map(path, &block); end
-
-  def run(app); end
-
-  def to_app(); end
-
-  def use(middleware, *args, &block); end
-
-  def warmup(prc=T.unsafe(nil), &block); end
-  UTF_8_BOM = ::T.let(nil, ::T.untyped)
-end
-
-class Rack::Builder
-  def self.app(default_app=T.unsafe(nil), &block); end
-
-  def self.load_file(path, opts=T.unsafe(nil)); end
-
-  def self.new_from_string(builder_script, file=T.unsafe(nil)); end
-
-  def self.parse_file(config, opts=T.unsafe(nil)); end
-end
-
-class Rack::Cascade
-  def <<(app); 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.[](*arg); 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.[](*arg); 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(*arg); end
-
-  def generate_sid(*arg); 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(arg); end
 end
@@ -28316,8 +7186,6 @@ class Range
 
   def entries(); end
 
-  def sum(identity=T.unsafe(nil)); end
-
   def to_a(); end
 end
 
@@ -28427,264 +7295,6 @@ class ResourceStageContext
   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
-
-  def styles(); end
-
-  def styles=(styles); end
-
-  def tagline(); end
-
-  def tagline=(tagline); end
-
-  def title(); end
-
-  def title?(); end
-
-  def to_h(); end
-
-  def to_html(); end
-
-  def to_html_fragment(wrap_class=T.unsafe(nil)); end
-
-  def to_json(); end
-
-  def to_markdown(); end
-
-  def to_roff(); end
-
-  def to_yaml(); end
-
-  def toc(); end
-end
-
-class Ronn::Document
-end
-
-class Ronn::Index
-  include ::Enumerable
-  def <<(path); end
-
-  def [](name); end
-
-  def add_manual(manual); end
-
-  def each(&bk); end
-
-  def empty?(); end
-
-  def exist?(); end
-
-  def first(); end
-
-  def initialize(path, &bk); end
-
-  def last(); end
-
-  def manual(path); end
-
-  def manuals(); end
-
-  def path(); end
-
-  def read!(data); end
-
-  def reference(name, path); end
-
-  def references(); end
-
-  def relative_to_index(path); end
-
-  def size(); end
-
-  def to_a(); end
-
-  def to_h(); end
-
-  def to_text(); end
-end
-
-class Ronn::Index
-  def self.[](path); end
-
-  def self.index_path_for_file(file); end
-end
-
-class Ronn::Template
-  def custom_title?(); end
-
-  def date(); end
-
-  def generator(); end
-
-  def initialize(document, style_path=T.unsafe(nil)); end
-
-  def inline_stylesheet(path, media=T.unsafe(nil)); end
-
-  def manual(); end
-
-  def missing_styles(); end
-
-  def name(); end
-
-  def name_and_section?(); end
-
-  def organization(); end
-
-  def page_name(); end
-
-  def remote_stylesheet(name, media=T.unsafe(nil)); end
-
-  def render(template=T.unsafe(nil)); end
-
-  def section(); end
-
-  def section_heads(); end
-
-  def style_files(); end
-
-  def style_path(); end
-
-  def style_path=(style_path); end
-
-  def styles(); end
-
-  def stylesheet(path, media=T.unsafe(nil)); end
-
-  def stylesheet_tags(); end
-
-  def stylesheets(); end
-
-  def tagline(); end
-
-  def tagline?(); end
-
-  def title(); end
-
-  def wrap_class_name(); end
-end
-
-class Ronn::Template
-end
-
-module Ronn::Utils
-  def block_element?(name); end
-
-  def child_of?(node, tag); end
-
-  def empty_element?(name); end
-
-  def html_element?(name); end
-
-  def inline_element?(name); end
-  HTML = ::T.let(nil, ::T.untyped)
-  HTML_BLOCK = ::T.let(nil, ::T.untyped)
-  HTML_EMPTY = ::T.let(nil, ::T.untyped)
-  HTML_INLINE = ::T.let(nil, ::T.untyped)
-end
-
-module Ronn::Utils
-end
-
-module Ronn
-  def self.new(filename, attributes=T.unsafe(nil), &block); end
-
-  def self.release?(); end
-
-  def self.revision(); end
-
-  def self.version(); end
-end
-
-RspecJunitFormatter = RSpecJUnitFormatter
-
 module RuboCop::AST::CollectionNode
   def abbrev(*args, &block); end
 
@@ -29999,783 +8609,8 @@ module SharedEnvExtension
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
-module SimpleCov
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
-class SimpleCov::ArrayFilter
-  def matches?(source_files_list); end
-end
-
-class SimpleCov::ArrayFilter
-end
-
-class SimpleCov::BlockFilter
-  def matches?(source_file); end
-end
-
-class SimpleCov::BlockFilter
-end
-
-module SimpleCov::Combine
-end
-
-module SimpleCov::Combine::BranchesCombiner
-end
-
-module SimpleCov::Combine::BranchesCombiner
-  def self.combine(coverage_a, coverage_b); end
-end
-
-module SimpleCov::Combine::FilesCombiner
-end
-
-module SimpleCov::Combine::FilesCombiner
-  def self.combine(coverage_a, coverage_b); end
-end
-
-module SimpleCov::Combine::LinesCombiner
-end
-
-module SimpleCov::Combine::LinesCombiner
-  def self.combine(coverage_a, coverage_b); end
-
-  def self.merge_line_coverage(first_val, second_val); end
-end
-
-module SimpleCov::Combine::ResultsCombiner
-end
-
-module SimpleCov::Combine::ResultsCombiner
-  def self.combine(*results); end
-
-  def self.combine_file_coverage(coverage_a, coverage_b); end
-
-  def self.combine_result_sets(combined_results, result); end
-end
-
-module SimpleCov::Combine
-  def self.combine(combiner_module, coverage_a, coverage_b); end
-
-  def self.empty_coverage?(coverage_a, coverage_b); end
-
-  def self.existing_coverage(coverage_a, coverage_b); end
-end
-
-module SimpleCov::CommandGuesser
-end
-
-module SimpleCov::CommandGuesser
-  def self.guess(); end
-
-  def self.original_run_command(); end
-
-  def self.original_run_command=(original_run_command); end
-end
-
-module SimpleCov::Configuration
-  def adapters(); end
-
-  def add_filter(filter_argument=T.unsafe(nil), &filter_proc); end
-
-  def add_group(group_name, filter_argument=T.unsafe(nil), &filter_proc); end
-
-  def at_exit(&block); end
-
-  def at_fork(&block); end
-
-  def branch_coverage?(); end
-
-  def branch_coverage_supported?(); end
-
-  def clear_coverage_criteria(); end
-
-  def command_name(name=T.unsafe(nil)); end
-
-  def configure(&block); end
-
-  def coverage_criteria(); end
-
-  def coverage_criterion(criterion=T.unsafe(nil)); end
-
-  def coverage_criterion_enabled?(criterion); end
-
-  def coverage_dir(dir=T.unsafe(nil)); end
-
-  def coverage_path(); end
-
-  def coverage_start_arguments_supported?(); end
-
-  def enable_coverage(criterion); end
-
-  def enable_for_subprocesses(value=T.unsafe(nil)); end
-
-  def enabled_for_subprocesses?(); end
-
-  def filters(); end
-
-  def filters=(filters); end
-
-  def formatter(formatter=T.unsafe(nil)); end
-
-  def formatter=(formatter); end
-
-  def formatters(); end
-
-  def formatters=(formatters); end
-
-  def groups(); end
-
-  def groups=(groups); end
-
-  def maximum_coverage_drop(coverage_drop=T.unsafe(nil)); end
-
-  def merge_timeout(seconds=T.unsafe(nil)); end
-
-  def minimum_coverage(coverage=T.unsafe(nil)); end
-
-  def minimum_coverage_by_file(coverage=T.unsafe(nil)); end
-
-  def nocov_token(nocov_token=T.unsafe(nil)); end
-
-  def primary_coverage(criterion=T.unsafe(nil)); end
-
-  def print_error_status(); end
-
-  def print_error_status=(print_error_status); end
-
-  def profiles(); end
-
-  def project_name(new_name=T.unsafe(nil)); end
-
-  def raise_on_invalid_coverage(coverage, coverage_setting); end
-
-  def refuse_coverage_drop(*criteria); end
-
-  def root(root=T.unsafe(nil)); end
-
-  def skip_token(nocov_token=T.unsafe(nil)); end
-
-  def track_files(glob); end
-
-  def tracked_files(); end
-
-  def use_merging(use=T.unsafe(nil)); end
-  DEFAULT_COVERAGE_CRITERION = ::T.let(nil, ::T.untyped)
-  SUPPORTED_COVERAGE_CRITERIA = ::T.let(nil, ::T.untyped)
-end
-
-module SimpleCov::Configuration
-end
-
-class SimpleCov::CoverageStatistics
-  def covered(); end
-
-  def initialize(covered:, missed:, total_strength: T.unsafe(nil)); end
-
-  def missed(); end
-
-  def percent(); end
-
-  def strength(); end
-
-  def total(); end
-end
-
-class SimpleCov::CoverageStatistics
-  def self.from(coverage_statistics); end
-end
-
-module SimpleCov::ExitCodes
-  EXCEPTION = ::T.let(nil, ::T.untyped)
-  MAXIMUM_COVERAGE_DROP = ::T.let(nil, ::T.untyped)
-  MINIMUM_COVERAGE = ::T.let(nil, ::T.untyped)
-  SUCCESS = ::T.let(nil, ::T.untyped)
-end
-
-module SimpleCov::ExitCodes::ExitCodeHandling
-end
-
-module SimpleCov::ExitCodes::ExitCodeHandling
-  def self.call(result, coverage_limits:); end
-
-  def self.coverage_checks(result, coverage_limits); end
-end
-
-class SimpleCov::ExitCodes::MaximumCoverageDropCheck
-  def exit_code(); end
-
-  def failing?(); end
-
-  def initialize(result, maximum_coverage_drop); end
-
-  def report(); end
-  MAX_DROP_ACCURACY = ::T.let(nil, ::T.untyped)
-end
-
-class SimpleCov::ExitCodes::MaximumCoverageDropCheck
-end
-
-class SimpleCov::ExitCodes::MinimumCoverageByFileCheck
-  def exit_code(); end
-
-  def failing?(); end
-
-  def initialize(result, minimum_coverage_by_file); end
-
-  def report(); end
-end
-
-class SimpleCov::ExitCodes::MinimumCoverageByFileCheck
-end
-
-class SimpleCov::ExitCodes::MinimumOverallCoverageCheck
-  def exit_code(); end
-
-  def failing?(); end
-
-  def initialize(result, minimum_coverage); end
-
-  def report(); end
-end
-
-class SimpleCov::ExitCodes::MinimumOverallCoverageCheck
-end
-
-module SimpleCov::ExitCodes
-end
-
-class SimpleCov::FileList
-  include ::Enumerable
-  def branch_covered_percent(); end
-
-  def count(*args, &block); end
-
-  def coverage_statistics(); end
-
-  def coverage_statistics_by_file(); end
-
-  def covered_branches(); end
-
-  def covered_lines(); end
-
-  def covered_percent(); end
-
-  def covered_percentages(); end
-
-  def covered_strength(); end
-
-  def each(*args, &block); end
-
-  def empty?(*args, &block); end
-
-  def initialize(files); end
-
-  def least_covered_file(); end
-
-  def length(*args, &block); end
-
-  def lines_of_code(); end
-
-  def map(*args, &block); end
-
-  def missed_branches(); end
-
-  def missed_lines(); end
-
-  def never_lines(); end
-
-  def size(*args, &block); end
-
-  def skipped_lines(); end
-
-  def to_a(*args, &block); end
-
-  def to_ary(*args, &block); end
-
-  def total_branches(); end
-end
-
-class SimpleCov::FileList
-  extend ::Forwardable
-end
-
-class SimpleCov::Filter
-  def filter_argument(); end
-
-  def initialize(filter_argument); end
-
-  def matches?(_source_file); end
-
-  def passes?(source_file); end
-end
-
-class SimpleCov::Filter
-  def self.build_filter(filter_argument); end
-
-  def self.class_for_argument(filter_argument); end
-end
-
-module SimpleCov::Formatter
-end
-
-class SimpleCov::Formatter::CoberturaFormatter
-  def format(result); end
-  DTD_URL = ::T.let(nil, ::T.untyped)
-  RESULT_FILE_NAME = ::T.let(nil, ::T.untyped)
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
-class SimpleCov::Formatter::CoberturaFormatter
-end
-
-class SimpleCov::Formatter::HTMLFormatter
-  def branchable_result?(); end
-
-  def format(result); end
-
-  def line_status?(source_file, line); end
-
-  def output_message(result); end
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-
-class SimpleCov::Formatter::HTMLFormatter
-end
-
-class SimpleCov::Formatter::JSONFormatter
-  def format(result); end
-end
-
-class SimpleCov::Formatter::JSONFormatter
-end
-
-class SimpleCov::Formatter::MultiFormatter
-end
-
-module SimpleCov::Formatter::MultiFormatter::InstanceMethods
-  def format(result); end
-end
-
-module SimpleCov::Formatter::MultiFormatter::InstanceMethods
-end
-
-class SimpleCov::Formatter::MultiFormatter
-  def self.[](*args); end
-
-  def self.new(formatters=T.unsafe(nil)); end
-end
-
-class SimpleCov::Formatter::SimpleFormatter
-  def format(result); end
-end
-
-class SimpleCov::Formatter::SimpleFormatter
-end
-
-module SimpleCov::Formatter
-  def self.from_env(env); end
-end
-
-module SimpleCov::LastRun
-end
-
-module SimpleCov::LastRun
-  def self.last_run_path(); end
-
-  def self.read(); end
-
-  def self.write(json); end
-end
-
 class SimpleCov::LinesClassifier
-  def classify(lines); end
-  COMMENT_LINE = ::T.let(nil, ::T.untyped)
   NOT_RELEVANT = ::T.let(nil, ::T.untyped)
-  RELEVANT = ::T.let(nil, ::T.untyped)
-  WHITESPACE_LINE = ::T.let(nil, ::T.untyped)
-  WHITESPACE_OR_COMMENT_LINE = ::T.let(nil, ::T.untyped)
-end
-
-class SimpleCov::LinesClassifier
-  def self.no_cov_line(); end
-
-  def self.no_cov_line?(line); end
-
-  def self.whitespace_line?(line); end
-end
-
-class SimpleCov::Profiles
-  def define(name, &blk); end
-
-  def load(name); end
-end
-
-class SimpleCov::Profiles
-end
-
-class SimpleCov::RegexFilter
-  def matches?(source_file); end
-end
-
-class SimpleCov::RegexFilter
-end
-
-class SimpleCov::Result
-  def command_name(); end
-
-  def command_name=(command_name); end
-
-  def coverage_statistics(*args, &block); end
-
-  def coverage_statistics_by_file(*args, &block); end
-
-  def covered_branches(*args, &block); end
-
-  def covered_lines(*args, &block); end
-
-  def covered_percent(*args, &block); end
-
-  def covered_percentages(*args, &block); end
-
-  def covered_strength(*args, &block); end
-
-  def created_at(); end
-
-  def created_at=(created_at); end
-
-  def filenames(); end
-
-  def files(); end
-
-  def format!(); end
-
-  def groups(); end
-
-  def initialize(original_result, command_name: T.unsafe(nil), created_at: T.unsafe(nil)); end
-
-  def least_covered_file(*args, &block); end
-
-  def missed_branches(*args, &block); end
-
-  def missed_lines(*args, &block); end
-
-  def original_result(); end
-
-  def source_files(); end
-
-  def to_hash(); end
-
-  def total_branches(*args, &block); end
-
-  def total_lines(*args, &block); end
-end
-
-class SimpleCov::Result
-  extend ::Forwardable
-  def self.from_hash(hash); end
-end
-
-class SimpleCov::ResultAdapter
-  def adapt(); end
-
-  def initialize(result); end
-
-  def result(); end
-end
-
-class SimpleCov::ResultAdapter
-  def self.call(*args); end
-end
-
-module SimpleCov::ResultMerger
-end
-
-module SimpleCov::ResultMerger
-  def self.adapt_pre_simplecov_0_18_result(result); end
-
-  def self.adapt_result(result); end
-
-  def self.create_result(command_names, coverage); end
-
-  def self.merge_and_store(*file_paths, ignore_timeout: T.unsafe(nil)); end
-
-  def self.merge_coverage(*results); end
-
-  def self.merge_results(*file_paths, ignore_timeout: T.unsafe(nil)); end
-
-  def self.merge_valid_results(results, ignore_timeout: T.unsafe(nil)); end
-
-  def self.merged_result(); end
-
-  def self.parse_file(path); end
-
-  def self.parse_json(content); end
-
-  def self.pre_simplecov_0_18_result?(result); end
-
-  def self.read_file(path); end
-
-  def self.read_resultset(); end
-
-  def self.resultset_path(); end
-
-  def self.resultset_writelock(); end
-
-  def self.store_result(result); end
-
-  def self.synchronize_resultset(); end
-
-  def self.time_since_result_creation(data); end
-
-  def self.valid_results(file_path, ignore_timeout: T.unsafe(nil)); end
-
-  def self.within_merge_timeout?(data); end
-end
-
-module SimpleCov::SimulateCoverage
-end
-
-module SimpleCov::SimulateCoverage
-  def self.call(absolute_path); end
-end
-
-class SimpleCov::SourceFile
-  def branches(); end
-
-  def branches_coverage_percent(); end
-
-  def branches_for_line(line_number); end
-
-  def branches_report(); end
-
-  def coverage_data(); end
-
-  def coverage_statistics(); end
-
-  def covered_branches(); end
-
-  def covered_lines(); end
-
-  def covered_percent(); end
-
-  def covered_strength(); end
-
-  def filename(); end
-
-  def initialize(filename, coverage_data); end
-
-  def line(number); end
-
-  def line_with_missed_branch?(line_number); end
-
-  def lines(); end
-
-  def lines_of_code(); end
-
-  def missed_branches(); end
-
-  def missed_lines(); end
-
-  def never_lines(); end
-
-  def no_branches?(); end
-
-  def no_lines?(); end
-
-  def project_filename(); end
-
-  def relevant_lines(); end
-
-  def skipped_lines(); end
-
-  def source(); end
-
-  def source_lines(); end
-
-  def src(); end
-
-  def total_branches(); end
-  RUBY_FILE_ENCODING_MAGIC_COMMENT_REGEX = ::T.let(nil, ::T.untyped)
-  SHEBANG_REGEX = ::T.let(nil, ::T.untyped)
-end
-
-class SimpleCov::SourceFile::Branch
-  def coverage(); end
-
-  def covered?(); end
-
-  def end_line(); end
-
-  def initialize(start_line:, end_line:, coverage:, inline:, type:); end
-
-  def inline?(); end
-
-  def missed?(); end
-
-  def overlaps_with?(line_range); end
-
-  def report(); end
-
-  def report_line(); end
-
-  def skipped!(); end
-
-  def skipped?(); end
-
-  def start_line(); end
-
-  def type(); end
-end
-
-class SimpleCov::SourceFile::Branch
-end
-
-class SimpleCov::SourceFile::Line
-  def coverage(); end
-
-  def covered?(); end
-
-  def initialize(src, line_number, coverage); end
-
-  def line(); end
-
-  def line_number(); end
-
-  def missed?(); end
-
-  def never?(); end
-
-  def number(); end
-
-  def skipped(); end
-
-  def skipped!(); end
-
-  def skipped?(); end
-
-  def source(); end
-
-  def src(); end
-
-  def status(); end
-end
-
-class SimpleCov::SourceFile::Line
-end
-
-class SimpleCov::SourceFile
-end
-
-class SimpleCov::StringFilter
-  def matches?(source_file); end
-end
-
-class SimpleCov::StringFilter
-end
-
-module SimpleCov::UselessResultsRemover
-end
-
-module SimpleCov::UselessResultsRemover
-  def self.call(coverage_result); end
-
-  def self.root_regx(); end
-end
-
-module SimpleCov
-  extend ::SimpleCov::Configuration
-  def self.at_exit_behavior(); end
-
-  def self.clear_result(); end
-
-  def self.collate(result_filenames, profile=T.unsafe(nil), ignore_timeout: T.unsafe(nil), &block); end
-
-  def self.exit_and_report_previous_error(exit_status); end
-
-  def self.exit_status_from_exception(); end
-
-  def self.external_at_exit(); end
-
-  def self.external_at_exit=(external_at_exit); end
-
-  def self.external_at_exit?(); end
-
-  def self.filtered(files); end
-
-  def self.final_result_process?(); end
-
-  def self.grouped(files); end
-
-  def self.load_adapter(name); end
-
-  def self.load_profile(name); end
-
-  def self.pid(); end
-
-  def self.pid=(pid); end
-
-  def self.previous_error?(error_exit_status); end
-
-  def self.process_result(result); end
-
-  def self.process_results_and_report_error(); end
-
-  def self.ready_to_process_results?(); end
-
-  def self.result(); end
-
-  def self.result?(); end
-
-  def self.result_exit_status(result); end
-
-  def self.round_coverage(coverage); end
-
-  def self.run_exit_tasks!(); end
-
-  def self.running(); end
-
-  def self.running=(running); end
-
-  def self.start(profile=T.unsafe(nil), &block); end
-
-  def self.wait_for_other_processes(); end
-
-  def self.write_last_run(result); end
-end
-
-module SimpleCovJSONFormatter
-end
-
-class SimpleCovJSONFormatter::ResultExporter
-  def export(); end
-
-  def initialize(result_hash); end
-  FILENAME = ::T.let(nil, ::T.untyped)
-end
-
-class SimpleCovJSONFormatter::ResultExporter
-end
-
-class SimpleCovJSONFormatter::ResultHashFormatter
-  def format(); end
-
-  def initialize(result); end
-end
-
-class SimpleCovJSONFormatter::ResultHashFormatter
-end
-
-class SimpleCovJSONFormatter::SourceFileFormatter
-  def format(); end
-
-  def initialize(source_file); end
-end
-
-class SimpleCovJSONFormatter::SourceFileFormatter
-end
-
-module SimpleCovJSONFormatter
 end
 
 module Singleton
@@ -31170,7 +9005,6 @@ module Spoom
 end
 
 class String
-  include ::MessagePack::CoreExt
   def black(); end
 
   def blink(); end
@@ -31189,8 +9023,6 @@ class String
 
   def hide(); end
 
-  def html_safe(); end
-
   def indent(amount, indent_string=T.unsafe(nil), indent_empty_lines=T.unsafe(nil)); end
 
   def indent!(amount, indent_string=T.unsafe(nil), indent_empty_lines=T.unsafe(nil)); end
@@ -31249,24 +9081,12 @@ class String
 
   def red(); end
 
-  def remove(*patterns); end
-
-  def remove!(*patterns); end
-
   def shellescape(); end
 
   def shellsplit(); end
 
-  def squish(); end
-
-  def squish!(); end
-
   def swap(); end
 
-  def to_date(); end
-
-  def to_datetime(); end
-
   def to_nfc(); end
 
   def to_nfd(); end
@@ -31275,14 +9095,6 @@ class String
 
   def to_nfkd(); end
 
-  def to_time(form=T.unsafe(nil)); end
-
-  def truncate(truncate_at, options=T.unsafe(nil)); end
-
-  def truncate_bytes(truncate_at, omission: T.unsafe(nil)); end
-
-  def truncate_words(words_count, options=T.unsafe(nil)); end
-
   def underline(); end
 
   def white(); end
@@ -31317,15 +9129,6 @@ module Superenv
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
-class Symbol
-  include ::MessagePack::CoreExt
-  def to_msgpack_ext(); end
-end
-
-class Symbol
-  def self.from_msgpack_ext(data); end
-end
-
 class SystemCommand::Result
   extend ::T::Private::Methods::MethodHooks
   extend ::T::Private::Methods::SingletonMethodHooks
@@ -31336,32 +9139,6 @@ class SystemCommand
   extend ::T::Private::Methods::SingletonMethodHooks
 end
 
-class TZInfo::DayOfYearTransitionRule
-  def initialize(day, transition_at); end
-
-  def seconds(); end
-end
-
-class TZInfo::DayOfYearTransitionRule
-end
-
-class TZInfo::TransitionRule
-  def ==(r); end
-
-  def at(offset, year); end
-
-  def eql?(r); end
-
-  def hash_args(); end
-
-  def initialize(transition_at); end
-
-  def transition_at(); end
-end
-
-class TZInfo::TransitionRule
-end
-
 class Tab
   extend ::T::Private::Methods::MethodHooks
   extend ::T::Private::Methods::SingletonMethodHooks
@@ -31397,132 +9174,21 @@ class Tempfile::Remover
 end
 
 class Time
-  include ::DateAndTime::Zones
-  include ::DateAndTime::Calculations
-  def acts_like_time?(); end
-
-  def advance(options); end
-
-  def ago(seconds); end
-
-  def at_beginning_of_day(); end
-
-  def at_beginning_of_hour(); end
-
-  def at_beginning_of_minute(); end
-
-  def at_end_of_day(); end
-
-  def at_end_of_hour(); end
-
-  def at_end_of_minute(); end
-
-  def at_midday(); end
-
-  def at_middle_of_day(); end
-
-  def at_midnight(); end
-
-  def at_noon(); end
-
-  def beginning_of_day(); end
-
-  def beginning_of_hour(); end
-
-  def beginning_of_minute(); end
-
-  def change(options); end
-
-  def compare_with_coercion(other); end
-
   def compare_without_coercion(arg); end
 
-  def end_of_day(); end
-
-  def end_of_hour(); end
-
-  def end_of_minute(); end
-
-  def eql_with_coercion(other); end
-
   def eql_without_coercion(arg); end
 
-  def in(seconds); end
-
-  def midday(); end
-
-  def middle_of_day(); end
-
-  def midnight(); end
-
-  def minus_with_coercion(other); end
-
-  def minus_with_duration(other); end
-
-  def minus_without_coercion(other); end
-
   def minus_without_duration(arg); end
 
-  def next_day(days=T.unsafe(nil)); end
-
-  def next_month(months=T.unsafe(nil)); end
-
-  def next_year(years=T.unsafe(nil)); end
-
-  def noon(); end
-
-  def plus_with_duration(other); end
-
   def plus_without_duration(arg); end
 
-  def prev_day(days=T.unsafe(nil)); end
-
-  def prev_month(months=T.unsafe(nil)); end
-
-  def prev_year(years=T.unsafe(nil)); end
-
   def rfc3339(fraction_digits=T.unsafe(nil)); end
 
-  def sec_fraction(); end
-
-  def seconds_since_midnight(); end
-
-  def seconds_until_end_of_day(); end
-
-  def since(seconds); end
-
   def to_default_s(); end
-  COMMON_YEAR_DAYS_IN_MONTH = ::T.let(nil, ::T.untyped)
 end
 
 class Time
-  def self.===(other); end
-
-  def self.at_with_coercion(*args); end
-
   def self.at_without_coercion(*arg); end
-
-  def self.current(); end
-
-  def self.days_in_month(month, year=T.unsafe(nil)); end
-
-  def self.days_in_year(year=T.unsafe(nil)); end
-
-  def self.find_zone(time_zone); end
-
-  def self.find_zone!(time_zone); end
-
-  def self.rfc3339(str); end
-
-  def self.use_zone(time_zone); end
-
-  def self.zone(); end
-
-  def self.zone=(time_zone); end
-
-  def self.zone_default(); end
-
-  def self.zone_default=(zone_default); end
 end
 
 class TracePoint
@@ -31535,10 +9201,6 @@ class TracePoint
   def parameters(); end
 end
 
-class TrueClass
-  include ::MessagePack::CoreExt
-end
-
 module Tty
   extend ::T::Private::Methods::SingletonMethodHooks
   def self.blue(); end
@@ -31580,14 +9242,37 @@ module Tty
   def self.yellow(); end
 end
 
+module URI
+  include ::URI::RFC2396_REGEXP
+end
+
+class URI::FTP
+  def buffer_open(buf, proxy, options); end
+end
+
 class URI::FTP
   def self.new2(user, password, host, port, path, typecode=T.unsafe(nil), arg_check=T.unsafe(nil)); end
 end
 
 class URI::File
+  def check_password(user); end
+
+  def check_user(user); end
+
+  def check_userinfo(user); end
+
+  def set_userinfo(v); end
+  COMPONENT = ::T.let(nil, ::T.untyped)
   DEFAULT_PORT = ::T.let(nil, ::T.untyped)
 end
 
+class URI::File
+end
+
+class URI::HTTP
+  def buffer_open(buf, proxy, options); end
+end
+
 class URI::LDAP
   def attributes(); end
 
@@ -31626,6 +9311,10 @@ class URI::MailTo
   def initialize(*arg); end
 end
 
+URI::Parser = URI::RFC2396_Parser
+
+URI::REGEXP = URI::RFC2396_REGEXP
+
 class URI::RFC2396_Parser
   def initialize(opts=T.unsafe(nil)); end
 end
@@ -31646,631 +9335,12 @@ module URI::Util
 end
 
 module URI
+  extend ::URI::Escape
   def self.get_encoding(label); end
 end
 
-module URITemplate
-  def +(other, *args, &block); end
-
-  def /(other, *args, &block); end
-
-  def ==(other, *args, &block); end
-
-  def >>(other, *args, &block); end
-
-  def absolute?(); end
-
-  def concat(other, *args, &block); end
-
-  def concat_without_coercion(other); end
-
-  def eq(other, *args, &block); end
-
-  def eq_without_coercion(other); end
-
-  def expand(variables=T.unsafe(nil)); end
-
-  def expand_partial(variables=T.unsafe(nil)); end
-
-  def host?(); end
-
-  def path_concat(other, *args, &block); end
-
-  def path_concat_without_coercion(other); end
-
-  def pattern(); end
-
-  def relative?(); end
-
-  def scheme?(); end
-
-  def static_characters(); end
-
-  def to_s(); end
-
-  def tokens(); end
-
-  def type(); end
-
-  def variables(); end
-  HOST_REGEX = ::T.let(nil, ::T.untyped)
-  SCHEME_REGEX = ::T.let(nil, ::T.untyped)
-  URI_SPLIT = ::T.let(nil, ::T.untyped)
-  VERSIONS = ::T.let(nil, ::T.untyped)
-end
-
-module URITemplate::ClassMethods
-  def convert(x); end
-
-  def included(base); end
-
-  def try_convert(x); end
-end
-
-module URITemplate::ClassMethods
-end
-
-class URITemplate::Colon
-  include ::URITemplate
-  def extract(uri); end
-
-  def initialize(pattern); end
-
-  def to_r(); end
-
-  def tokenize!(); end
-  VAR = ::T.let(nil, ::T.untyped)
-end
-
-class URITemplate::Colon::InvalidValue
-  include ::URITemplate::InvalidValue
-  def generate_message(); end
-
-  def initialize(variable, value); end
-
-  def value(); end
-
-  def variable(); end
-end
-
-class URITemplate::Colon::InvalidValue::SplatIsNotAnArray
-end
-
-class URITemplate::Colon::InvalidValue::SplatIsNotAnArray
-end
-
-class URITemplate::Colon::InvalidValue
-end
-
-class URITemplate::Colon::Token
-end
-
-class URITemplate::Colon::Token::Splat
-  def index(); end
-
-  def initialize(index); end
-  SPLAT = ::T.let(nil, ::T.untyped)
-end
-
-class URITemplate::Colon::Token::Splat
-end
-
-class URITemplate::Colon::Token::Static
-  include ::URITemplate::Literal
-  include ::URITemplate::Token
-  def initialize(str); end
-
-  def to_r(); end
-end
-
-class URITemplate::Colon::Token::Static
-end
-
-class URITemplate::Colon::Token::Variable
-  include ::URITemplate::Expression
-  include ::URITemplate::Token
-  def expand(vars); end
-
-  def initialize(name); end
-
-  def name(); end
-
-  def to_r(); end
-end
-
-class URITemplate::Colon::Token::Variable
-end
-
-class URITemplate::Colon::Token
-end
-
-class URITemplate::Colon
-  extend ::URITemplate::ClassMethods
-end
-
-module URITemplate::Expression
-  include ::URITemplate::Token
-  def expression?(); end
-
-  def literal?(); end
-
-  def variables(); end
-end
-
-module URITemplate::Expression
-end
-
-module URITemplate::Invalid
-end
-
-module URITemplate::Invalid
-end
-
-module URITemplate::InvalidValue
-end
-
-module URITemplate::InvalidValue
-end
-
-module URITemplate::Literal
-  include ::URITemplate::Token
-  def ends_with_slash?(); end
-
-  def expand(_); end
-
-  def expand_partial(_); end
-
-  def expression?(); end
-
-  def literal?(); end
-
-  def size(); end
-
-  def starts_with_slash?(); end
-
-  def string(); end
-
-  def to_s(); end
-  SLASH = ::T.let(nil, ::T.untyped)
-end
-
-module URITemplate::Literal
-end
-
-class URITemplate::RFC6570
-  include ::URITemplate
-  def ===(*args, &block); end
-
-  def extract(uri_or_match, post_processing=T.unsafe(nil)); end
-
-  def extract_matchdata(matchdata, post_processing); end
-
-  def extract_simple(uri_or_match); end
-
-  def initialize(pattern_or_tokens, options=T.unsafe(nil)); end
-
-  def level(); end
-
-  def match(*args, &block); end
-
-  def options(); end
-
-  def to_r(); end
-
-  def tokenize!(); end
-  CHARACTER_CLASSES = ::T.let(nil, ::T.untyped)
-  CONVERT_RESULT = ::T.let(nil, ::T.untyped)
-  CONVERT_VALUES = ::T.let(nil, ::T.untyped)
-  DEFAULT_PROCESSING = ::T.let(nil, ::T.untyped)
-  EXPRESSION = ::T.let(nil, ::T.untyped)
-  LITERAL = ::T.let(nil, ::T.untyped)
-  NO_PROCESSING = ::T.let(nil, ::T.untyped)
-  OPERATORS = ::T.let(nil, ::T.untyped)
-  TYPE = ::T.let(nil, ::T.untyped)
-  URI = ::T.let(nil, ::T.untyped)
-  VAR = ::T.let(nil, ::T.untyped)
-end
-
-module URITemplate::RFC6570::ClassMethods
-  def try_convert(x); end
-
-  def valid?(pattern); end
-end
-
-module URITemplate::RFC6570::ClassMethods
-end
-
-class URITemplate::RFC6570::Expression
-  include ::URITemplate::Expression
-  include ::URITemplate::Token
-  def arity(); end
-
-  def cut(str, chars); end
-
-  def decode(x, split=T.unsafe(nil)); end
-
-  def empty_literals?(list); end
-
-  def escape(x); end
-
-  def expand(vars); end
-
-  def expand_partial(vars); end
-
-  def extract(position, matched); end
-
-  def initialize(vars); end
-
-  def level(); end
-
-  def pair(key, value, max_length=T.unsafe(nil), &block); end
-
-  def regex_builder(); end
-
-  def transform_array(name, ary, expand, max_length); end
-
-  def transform_hash(name, hsh, expand, max_length); end
-
-  def unescape(x); end
-  BASE_LEVEL = ::T.let(nil, ::T.untyped)
-  CHARACTER_CLASS = ::T.let(nil, ::T.untyped)
-  COMMA = ::T.let(nil, ::T.untyped)
-  LIST_CONNECTOR = ::T.let(nil, ::T.untyped)
-  OPERATOR = ::T.let(nil, ::T.untyped)
-  PAIR_CONNECTOR = ::T.let(nil, ::T.untyped)
-  PAIR_IF_EMPTY = ::T.let(nil, ::T.untyped)
-  PREFIX = ::T.let(nil, ::T.untyped)
-  SEPARATOR = ::T.let(nil, ::T.untyped)
-  SPLITTER = ::T.let(nil, ::T.untyped)
-end
-
-class URITemplate::RFC6570::Expression::Basic
-end
-
-URITemplate::RFC6570::Expression::Basic::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::Basic
-
-URITemplate::RFC6570::Expression::Basic::FOLLOW_UP = URITemplate::RFC6570::Expression::Basic
-
-class URITemplate::RFC6570::Expression::Basic
-end
-
-module URITemplate::RFC6570::Expression::ClassMethods
-  def generate_hash_extractor(max_length); end
-
-  def hash_extractor(max_length); end
-
-  def hash_extractors(); end
-
-  def regex_builder(); end
-end
-
-module URITemplate::RFC6570::Expression::ClassMethods
-end
-
-class URITemplate::RFC6570::Expression::FormQuery
-  BASE_LEVEL = ::T.let(nil, ::T.untyped)
-  OPERATOR = ::T.let(nil, ::T.untyped)
-  PREFIX = ::T.let(nil, ::T.untyped)
-  SEPARATOR = ::T.let(nil, ::T.untyped)
-end
-
-URITemplate::RFC6570::Expression::FormQuery::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::FormQueryContinuation
-
-URITemplate::RFC6570::Expression::FormQuery::FOLLOW_UP = URITemplate::RFC6570::Expression::Basic
-
-class URITemplate::RFC6570::Expression::FormQuery
-end
-
-class URITemplate::RFC6570::Expression::FormQueryContinuation
-  BASE_LEVEL = ::T.let(nil, ::T.untyped)
-  OPERATOR = ::T.let(nil, ::T.untyped)
-  PREFIX = ::T.let(nil, ::T.untyped)
-  SEPARATOR = ::T.let(nil, ::T.untyped)
-end
-
-URITemplate::RFC6570::Expression::FormQueryContinuation::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::FormQueryContinuation
-
-URITemplate::RFC6570::Expression::FormQueryContinuation::FOLLOW_UP = URITemplate::RFC6570::Expression::Basic
-
-class URITemplate::RFC6570::Expression::FormQueryContinuation
-end
-
-class URITemplate::RFC6570::Expression::Fragment
-  BASE_LEVEL = ::T.let(nil, ::T.untyped)
-  CHARACTER_CLASS = ::T.let(nil, ::T.untyped)
-  OPERATOR = ::T.let(nil, ::T.untyped)
-  PREFIX = ::T.let(nil, ::T.untyped)
-end
-
-URITemplate::RFC6570::Expression::Fragment::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::Reserved
-
-URITemplate::RFC6570::Expression::Fragment::FOLLOW_UP = URITemplate::RFC6570::Expression::Reserved
-
-class URITemplate::RFC6570::Expression::Fragment
-end
-
-class URITemplate::RFC6570::Expression::Label
-  BASE_LEVEL = ::T.let(nil, ::T.untyped)
-  OPERATOR = ::T.let(nil, ::T.untyped)
-  PREFIX = ::T.let(nil, ::T.untyped)
-  SEPARATOR = ::T.let(nil, ::T.untyped)
-end
-
-URITemplate::RFC6570::Expression::Label::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::Label
-
-URITemplate::RFC6570::Expression::Label::FOLLOW_UP = URITemplate::RFC6570::Expression::Label
-
-class URITemplate::RFC6570::Expression::Label
-end
-
-class URITemplate::RFC6570::Expression::Named
-  def self_pair(key, value, max_length=T.unsafe(nil), &block); end
-
-  def to_r_source(); end
-end
-
-class URITemplate::RFC6570::Expression::Named
-end
-
-class URITemplate::RFC6570::Expression::Path
-  BASE_LEVEL = ::T.let(nil, ::T.untyped)
-  OPERATOR = ::T.let(nil, ::T.untyped)
-  PREFIX = ::T.let(nil, ::T.untyped)
-  SEPARATOR = ::T.let(nil, ::T.untyped)
-end
-
-URITemplate::RFC6570::Expression::Path::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::Path
-
-URITemplate::RFC6570::Expression::Path::FOLLOW_UP = URITemplate::RFC6570::Expression::Path
-
-class URITemplate::RFC6570::Expression::Path
-end
-
 class URITemplate::RFC6570::Expression::PathParameters
-  BASE_LEVEL = ::T.let(nil, ::T.untyped)
-  OPERATOR = ::T.let(nil, ::T.untyped)
   PAIR_IF_EMPTY = ::T.let(nil, ::T.untyped)
-  PREFIX = ::T.let(nil, ::T.untyped)
-  SEPARATOR = ::T.let(nil, ::T.untyped)
-end
-
-URITemplate::RFC6570::Expression::PathParameters::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::PathParameters
-
-URITemplate::RFC6570::Expression::PathParameters::FOLLOW_UP = URITemplate::RFC6570::Expression::PathParameters
-
-class URITemplate::RFC6570::Expression::PathParameters
-end
-
-class URITemplate::RFC6570::Expression::Reserved
-  BASE_LEVEL = ::T.let(nil, ::T.untyped)
-  CHARACTER_CLASS = ::T.let(nil, ::T.untyped)
-  OPERATOR = ::T.let(nil, ::T.untyped)
-end
-
-URITemplate::RFC6570::Expression::Reserved::BULK_FOLLOW_UP = URITemplate::RFC6570::Expression::Reserved
-
-URITemplate::RFC6570::Expression::Reserved::FOLLOW_UP = URITemplate::RFC6570::Expression::Reserved
-
-class URITemplate::RFC6570::Expression::Reserved
-end
-
-class URITemplate::RFC6570::Expression::Unnamed
-  def self_pair(_, value, max_length=T.unsafe(nil), &block); end
-
-  def to_r_source(); end
-end
-
-class URITemplate::RFC6570::Expression::Unnamed
-end
-
-class URITemplate::RFC6570::Expression
-  extend ::URITemplate::RFC6570::Expression::ClassMethods
-end
-
-class URITemplate::RFC6570::Invalid
-  include ::URITemplate::Invalid
-  def initialize(source, position); end
-
-  def pattern(); end
-
-  def position(); end
-end
-
-class URITemplate::RFC6570::Invalid
-end
-
-class URITemplate::RFC6570::Literal
-  include ::URITemplate::Literal
-  include ::URITemplate::Token
-  def initialize(string); end
-
-  def level(); end
-
-  def to_r_source(*_); end
-end
-
-class URITemplate::RFC6570::Literal
-end
-
-class URITemplate::RFC6570::RegexBuilder
-  def <<(arg); end
-
-  def capture(&block); end
-
-  def character_class(max_length=T.unsafe(nil), min=T.unsafe(nil)); end
-
-  def character_class_with_comma(max_length=T.unsafe(nil), min=T.unsafe(nil)); end
-
-  def escaped_pair_connector(); end
-
-  def escaped_prefix(); end
-
-  def escaped_separator(); end
-
-  def group(capture=T.unsafe(nil)); end
-
-  def initialize(expression_class); end
-
-  def join(); end
-
-  def length(*args); end
-
-  def lookahead(); end
-
-  def negative_lookahead(); end
-
-  def push(*args); end
-
-  def reluctant(); end
-
-  def separated_list(first=T.unsafe(nil), length=T.unsafe(nil), min=T.unsafe(nil), &block); end
-end
-
-class URITemplate::RFC6570::RegexBuilder
-end
-
-class URITemplate::RFC6570::Token
-end
-
-class URITemplate::RFC6570::Token
-end
-
-class URITemplate::RFC6570::Tokenizer
-  include ::Enumerable
-  def each(&blk); end
-
-  def initialize(source, ops); end
-
-  def source(); end
-end
-
-class URITemplate::RFC6570::Tokenizer
-end
-
-module URITemplate::RFC6570::Utils
-  include ::URITemplate::Utils
-  include ::URITemplate::Utils::StringEncoding
-  include ::URITemplate::Utils::StringEncoding::Encode
-  include ::URITemplate::Utils::Escaping::Pure
-  def def?(value); end
-end
-
-module URITemplate::RFC6570::Utils
-  extend ::URITemplate::RFC6570::Utils
-  extend ::URITemplate::Utils
-  extend ::URITemplate::Utils::StringEncoding
-  extend ::URITemplate::Utils::StringEncoding::Encode
-  extend ::URITemplate::Utils::Escaping::Pure
-end
-
-class URITemplate::RFC6570
-  extend ::URITemplate::ClassMethods
-  extend ::Forwardable
-  extend ::URITemplate::RFC6570::ClassMethods
-end
-
-module URITemplate::Token
-  def ends_with_slash?(); end
-
-  def expand(variables); end
-
-  def expand_partial(variables); end
-
-  def host?(); end
-
-  def scheme?(); end
-
-  def size(); end
-
-  def starts_with_slash?(); end
-
-  def to_s(); end
-
-  def variables(); end
-  EMPTY_ARRAY = ::T.let(nil, ::T.untyped)
-end
-
-module URITemplate::Token
-end
-
-module URITemplate::Utils
-  include ::URITemplate::Utils::StringEncoding
-  include ::URITemplate::Utils::StringEncoding::Encode
-  include ::URITemplate::Utils::Escaping::Pure
-  def compact_regexp(rx); end
-
-  def object_to_param(object); end
-
-  def pair_array?(a); end
-
-  def pair_array_to_hash(x, careful=T.unsafe(nil)); end
-
-  def pair_array_to_hash2(x); end
-
-  def use_unicode?(); end
-  KCODE_UTF8 = ::T.let(nil, ::T.untyped)
-end
-
-module URITemplate::Utils::Escaping
-end
-
-module URITemplate::Utils::Escaping::Pure
-  def escape_uri(s); end
-
-  def escape_url(s); end
-
-  def unescape_uri(s); end
-
-  def unescape_url(s); end
-
-  def using_escape_utils?(); end
-  PCT = ::T.let(nil, ::T.untyped)
-  URI_ESCAPED = ::T.let(nil, ::T.untyped)
-  URL_ESCAPED = ::T.let(nil, ::T.untyped)
-end
-
-module URITemplate::Utils::Escaping::Pure
-end
-
-module URITemplate::Utils::Escaping
-end
-
-module URITemplate::Utils::StringEncoding
-  include ::URITemplate::Utils::StringEncoding::Encode
-end
-
-module URITemplate::Utils::StringEncoding::Encode
-  def force_utf8(str); end
-
-  def to_ascii(str); end
-
-  def to_utf8(str); end
-end
-
-module URITemplate::Utils::StringEncoding::Encode
-end
-
-module URITemplate::Utils::StringEncoding
-end
-
-module URITemplate::Utils
-  extend ::URITemplate::Utils
-  extend ::URITemplate::Utils::StringEncoding
-  extend ::URITemplate::Utils::StringEncoding::Encode
-  extend ::URITemplate::Utils::Escaping::Pure
-end
-
-module URITemplate
-  extend ::URITemplate::ClassMethods
-  def self.apply(a, method, b, *args); end
-
-  def self.coerce(a, b); end
-
-  def self.coerce_first_arg(meth); end
-
-  def self.new(*args); end
-
-  def self.resolve_class(*args); end
 end
 
 module URL::BlockDSL::PageWithURL
@@ -32505,81 +9575,6 @@ class Version
   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 make_body_tempfile(); end
-
-  def rack(); end
-
-  def rack=(rack); end
-
-  def remove_body_tempfile(); 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::CGIHandler
-  CGIRunnerArray = ::T.let(nil, ::T.untyped)
-end
-
-class WEBrick::HTTPServlet::DefaultFileHandler
-  def multipart_body(body, parts, boundary, mtype, filesize); end
-end
-
-class WEBrick::HTTPServlet::FileHandler
-  def set_filesystem_encoding(str); end
-end
-
-module Warning::Processor
-  def clear(); end
-
-  def dedup(); end
-
-  def freeze(); end
-
-  def ignore(regexp, path=T.unsafe(nil)); end
-
-  def process(path=T.unsafe(nil), actions=T.unsafe(nil), &block); end
-
-  def warn(str); end
-  IGNORE_MAP = ::T.let(nil, ::T.untyped)
-end
-
-module Warning::Processor
-end
-
-module Warning
-  extend ::Warning
-  extend ::Warning::Processor
-end
-
 class WeakRef
   def initialize(orig); end
 end
@@ -32588,206 +9583,6 @@ class WebRobots::RobotsTxt::Parser
   Racc_debug_parser = ::T.let(nil, ::T.untyped)
 end
 
-module Zeitwerk
-end
-
-class Zeitwerk::Error
-end
-
-class Zeitwerk::Error
-end
-
-module Zeitwerk::ExplicitNamespace
-end
-
-module Zeitwerk::ExplicitNamespace
-  extend ::Zeitwerk::RealModName
-  def self.cpaths(); end
-
-  def self.mutex(); end
-
-  def self.register(cpath, loader); end
-
-  def self.tracer(); end
-
-  def self.unregister(loader); end
-end
-
-class Zeitwerk::GemInflector
-  def camelize(basename, abspath); end
-
-  def initialize(root_file); end
-end
-
-class Zeitwerk::GemInflector
-end
-
-class Zeitwerk::Inflector
-  def camelize(basename, _abspath); end
-
-  def inflect(inflections); end
-end
-
-class Zeitwerk::Inflector
-end
-
-class Zeitwerk::Loader
-  include ::Zeitwerk::Loader::Callbacks
-  include ::Zeitwerk::RealModName
-  def autoloaded_dirs(); end
-
-  def autoloads(); end
-
-  def collapse(*glob_patterns); end
-
-  def collapse_dirs(); end
-
-  def collapse_glob_patterns(); end
-
-  def dirs(); end
-
-  def do_not_eager_load(*paths); end
-
-  def eager_load(); end
-
-  def eager_load_exclusions(); end
-
-  def enable_reloading(); end
-
-  def ignore(*glob_patterns); end
-
-  def ignored_glob_patterns(); end
-
-  def ignored_paths(); end
-
-  def inflector(); end
-
-  def inflector=(inflector); end
-
-  def lazy_subdirs(); end
-
-  def log!(); end
-
-  def logger(); end
-
-  def logger=(logger); end
-
-  def manages?(dir); end
-
-  def mutex(); end
-
-  def mutex2(); end
-
-  def on_load(cpath, &block); end
-
-  def on_load_callbacks(); end
-
-  def preload(*paths); end
-
-  def preloads(); end
-
-  def push_dir(path, namespace: T.unsafe(nil)); end
-
-  def reload(); end
-
-  def reloading_enabled?(); end
-
-  def root_dirs(); end
-
-  def setup(); end
-
-  def tag(); end
-
-  def tag=(tag); end
-
-  def to_unload(); end
-
-  def unload(); end
-
-  def unloadable_cpath?(cpath); end
-
-  def unloadable_cpaths(); end
-end
-
-module Zeitwerk::Loader::Callbacks
-  include ::Zeitwerk::RealModName
-  def on_dir_autoloaded(dir); end
-
-  def on_file_autoloaded(file); end
-
-  def on_namespace_loaded(namespace); end
-end
-
-module Zeitwerk::Loader::Callbacks
-end
-
-class Zeitwerk::Loader
-  def self.all_dirs(); end
-
-  def self.default_logger(); end
-
-  def self.default_logger=(default_logger); end
-
-  def self.eager_load_all(); end
-
-  def self.for_gem(); end
-
-  def self.mutex(); end
-
-  def self.mutex=(mutex); end
-end
-
-class Zeitwerk::NameError
-end
-
-class Zeitwerk::NameError
-end
-
-module Zeitwerk::RealModName
-  def real_mod_name(mod); end
-end
-
-module Zeitwerk::RealModName
-end
-
-module Zeitwerk::Registry
-end
-
-module Zeitwerk::Registry
-  def self.autoloads(); end
-
-  def self.inception?(cpath); end
-
-  def self.inceptions(); end
-
-  def self.loader_for(path); end
-
-  def self.loader_for_gem(root_file); end
-
-  def self.loaders(); end
-
-  def self.loaders_managing_gems(); end
-
-  def self.on_unload(loader); end
-
-  def self.register_autoload(loader, realpath); end
-
-  def self.register_inception(cpath, realpath, loader); end
-
-  def self.register_loader(loader); end
-
-  def self.unregister_autoload(realpath); end
-end
-
-class Zeitwerk::ReloadingDisabledError
-end
-
-class Zeitwerk::ReloadingDisabledError
-end
-
-module Zeitwerk
-end
-
 class Zlib::Deflate
   def initialize(*arg); end
 end