diff --git a/.gitignore b/.gitignore
index 8c23188..ede5b2a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
 .DS_Store
 *.lock
 pkg/*
+sorbet/rbi/hidden-definitions/errors.txt
diff --git a/CHANGELOG.md b/CHANGELOG.md
index c671c2e..69813ac 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,7 @@
 IMPROVEMENTS:
 
 - Add Ruby 2.7 support
+- Add experimental [Sorbet](https://sorbet.org) support to development tools, fix surfaced problems
 
 ## 2.0.0 (January 25, 2019)
 
diff --git a/Rakefile b/Rakefile
index 538a5a5..3bd6982 100644
--- a/Rakefile
+++ b/Rakefile
@@ -7,4 +7,8 @@ RSpec::Core::RakeTask.new(:spec)
 RuboCop::RakeTask.new
 Bundler::Audit::Task.new
 
-task default: [:rubocop, :spec, 'bundle:audit']
+task :sorbet do
+  sh 'srb typecheck'
+end
+
+task default: [:rubocop, :sorbet, :spec, 'bundle:audit']
diff --git a/dyndnsd.gemspec b/dyndnsd.gemspec
index 928cfa2..95f5ebc 100644
--- a/dyndnsd.gemspec
+++ b/dyndnsd.gemspec
@@ -26,6 +26,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'opentracing', '~> 0.5.0'
   s.add_runtime_dependency 'rack-tracer', '~> 0.9.0'
   s.add_runtime_dependency 'jaeger-client', '~> 0.10.0'
+  s.add_runtime_dependency 'sorbet-runtime', '~> 0.5.0'
 
   s.add_development_dependency 'bundler'
   s.add_development_dependency 'rake'
@@ -33,4 +34,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rack-test'
   s.add_development_dependency 'rubocop', '~> 0.80.0'
   s.add_development_dependency 'bundler-audit', '~> 0.6.0'
+  s.add_development_dependency 'sorbet', '~> 0.5.0'
 end
diff --git a/lib/dyndnsd.rb b/lib/dyndnsd.rb
index 2981f83..aadab3a 100755
--- a/lib/dyndnsd.rb
+++ b/lib/dyndnsd.rb
@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# typed: true
 
 require 'etc'
 require 'logger'
diff --git a/lib/dyndnsd/database.rb b/lib/dyndnsd/database.rb
index 7ae6c21..e3a9886 100644
--- a/lib/dyndnsd/database.rb
+++ b/lib/dyndnsd/database.rb
@@ -1,3 +1,4 @@
+# typed: true
 
 require 'forwardable'
 
diff --git a/lib/dyndnsd/generator/bind.rb b/lib/dyndnsd/generator/bind.rb
index 213ff85..5429018 100644
--- a/lib/dyndnsd/generator/bind.rb
+++ b/lib/dyndnsd/generator/bind.rb
@@ -1,3 +1,4 @@
+# typed: true
 
 module Dyndnsd
   module Generator
diff --git a/lib/dyndnsd/helper.rb b/lib/dyndnsd/helper.rb
index 0184735..dbf548a 100644
--- a/lib/dyndnsd/helper.rb
+++ b/lib/dyndnsd/helper.rb
@@ -1,3 +1,4 @@
+# typed: true
 
 require 'ipaddr'
 
diff --git a/lib/dyndnsd/responder/dyndns_style.rb b/lib/dyndnsd/responder/dyndns_style.rb
index 51f829a..b195a36 100644
--- a/lib/dyndnsd/responder/dyndns_style.rb
+++ b/lib/dyndnsd/responder/dyndns_style.rb
@@ -1,3 +1,4 @@
+# typed: true
 
 module Dyndnsd
   module Responder
diff --git a/lib/dyndnsd/responder/rest_style.rb b/lib/dyndnsd/responder/rest_style.rb
index e2e0b8d..4cf9d85 100644
--- a/lib/dyndnsd/responder/rest_style.rb
+++ b/lib/dyndnsd/responder/rest_style.rb
@@ -1,3 +1,4 @@
+# typed: true
 
 module Dyndnsd
   module Responder
diff --git a/lib/dyndnsd/textfile_reporter.rb b/lib/dyndnsd/textfile_reporter.rb
index a19993c..f5515f9 100644
--- a/lib/dyndnsd/textfile_reporter.rb
+++ b/lib/dyndnsd/textfile_reporter.rb
@@ -1,3 +1,4 @@
+# typed: true
 
 # Adapted from https://github.com/eric/metriks-graphite/blob/master/lib/metriks/reporter/graphite.rb
 
diff --git a/lib/dyndnsd/updater/command_with_bind_zone.rb b/lib/dyndnsd/updater/command_with_bind_zone.rb
index d15dfd7..4fb561c 100644
--- a/lib/dyndnsd/updater/command_with_bind_zone.rb
+++ b/lib/dyndnsd/updater/command_with_bind_zone.rb
@@ -1,3 +1,4 @@
+# typed: true
 
 module Dyndnsd
   module Updater
diff --git a/lib/dyndnsd/version.rb b/lib/dyndnsd/version.rb
index af416f9..7642f78 100644
--- a/lib/dyndnsd/version.rb
+++ b/lib/dyndnsd/version.rb
@@ -1,3 +1,4 @@
+# typed: true
 
 module Dyndnsd
   VERSION = '2.0.0'.freeze
diff --git a/sorbet/config b/sorbet/config
new file mode 100644
index 0000000..7fb7a8e
--- /dev/null
+++ b/sorbet/config
@@ -0,0 +1,2 @@
+--dir
+.
diff --git a/sorbet/rbi/hidden-definitions/hidden.rbi b/sorbet/rbi/hidden-definitions/hidden.rbi
new file mode 100644
index 0000000..81e48f1
--- /dev/null
+++ b/sorbet/rbi/hidden-definitions/hidden.rbi
@@ -0,0 +1,26236 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi hidden-definitions
+
+# typed: autogenerated
+
+module AST
+end
+
+class AST::Node
+  def +(array); end
+
+  def <<(element); end
+
+  def ==(other); end
+
+  def append(element); end
+
+  def assign_properties(properties); end
+
+  def children(); end
+
+  def clone(); end
+
+  def concat(array); end
+
+  def eql?(other); end
+
+  def fancy_type(); end
+
+  def initialize(type, children=T.unsafe(nil), properties=T.unsafe(nil)); 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
+end
+
+class AST::Node
+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 AST::Processor::Mixin
+end
+
+class AST::Processor
+end
+
+module AST::Sexp
+  def s(type, *children); end
+end
+
+module AST::Sexp
+end
+
+module AST
+end
+
+class Addrinfo
+  def connect_internal(local_addrinfo, timeout=T.unsafe(nil)); end
+end
+
+class Array
+  include ::JSON::Ext::Generator::GeneratorMethods::Array
+  def bsearch(); end
+
+  def bsearch_index(); end
+
+  def collect!(); end
+
+  def dig(*_); end
+
+  def flatten!(*_); end
+
+  def pack(*_); end
+
+  def replace(_); end
+
+  def shelljoin(); end
+
+  def to_h(); end
+end
+
+class Array
+  def self.try_convert(_); end
+end
+
+class Atomic
+  def _compare_and_set(_, _1); end
+
+  def compare_and_set(expected, new); end
+
+  def compare_and_swap(expected, new); end
+
+  def get(); end
+
+  def get_and_set(_); end
+
+  def initialize(*_); end
+
+  def set(_); end
+
+  def swap(_); end
+
+  def try_update(); end
+
+  def update(); end
+
+  def value(); end
+
+  def value=(value); end
+end
+
+class Atomic::ConcurrentUpdateError
+  CONC_UP_ERR_BACKTRACE = ::T.let(nil, ::T.untyped)
+end
+
+class Atomic::ConcurrentUpdateError
+end
+
+class Atomic
+end
+
+BasicObject::BasicObject = BasicObject
+
+class BasicSocket
+  def read_nonblock(len, str=T.unsafe(nil), exception: T.unsafe(nil)); end
+end
+
+class BigDecimal
+  def clone(); end
+  EXCEPTION_NaN = ::T.let(nil, ::T.untyped)
+  SIGN_NaN = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class BigDecimal
+  def self.new(*args, **kwargs); end
+end
+
+class Binding
+  def clone(); end
+
+  def irb(); end
+end
+
+module Bundler::Audit
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::Audit::Advisory
+  def criticality(); end
+
+  def cve_id(); end
+
+  def osvdb_id(); end
+
+  def patched?(version); end
+
+  def unaffected?(version); end
+
+  def vulnerable?(version); end
+end
+
+class Bundler::Audit::Advisory
+  def self.load(path); end
+end
+
+class Bundler::Audit::Database
+  def advisories(&block); end
+
+  def advisories_for(name); end
+
+  def check_gem(gem); end
+
+  def each_advisory_path(&block); end
+
+  def each_advisory_path_for(name, &block); end
+
+  def initialize(path=T.unsafe(nil)); end
+
+  def path(); end
+
+  def size(); end
+  URL = ::T.let(nil, ::T.untyped)
+  USER_PATH = ::T.let(nil, ::T.untyped)
+  VENDORED_PATH = ::T.let(nil, ::T.untyped)
+  VENDORED_TIMESTAMP = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::Audit::Database
+  def self.path(); end
+
+  def self.update!(options=T.unsafe(nil)); end
+end
+
+module Bundler::Audit
+end
+
+Bundler::Deprecate = Gem::Deprecate
+
+class Bundler::Env
+end
+
+class Bundler::Env
+  def self.environment(); end
+
+  def self.report(options=T.unsafe(nil)); end
+
+  def self.write(io); end
+end
+
+class Bundler::FeatureFlag
+  def github_https?(); end
+end
+
+class Bundler::Fetcher
+  def fetch_spec(spec); end
+
+  def fetchers(); end
+
+  def http_proxy(); end
+
+  def initialize(remote); end
+
+  def specs(gem_names, source); end
+
+  def specs_with_retry(gem_names, source); end
+
+  def uri(); end
+
+  def use_api(); end
+
+  def user_agent(); end
+  FAIL_ERRORS = ::T.let(nil, ::T.untyped)
+  FETCHERS = ::T.let(nil, ::T.untyped)
+  HTTP_ERRORS = ::T.let(nil, ::T.untyped)
+  NET_ERRORS = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::Fetcher::AuthenticationRequiredError
+  def initialize(remote_uri); end
+end
+
+class Bundler::Fetcher::BadAuthenticationError
+  def initialize(remote_uri); end
+end
+
+class Bundler::Fetcher::Base
+  def api_fetcher?(); end
+
+  def available?(); end
+
+  def display_uri(); end
+
+  def downloader(); end
+
+  def fetch_uri(); end
+
+  def initialize(downloader, remote, display_uri); end
+
+  def remote(); end
+
+  def remote_uri(); end
+end
+
+class Bundler::Fetcher::Base
+end
+
+class Bundler::Fetcher::CertificateFailureError
+  def initialize(remote_uri); end
+end
+
+class Bundler::Fetcher::CompactIndex
+  def available?(*args, &blk); end
+
+  def fetch_spec(*args, &blk); end
+
+  def specs(*args, &blk); end
+
+  def specs_for_names(gem_names); end
+end
+
+class Bundler::Fetcher::CompactIndex::ClientFetcher
+  def call(path, headers); end
+
+  def fetcher(); end
+
+  def fetcher=(_); end
+
+  def ui(); end
+
+  def ui=(_); end
+end
+
+class Bundler::Fetcher::CompactIndex::ClientFetcher
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+class Bundler::Fetcher::CompactIndex
+  def self.compact_index_request(method_name); end
+end
+
+class Bundler::Fetcher::Dependency
+  def dependency_api_uri(gem_names=T.unsafe(nil)); end
+
+  def dependency_specs(gem_names); end
+
+  def get_formatted_specs_and_deps(gem_list); end
+
+  def specs(gem_names, full_dependency_list=T.unsafe(nil), last_spec_list=T.unsafe(nil)); end
+
+  def unmarshalled_dep_gems(gem_names); end
+end
+
+class Bundler::Fetcher::Dependency
+end
+
+class Bundler::Fetcher::Downloader
+  def connection(); end
+
+  def fetch(uri, headers=T.unsafe(nil), counter=T.unsafe(nil)); end
+
+  def initialize(connection, redirect_limit); end
+
+  def redirect_limit(); end
+
+  def request(uri, headers); end
+end
+
+class Bundler::Fetcher::Downloader
+end
+
+class Bundler::Fetcher::Index
+  def fetch_spec(spec); end
+
+  def specs(_gem_names); end
+end
+
+class Bundler::Fetcher::Index
+end
+
+class Bundler::Fetcher::SSLError
+  def initialize(msg=T.unsafe(nil)); end
+end
+
+class Bundler::Fetcher
+  def self.api_timeout(); end
+
+  def self.api_timeout=(api_timeout); end
+
+  def self.disable_endpoint(); end
+
+  def self.disable_endpoint=(disable_endpoint); end
+
+  def self.max_retries(); end
+
+  def self.max_retries=(max_retries); end
+
+  def self.redirect_limit(); end
+
+  def self.redirect_limit=(redirect_limit); end
+end
+
+class Bundler::GemHelper
+  include ::Rake::DSL
+  include ::Rake::FileUtilsExt
+  include ::FileUtils
+  include ::FileUtils::StreamUtils_
+  def allowed_push_host(); end
+
+  def already_tagged?(); end
+
+  def base(); end
+
+  def build_gem(); end
+
+  def built_gem_path(); end
+
+  def clean?(); end
+
+  def committed?(); end
+
+  def gem_key(); end
+
+  def gem_push?(); end
+
+  def gem_push_host(); end
+
+  def gemspec(); end
+
+  def git_push(remote=T.unsafe(nil)); end
+
+  def guard_clean(); end
+
+  def initialize(base=T.unsafe(nil), name=T.unsafe(nil)); end
+
+  def install(); end
+
+  def install_gem(built_gem_path=T.unsafe(nil), local=T.unsafe(nil)); end
+
+  def name(); end
+
+  def perform_git_push(options=T.unsafe(nil)); end
+
+  def rubygem_push(path); end
+
+  def sh(cmd, &block); end
+
+  def sh_with_code(cmd, &block); end
+
+  def spec_path(); end
+
+  def tag_version(); end
+
+  def version(); end
+
+  def version_tag(); end
+end
+
+class Bundler::GemHelper
+  def self.gemspec(&block); end
+
+  def self.install_tasks(opts=T.unsafe(nil)); end
+
+  def self.instance(); end
+
+  def self.instance=(instance); end
+end
+
+class Bundler::GemRemoteFetcher
+end
+
+class Bundler::GemRemoteFetcher
+end
+
+class Bundler::GemVersionPromoter
+  def initialize(locked_specs=T.unsafe(nil), unlock_gems=T.unsafe(nil)); end
+
+  def level(); end
+
+  def level=(value); end
+
+  def locked_specs(); end
+
+  def major?(); end
+
+  def minor?(); end
+
+  def prerelease_specified(); end
+
+  def prerelease_specified=(prerelease_specified); end
+
+  def sort_versions(dep, spec_groups); end
+
+  def strict(); end
+
+  def strict=(strict); end
+
+  def unlock_gems(); end
+  DEBUG = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::GemVersionPromoter
+end
+
+class Bundler::Graph
+  def edge_options(); end
+
+  def groups(); end
+
+  def initialize(env, output_file, show_version=T.unsafe(nil), show_requirements=T.unsafe(nil), output_format=T.unsafe(nil), without=T.unsafe(nil)); end
+
+  def node_options(); end
+
+  def output_file(); end
+
+  def output_format(); end
+
+  def relations(); end
+
+  def viz(); end
+  GRAPH_NAME = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::Graph::GraphVizClient
+  def g(); end
+
+  def initialize(graph_instance); end
+
+  def run(); end
+end
+
+class Bundler::Graph::GraphVizClient
+end
+
+class Bundler::Graph
+end
+
+class Bundler::Index
+  include ::Enumerable
+end
+
+class Bundler::Injector
+  def initialize(deps, options=T.unsafe(nil)); end
+
+  def inject(gemfile_path, lockfile_path); end
+
+  def remove(gemfile_path, lockfile_path); end
+  INJECTED_GEMS = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::Injector
+  def self.inject(new_deps, options=T.unsafe(nil)); end
+
+  def self.remove(gems, options=T.unsafe(nil)); end
+end
+
+class Bundler::Installer
+  def generate_bundler_executable_stubs(spec, options=T.unsafe(nil)); end
+
+  def generate_standalone_bundler_executable_stubs(spec); end
+
+  def initialize(root, definition); end
+
+  def post_install_messages(); end
+
+  def run(options); end
+end
+
+class Bundler::Installer
+  def self.ambiguous_gems(); end
+
+  def self.ambiguous_gems=(ambiguous_gems); end
+
+  def self.install(root, definition, options=T.unsafe(nil)); end
+end
+
+class Bundler::Molinillo::DependencyGraph
+  include ::Enumerable
+end
+
+class Bundler::Molinillo::DependencyGraph::Log
+  extend ::Enumerable
+end
+
+module Bundler::Plugin::API::Source
+  def ==(other); end
+
+  def app_cache_dirname(); end
+
+  def app_cache_path(custom_path=T.unsafe(nil)); end
+
+  def bundler_plugin_api_source?(); end
+
+  def cache(spec, custom_path=T.unsafe(nil)); end
+
+  def cached!(); end
+
+  def can_lock?(spec); end
+
+  def dependency_names(); end
+
+  def dependency_names=(dependency_names); end
+
+  def double_check_for(*_); end
+
+  def eql?(other); end
+
+  def fetch_gemspec_files(); end
+
+  def gem_install_dir(); end
+
+  def hash(); end
+
+  def include?(other); end
+
+  def initialize(opts); end
+
+  def install(spec, opts); end
+
+  def install_path(); end
+
+  def installed?(); end
+
+  def name(); end
+
+  def options(); end
+
+  def options_to_lock(); end
+
+  def post_install(spec, disable_exts=T.unsafe(nil)); end
+
+  def remote!(); end
+
+  def root(); end
+
+  def specs(); end
+
+  def to_lock(); end
+
+  def to_s(); end
+
+  def unlock!(); end
+
+  def unmet_deps(); end
+
+  def uri(); end
+
+  def uri_hash(); end
+end
+
+module Bundler::Plugin::API::Source
+end
+
+module Bundler::Plugin::Events
+  GEM_AFTER_INSTALL = ::T.let(nil, ::T.untyped)
+  GEM_AFTER_INSTALL_ALL = ::T.let(nil, ::T.untyped)
+  GEM_BEFORE_INSTALL = ::T.let(nil, ::T.untyped)
+  GEM_BEFORE_INSTALL_ALL = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::Plugin::Index::CommandConflict
+  def initialize(plugin, commands); end
+end
+
+class Bundler::Plugin::Index::CommandConflict
+end
+
+class Bundler::Plugin::Index::SourceConflict
+  def initialize(plugin, sources); end
+end
+
+class Bundler::Plugin::Index::SourceConflict
+end
+
+class Bundler::Plugin::Installer
+  def install(names, options); end
+
+  def install_definition(definition); end
+end
+
+class Bundler::Plugin::Installer::Git
+  def generate_bin(spec, disable_extensions=T.unsafe(nil)); end
+end
+
+class Bundler::Plugin::Installer::Git
+end
+
+class Bundler::Plugin::Installer::Rubygems
+end
+
+class Bundler::Plugin::Installer::Rubygems
+end
+
+class Bundler::Plugin::Installer
+end
+
+class Bundler::Plugin::SourceList
+end
+
+class Bundler::Plugin::SourceList
+end
+
+class Bundler::ProcessLock
+end
+
+class Bundler::ProcessLock
+  def self.lock(bundle_path=T.unsafe(nil)); end
+end
+
+class Bundler::Retry
+  def attempt(&block); end
+
+  def attempts(&block); end
+
+  def current_run(); end
+
+  def current_run=(current_run); end
+
+  def initialize(name, exceptions=T.unsafe(nil), retries=T.unsafe(nil)); end
+
+  def name(); end
+
+  def name=(name); end
+
+  def total_runs(); end
+
+  def total_runs=(total_runs); end
+end
+
+class Bundler::Retry
+  def self.attempts(); end
+
+  def self.default_attempts(); end
+
+  def self.default_retries(); end
+end
+
+class Bundler::RubyGemsGemInstaller
+  def initialize(gem, options=T.unsafe(nil)); end
+end
+
+class Bundler::RubyGemsGemInstaller
+end
+
+class Bundler::Settings::Mirror
+  def ==(other); end
+
+  def fallback_timeout(); end
+
+  def fallback_timeout=(timeout); end
+
+  def initialize(uri=T.unsafe(nil), fallback_timeout=T.unsafe(nil)); end
+
+  def uri(); end
+
+  def uri=(uri); end
+
+  def valid?(); end
+
+  def validate!(probe=T.unsafe(nil)); end
+  DEFAULT_FALLBACK_TIMEOUT = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::Settings::Mirror
+end
+
+class Bundler::Settings::Mirrors
+  def each(&blk); end
+
+  def for(uri); end
+
+  def initialize(prober=T.unsafe(nil)); end
+
+  def parse(key, value); end
+end
+
+class Bundler::Settings::Mirrors
+end
+
+class Bundler::Settings::Validator
+end
+
+class Bundler::Settings::Validator::Rule
+  def description(); end
+
+  def fail!(key, value, *reasons); end
+
+  def initialize(keys, description, &validate); end
+
+  def k(key); end
+
+  def set(settings, key, value, *reasons); end
+
+  def validate!(key, value, settings); end
+end
+
+class Bundler::Settings::Validator::Rule
+end
+
+class Bundler::Settings::Validator
+  def self.validate!(key, value, settings); end
+end
+
+class Bundler::SpecSet
+  include ::Enumerable
+end
+
+class Bundler::UI::Shell
+  def add_color(string, *color); end
+
+  def ask(msg); end
+
+  def confirm(msg, newline=T.unsafe(nil)); end
+
+  def debug(msg, newline=T.unsafe(nil)); end
+
+  def debug?(); end
+
+  def error(msg, newline=T.unsafe(nil)); end
+
+  def info(msg, newline=T.unsafe(nil)); end
+
+  def initialize(options=T.unsafe(nil)); end
+
+  def level(name=T.unsafe(nil)); end
+
+  def level=(level); end
+
+  def no?(); end
+
+  def quiet?(); end
+
+  def shell=(shell); end
+
+  def silence(&blk); end
+
+  def trace(e, newline=T.unsafe(nil), force=T.unsafe(nil)); end
+
+  def unprinted_warnings(); end
+
+  def warn(msg, newline=T.unsafe(nil)); end
+
+  def yes?(msg); end
+  LEVELS = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::UI::Shell
+end
+
+module Bundler::VersionRanges
+end
+
+class Bundler::VersionRanges::NEq
+  def version(); end
+
+  def version=(_); end
+end
+
+class Bundler::VersionRanges::NEq
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+class Bundler::VersionRanges::ReqR
+  def cover?(v); end
+
+  def empty?(); end
+
+  def left(); end
+
+  def left=(_); end
+
+  def right(); end
+
+  def right=(_); end
+
+  def single?(); end
+  INFINITY = ::T.let(nil, ::T.untyped)
+  UNIVERSAL = ::T.let(nil, ::T.untyped)
+  ZERO = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::VersionRanges::ReqR::Endpoint
+  def inclusive(); end
+
+  def inclusive=(_); end
+
+  def version(); end
+
+  def version=(_); end
+end
+
+class Bundler::VersionRanges::ReqR::Endpoint
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+class Bundler::VersionRanges::ReqR
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+module Bundler::VersionRanges
+  def self.empty?(ranges, neqs); end
+
+  def self.for(requirement); end
+
+  def self.for_many(requirements); end
+end
+
+module CGI::HtmlExtension
+  def a(href=T.unsafe(nil)); end
+
+  def base(href=T.unsafe(nil)); end
+
+  def blockquote(cite=T.unsafe(nil)); end
+
+  def caption(align=T.unsafe(nil)); end
+
+  def checkbox(name=T.unsafe(nil), value=T.unsafe(nil), checked=T.unsafe(nil)); end
+
+  def checkbox_group(name=T.unsafe(nil), *values); end
+
+  def file_field(name=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end
+
+  def form(method=T.unsafe(nil), action=T.unsafe(nil), enctype=T.unsafe(nil)); end
+
+  def hidden(name=T.unsafe(nil), value=T.unsafe(nil)); end
+
+  def html(attributes=T.unsafe(nil)); end
+
+  def image_button(src=T.unsafe(nil), name=T.unsafe(nil), alt=T.unsafe(nil)); end
+
+  def img(src=T.unsafe(nil), alt=T.unsafe(nil), width=T.unsafe(nil), height=T.unsafe(nil)); end
+
+  def multipart_form(action=T.unsafe(nil), enctype=T.unsafe(nil)); end
+
+  def password_field(name=T.unsafe(nil), value=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end
+
+  def popup_menu(name=T.unsafe(nil), *values); end
+
+  def radio_button(name=T.unsafe(nil), value=T.unsafe(nil), checked=T.unsafe(nil)); end
+
+  def radio_group(name=T.unsafe(nil), *values); end
+
+  def reset(value=T.unsafe(nil), name=T.unsafe(nil)); end
+
+  def scrolling_list(name=T.unsafe(nil), *values); end
+
+  def submit(value=T.unsafe(nil), name=T.unsafe(nil)); end
+
+  def text_field(name=T.unsafe(nil), value=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end
+
+  def textarea(name=T.unsafe(nil), cols=T.unsafe(nil), rows=T.unsafe(nil)); end
+end
+
+module CGI::HtmlExtension
+end
+
+class Class
+  def json_creatable?(); end
+end
+
+class Complex
+  def self.polar(*_); end
+
+  def self.rect(*_); end
+
+  def self.rectangular(*_); end
+end
+
+class ConcurrentRedBlackTree
+end
+
+class ConcurrentRedBlackTree::ConcurrentNode
+  def balanced_rotate(dir); end
+
+  def child(dir); end
+
+  def new_child(dir, node, color=T.unsafe(nil)); end
+
+  def new_children(dir, node, other, color=T.unsafe(nil)); end
+
+  def new_color(color); end
+
+  def new_value(value); end
+
+  def rebalance_for_delete(dir); end
+
+  def rebalance_for_insert(dir); end
+
+  def rotate(dir); end
+  EMPTY_CONCURRENT = ::T.let(nil, ::T.untyped)
+  LEFT = ::T.let(nil, ::T.untyped)
+  RIGHT = ::T.let(nil, ::T.untyped)
+end
+
+class ConcurrentRedBlackTree::ConcurrentNode::EmptyConcurrentNode
+end
+
+class ConcurrentRedBlackTree::ConcurrentNode::EmptyConcurrentNode
+end
+
+class ConcurrentRedBlackTree::ConcurrentNode
+end
+
+class ConcurrentRedBlackTree
+end
+
+class Date::Infinity
+  def initialize(d=T.unsafe(nil)); end
+end
+
+class Delegator
+  def !=(obj); end
+
+  def ==(obj); end
+
+  def __getobj__(); end
+
+  def __setobj__(obj); end
+
+  def eql?(obj); end
+
+  def initialize(obj); end
+
+  def marshal_dump(); end
+
+  def marshal_load(data); end
+
+  def method_missing(m, *args, &block); end
+
+  def methods(all=T.unsafe(nil)); end
+
+  def protected_methods(all=T.unsafe(nil)); end
+
+  def public_methods(all=T.unsafe(nil)); end
+end
+
+class Delegator
+  def self.const_missing(n); end
+
+  def self.delegating_block(mid); end
+
+  def self.public_api(); end
+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 receiver(); end
+  RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped)
+end
+
+class DidYouMean::NullChecker
+  def corrections(); end
+
+  def initialize(*_); end
+end
+
+class DidYouMean::PlainFormatter
+  def message_for(corrections); end
+end
+
+class DidYouMean::PlainFormatter
+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.formatter(); end
+
+  def self.formatter=(formatter); end
+end
+
+class Dir
+  def children(); end
+
+  def each_child(); end
+end
+
+class Dir
+  def self.children(*_); end
+
+  def self.each_child(*_); end
+
+  def self.empty?(_); end
+
+  def self.exists?(_); end
+
+  def self.tmpdir(); end
+end
+
+class Dyndnsd::Database
+  def [](*args, &block); end
+
+  def []=(*args, &block); end
+
+  def each(*args, &block); end
+
+  def has_key?(*args, &block); end
+end
+
+class Dyndnsd::DummyDatabase
+  def [](*args, &block); end
+
+  def []=(*args, &block); end
+
+  def each(*args, &block); end
+
+  def has_key?(*args, &block); end
+end
+
+class ERB
+  def def_method(mod, methodname, fname=T.unsafe(nil)); end
+
+  def def_module(methodname=T.unsafe(nil)); end
+
+  def result_with_hash(hash); end
+end
+
+class ERB::Compiler::Scanner
+  DEFAULT_ETAGS = ::T.let(nil, ::T.untyped)
+  DEFAULT_STAGS = ::T.let(nil, ::T.untyped)
+end
+
+Emitter = Psych::Stream::Emitter
+
+class Encoding
+  def _dump(*_); end
+end
+
+class Encoding::Converter
+  def convert(_); end
+
+  def convpath(); end
+
+  def destination_encoding(); end
+
+  def finish(); end
+
+  def initialize(*_); end
+
+  def insert_output(_); end
+
+  def last_error(); end
+
+  def primitive_convert(*_); end
+
+  def primitive_errinfo(); end
+
+  def putback(*_); end
+
+  def replacement(); end
+
+  def replacement=(replacement); end
+
+  def source_encoding(); end
+end
+
+class Encoding::Converter
+  def self.asciicompat_encoding(_); end
+
+  def self.search_convpath(*_); end
+end
+
+class Encoding::InvalidByteSequenceError
+  def destination_encoding(); end
+
+  def destination_encoding_name(); end
+
+  def error_bytes(); end
+
+  def incomplete_input?(); end
+
+  def readagain_bytes(); end
+
+  def source_encoding(); end
+
+  def source_encoding_name(); end
+end
+
+class Encoding::UndefinedConversionError
+  def destination_encoding(); end
+
+  def destination_encoding_name(); end
+
+  def error_char(); end
+
+  def source_encoding(); end
+
+  def source_encoding_name(); end
+end
+
+class Encoding
+  def self._load(_); end
+
+  def self.locale_charmap(); end
+end
+
+module Enumerable
+  def chain(*_); end
+
+  def chunk(); end
+
+  def chunk_while(); end
+
+  def each_entry(*_); end
+
+  def grep_v(_); end
+
+  def slice_after(*_); end
+
+  def slice_before(*_); end
+
+  def slice_when(); end
+
+  def sum(*_); end
+
+  def to_set(klass=T.unsafe(nil), *args, &block); end
+
+  def uniq(); end
+end
+
+class Enumerator
+  def +(_); end
+
+  def each_with_index(); end
+end
+
+class Enumerator::ArithmeticSequence
+  def begin(); end
+
+  def each(&blk); end
+
+  def end(); end
+
+  def exclude_end?(); end
+
+  def last(*_); end
+
+  def step(); end
+end
+
+class Enumerator::ArithmeticSequence
+end
+
+class Enumerator::Chain
+end
+
+class Enumerator::Chain
+end
+
+class Enumerator::Generator
+  def each(*_, &blk); end
+
+  def initialize(*_); end
+end
+
+class Enumerator::Lazy
+  def chunk(*_); end
+
+  def chunk_while(*_); end
+
+  def force(*_); end
+
+  def slice_when(*_); end
+end
+
+Errno::EAUTH = Errno::NOERROR
+
+Errno::EBADARCH = Errno::NOERROR
+
+Errno::EBADEXEC = Errno::NOERROR
+
+Errno::EBADMACHO = Errno::NOERROR
+
+Errno::EBADRPC = Errno::NOERROR
+
+Errno::ECAPMODE = Errno::NOERROR
+
+Errno::EDEADLOCK = Errno::EDEADLK
+
+Errno::EDEVERR = Errno::NOERROR
+
+Errno::EDOOFUS = Errno::NOERROR
+
+Errno::EFTYPE = Errno::NOERROR
+
+Errno::EIPSEC = Errno::NOERROR
+
+Errno::ELAST = Errno::NOERROR
+
+Errno::ENEEDAUTH = Errno::NOERROR
+
+Errno::ENOATTR = Errno::NOERROR
+
+Errno::ENOPOLICY = Errno::NOERROR
+
+Errno::ENOTCAPABLE = Errno::NOERROR
+
+class Errno::ENOTSUP
+  Errno = ::T.let(nil, ::T.untyped)
+end
+
+class Errno::ENOTSUP
+end
+
+Errno::EPROCLIM = Errno::NOERROR
+
+Errno::EPROCUNAVAIL = Errno::NOERROR
+
+Errno::EPROGMISMATCH = Errno::NOERROR
+
+Errno::EPROGUNAVAIL = Errno::NOERROR
+
+Errno::EPWROFF = Errno::NOERROR
+
+Errno::EQFULL = Errno::NOERROR
+
+Errno::ERPCMISMATCH = Errno::NOERROR
+
+Errno::ESHLIBVERS = Errno::NOERROR
+
+class Etc::Group
+  def gid(); end
+
+  def gid=(_); end
+
+  def mem(); end
+
+  def mem=(_); end
+
+  def name(); end
+
+  def name=(_); end
+
+  def passwd(); end
+
+  def passwd=(_); end
+end
+
+class Etc::Group
+  extend ::Enumerable
+  def self.[](*_); end
+
+  def self.each(&blk); end
+
+  def self.members(); end
+end
+
+class Etc::Passwd
+  def dir=(_); end
+
+  def gecos(); end
+
+  def gecos=(_); end
+
+  def gid=(_); end
+
+  def name=(_); end
+
+  def passwd=(_); end
+
+  def shell=(_); end
+
+  def uid=(_); end
+end
+
+class Etc::Passwd
+  extend ::Enumerable
+  def self.[](*_); end
+
+  def self.each(&blk); end
+
+  def self.members(); end
+end
+
+class Exception
+  def full_message(*_); end
+end
+
+class Exception
+  def self.exception(*_); end
+
+  def self.to_tty?(); end
+end
+
+class ExitCalledError
+end
+
+class ExitCalledError
+end
+
+class FalseClass
+  include ::JSON::Ext::Generator::GeneratorMethods::FalseClass
+end
+
+class Fiber
+  def resume(*_); end
+end
+
+class Fiber
+  def self.yield(*_); end
+end
+
+class File
+  Separator = ::T.let(nil, ::T.untyped)
+end
+
+class File::Stat
+  def size?(); end
+end
+
+class File
+  def self.empty?(_); end
+
+  def self.exists?(_); end
+
+  def self.lutime(*_); end
+
+  def self.mkfifo(*_); end
+end
+
+FileList = Rake::FileList
+
+module FileUtils
+  include ::FileUtils::StreamUtils_
+  def ruby(*args, **options, &block); end
+
+  def safe_ln(*args, **options); end
+
+  def sh(*cmd, &block); end
+
+  def split_all(path); end
+  LN_SUPPORTED = ::T.let(nil, ::T.untyped)
+  RUBY = ::T.let(nil, ::T.untyped)
+end
+
+module FileUtils::DryRun
+  include ::FileUtils
+  include ::FileUtils::StreamUtils_
+  include ::FileUtils::LowMethods
+end
+
+module FileUtils::DryRun
+  extend ::FileUtils::DryRun
+  extend ::FileUtils
+  extend ::FileUtils::StreamUtils_
+  extend ::FileUtils::LowMethods
+end
+
+module FileUtils::NoWrite
+  include ::FileUtils
+  include ::FileUtils::StreamUtils_
+  include ::FileUtils::LowMethods
+end
+
+module FileUtils::NoWrite
+  extend ::FileUtils::NoWrite
+  extend ::FileUtils
+  extend ::FileUtils::StreamUtils_
+  extend ::FileUtils::LowMethods
+end
+
+module FileUtils::Verbose
+  include ::FileUtils
+  include ::FileUtils::StreamUtils_
+end
+
+module FileUtils::Verbose
+  extend ::FileUtils::Verbose
+  extend ::FileUtils
+  extend ::FileUtils::StreamUtils_
+end
+
+module FileUtils
+  extend ::FileUtils::StreamUtils_
+end
+
+module Find
+end
+
+module Find
+  def self.find(*paths, ignore_error: T.unsafe(nil)); end
+
+  def self.prune(); end
+end
+
+class Float
+  include ::JSON::Ext::Generator::GeneratorMethods::Float
+end
+
+module Forwardable
+  def def_delegator(accessor, method, ali=T.unsafe(nil)); end
+
+  def def_delegators(accessor, *methods); end
+
+  def def_instance_delegator(accessor, method, ali=T.unsafe(nil)); end
+
+  def def_instance_delegators(accessor, *methods); end
+
+  def delegate(hash); end
+
+  def instance_delegate(hash); end
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+module Forwardable
+  def self._compile_method(src, file, line); end
+
+  def self._delegator_method(obj, accessor, method, ali); end
+
+  def self._valid_method?(method); end
+
+  def self.debug(); end
+
+  def self.debug=(debug); end
+end
+
+module GC
+  def garbage_collect(*_); end
+end
+
+module GC
+  def self.latest_gc_info(*_); end
+
+  def self.stress=(stress); end
+
+  def self.verify_internal_consistency(); end
+
+  def self.verify_transient_heap_internal_consistency(); end
+end
+
+class Gem::Package::TarHeader
+  def self.oct_or_256based(str); end
+end
+
+class Gem::RemoteFetcher
+  def s3_uri_signer(uri); end
+end
+
+class Gem::Resolver::Molinillo::DependencyGraph::Log
+  extend ::Enumerable
+end
+
+class Gem::S3URISigner
+  def initialize(uri); end
+
+  def sign(expiration=T.unsafe(nil)); end
+
+  def uri(); end
+
+  def uri=(uri); end
+  BASE64_URI_TRANSLATE = ::T.let(nil, ::T.untyped)
+  EC2_IAM_INFO = ::T.let(nil, ::T.untyped)
+  EC2_IAM_SECURITY_CREDENTIALS = ::T.let(nil, ::T.untyped)
+end
+
+class Gem::S3URISigner::ConfigurationError
+  def initialize(message); end
+end
+
+class Gem::S3URISigner::ConfigurationError
+end
+
+class Gem::S3URISigner::InstanceProfileError
+  def initialize(message); end
+end
+
+class Gem::S3URISigner::InstanceProfileError
+end
+
+class Gem::S3URISigner::S3Config
+  def access_key_id(); end
+
+  def access_key_id=(_); end
+
+  def region(); end
+
+  def region=(_); end
+
+  def secret_access_key(); end
+
+  def secret_access_key=(_); end
+
+  def security_token(); end
+
+  def security_token=(_); end
+end
+
+class Gem::S3URISigner::S3Config
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+class Gem::S3URISigner
+end
+
+class Gem::Specification
+  extend ::Enumerable
+end
+
+module Gem::Util
+  def self.correct_for_windows_path(path); end
+end
+
+class Hash
+  include ::JSON::Ext::Generator::GeneratorMethods::Hash
+  def <(_); end
+
+  def <=(_); end
+
+  def >(_); end
+
+  def >=(_); end
+
+  def compact(); end
+
+  def compact!(); end
+
+  def default_proc(); end
+
+  def default_proc=(default_proc); end
+
+  def fetch_values(*_); end
+
+  def flatten(*_); end
+
+  def index(_); end
+
+  def replace(_); end
+
+  def slice(*_); end
+
+  def to_h(); end
+
+  def to_proc(); end
+
+  def transform_keys(); end
+
+  def transform_keys!(); end
+
+  def transform_values(); end
+
+  def transform_values!(); end
+
+  def update(*_); end
+end
+
+class Hash
+  def self.try_convert(_); end
+end
+
+module Hitimes
+  INSTANT_CONVERSION_FACTOR = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class Hitimes::Error
+end
+
+class Hitimes::Error
+end
+
+class Hitimes::Interval
+  def duration(); end
+
+  def duration_so_far(); end
+
+  def length(); end
+
+  def running?(); end
+
+  def split(); end
+
+  def start(); end
+
+  def start_instant(); end
+
+  def started?(); end
+
+  def stop(); end
+
+  def stop_instant(); end
+
+  def stopped?(); end
+
+  def to_f(); end
+
+  def to_seconds(); end
+end
+
+class Hitimes::Interval
+  def self.measure(); end
+
+  def self.now(); end
+end
+
+class Hitimes::Metric
+  def additional_data(); end
+
+  def initialize(name, additional_data=T.unsafe(nil)); end
+
+  def name(); end
+
+  def sampling_delta(); end
+
+  def sampling_start_time(); end
+
+  def sampling_stop_time(); end
+
+  def to_hash(); end
+
+  def utc_microseconds(); end
+end
+
+class Hitimes::Metric
+end
+
+class Hitimes::MutexedStats
+  def update(value); end
+end
+
+class Hitimes::MutexedStats
+end
+
+module Hitimes::Paths
+end
+
+module Hitimes::Paths
+  def self.lib_path(*args); end
+
+  def self.root_dir(); end
+
+  def self.sub_path(sub, *args); end
+end
+
+class Hitimes::Stats
+  def count(); end
+
+  def max(); end
+
+  def mean(); end
+
+  def min(); end
+
+  def rate(); end
+
+  def stddev(); end
+
+  def sum(); end
+
+  def sumsq(); end
+
+  def to_hash(*args); end
+
+  def to_json(*args); end
+
+  def update(_); end
+  STATS = ::T.let(nil, ::T.untyped)
+end
+
+class Hitimes::Stats
+end
+
+class Hitimes::TimedMetric
+  def count(*args, &block); end
+
+  def duration(*args, &block); end
+
+  def max(*args, &block); end
+
+  def mean(*args, &block); end
+
+  def measure(&block); end
+
+  def min(*args, &block); end
+
+  def rate(*args, &block); end
+
+  def running?(); end
+
+  def split(); end
+
+  def start(); end
+
+  def stats(); end
+
+  def stddev(*args, &block); end
+
+  def stop(); end
+
+  def sum(*args, &block); end
+
+  def sumsq(*args, &block); end
+end
+
+class Hitimes::TimedMetric
+  extend ::Forwardable
+  def self.now(name, additional_data=T.unsafe(nil)); end
+end
+
+class Hitimes::TimedValueMetric
+  def duration(); end
+
+  def measure(value, &block); end
+
+  def rate(); end
+
+  def running?(); end
+
+  def split(value); end
+
+  def start(); end
+
+  def stop(value); end
+
+  def timed_stats(); end
+
+  def unit_count(); end
+
+  def value_stats(); end
+end
+
+class Hitimes::TimedValueMetric
+  def self.now(name, additional_data=T.unsafe(nil)); end
+end
+
+class Hitimes::ValueMetric
+  def count(*args, &block); end
+
+  def max(*args, &block); end
+
+  def mean(*args, &block); end
+
+  def measure(value); end
+
+  def min(*args, &block); end
+
+  def stats(); end
+
+  def stddev(*args, &block); end
+
+  def sum(*args, &block); end
+
+  def sumsq(*args, &block); end
+end
+
+class Hitimes::ValueMetric
+  extend ::Forwardable
+end
+
+module Hitimes
+  def self.measure(&block); end
+
+  def self.raw_instant(); end
+end
+
+class IO
+  def beep(); end
+
+  def cooked(); end
+
+  def cooked!(); end
+
+  def cursor(); end
+
+  def cursor=(); end
+
+  def echo=(echo); end
+
+  def echo?(); end
+
+  def external_encoding(); end
+
+  def getch(*_); end
+
+  def getpass(*_); end
+
+  def goto(); end
+
+  def iflush(); end
+
+  def ioflush(); end
+
+  def noecho(); end
+
+  def nonblock(*_); end
+
+  def nonblock=(nonblock); end
+
+  def nonblock?(); end
+
+  def nread(); end
+
+  def oflush(); end
+
+  def pathconf(_); end
+
+  def pread(*_); end
+
+  def pressed?(); end
+
+  def pwrite(_, _1); end
+
+  def raw(*_); end
+
+  def raw!(*_); end
+
+  def ready?(); end
+
+  def wait(*_); end
+
+  def wait_readable(*_); end
+
+  def wait_writable(*_); end
+
+  def winsize(); end
+
+  def winsize=(winsize); end
+
+  def write_nonblock(buf, exception: T.unsafe(nil)); end
+end
+
+IO::EWOULDBLOCKWaitReadable = IO::EAGAINWaitReadable
+
+IO::EWOULDBLOCKWaitWritable = IO::EAGAINWaitWritable
+
+class IO
+  def self.console(*_); end
+
+  def self.foreach(*_); end
+end
+
+class IPAddr
+  include ::Comparable
+  def &(other); end
+
+  def <<(num); end
+
+  def ==(other); end
+
+  def ===(other); end
+
+  def >>(num); end
+
+  def eql?(other); end
+
+  def family(); end
+
+  def hton(); end
+
+  def include?(other); end
+
+  def initialize(addr=T.unsafe(nil), family=T.unsafe(nil)); end
+
+  def ip6_arpa(); end
+
+  def ip6_int(); end
+
+  def ipv4?(); end
+
+  def ipv4_compat(); end
+
+  def ipv4_compat?(); end
+
+  def ipv4_mapped(); end
+
+  def ipv4_mapped?(); end
+
+  def ipv6?(); end
+
+  def link_local?(); end
+
+  def loopback?(); end
+
+  def mask(prefixlen); end
+
+  def mask!(mask); end
+
+  def native(); end
+
+  def prefix(); end
+
+  def prefix=(prefix); end
+
+  def private?(); end
+
+  def reverse(); end
+
+  def set(addr, *family); end
+
+  def succ(); end
+
+  def to_i(); end
+
+  def to_range(); end
+
+  def to_string(); end
+
+  def |(other); end
+
+  def ~(); end
+  IN4MASK = ::T.let(nil, ::T.untyped)
+  IN6FORMAT = ::T.let(nil, ::T.untyped)
+  IN6MASK = ::T.let(nil, ::T.untyped)
+  RE_IPV4ADDRLIKE = ::T.let(nil, ::T.untyped)
+  RE_IPV6ADDRLIKE_COMPRESSED = ::T.let(nil, ::T.untyped)
+  RE_IPV6ADDRLIKE_FULL = ::T.let(nil, ::T.untyped)
+end
+
+class IPAddr::AddressFamilyError
+end
+
+class IPAddr::AddressFamilyError
+end
+
+class IPAddr::Error
+end
+
+class IPAddr::Error
+end
+
+class IPAddr::InvalidAddressError
+end
+
+class IPAddr::InvalidAddressError
+end
+
+class IPAddr::InvalidPrefixError
+end
+
+class IPAddr::InvalidPrefixError
+end
+
+class IPAddr
+  def self.new_ntoh(addr); end
+
+  def self.ntop(addr); end
+end
+
+class Integer
+  include ::JSON::Ext::Generator::GeneratorMethods::Integer
+  def allbits?(_); end
+
+  def anybits?(_); end
+
+  def digits(*_); end
+
+  def nobits?(_); end
+
+  def pow(*_); end
+
+  def to_bn(); end
+  GMP_VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class Integer
+  def self.sqrt(_); end
+end
+
+class JSON::Ext::Generator::State
+  def self.from_state(_); end
+end
+
+class JSON::Ext::Parser
+  def initialize(*_); end
+end
+
+JSON::Parser = JSON::Ext::Parser
+
+JSON::State = JSON::Ext::Generator::State
+
+JSON::UnparserError = JSON::GeneratorError
+
+JSONTree = Psych::Visitors::JSONTree
+
+module JaroWinkler
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class JaroWinkler::Error
+end
+
+class JaroWinkler::Error
+end
+
+class JaroWinkler::InvalidWeightError
+end
+
+class JaroWinkler::InvalidWeightError
+end
+
+module JaroWinkler
+  def self.distance(*_); end
+
+  def self.jaro_distance(*_); end
+end
+
+module Kernel
+  def gem(dep, *reqs); end
+
+  def itself(); end
+
+  def object_id(); end
+
+  def pretty_inspect(); end
+
+  def then(); end
+
+  def yield_self(); end
+end
+
+module Kernel
+  def self.at_exit(); end
+end
+
+class KeyError
+  include ::DidYouMean::Correctable
+  def key(); end
+
+  def receiver(); end
+end
+
+class LoadError
+  def path(); end
+end
+
+class LocalJumpError
+  def exit_value(); end
+
+  def reason(); end
+end
+
+class Logger
+  SEV_LABEL = ::T.let(nil, ::T.untyped)
+end
+
+class Logger::Formatter
+  Format = ::T.let(nil, ::T.untyped)
+end
+
+class Logger::LogDevice
+  include ::MonitorMixin
+end
+
+module Logger::Period
+  SiD = ::T.let(nil, ::T.untyped)
+end
+
+module Marshal
+  def self.restore(*_); end
+end
+
+module Metriks
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class Metriks::Counter
+  def clear(); end
+
+  def count(); end
+
+  def decrement(decr=T.unsafe(nil)); end
+
+  def increment(incr=T.unsafe(nil)); end
+end
+
+class Metriks::Counter
+end
+
+class Metriks::EWMA
+  def clear(); end
+
+  def initialize(alpha, interval); end
+
+  def rate(); end
+
+  def tick(); end
+
+  def update(value); end
+  FIFTEEN_MINUTES = ::T.let(nil, ::T.untyped)
+  FIVE_MINUTES = ::T.let(nil, ::T.untyped)
+  INTERVAL = ::T.let(nil, ::T.untyped)
+  M15_ALPHA = ::T.let(nil, ::T.untyped)
+  M1_ALPHA = ::T.let(nil, ::T.untyped)
+  M5_ALPHA = ::T.let(nil, ::T.untyped)
+  ONE_MINUTE = ::T.let(nil, ::T.untyped)
+  SECONDS_PER_MINUTE = ::T.let(nil, ::T.untyped)
+end
+
+class Metriks::EWMA
+  def self.new_m1(); end
+
+  def self.new_m15(); end
+
+  def self.new_m5(); end
+end
+
+class Metriks::ExponentiallyDecayingSample
+  def clear(); end
+
+  def initialize(reservoir_size, alpha, values=T.unsafe(nil)); end
+
+  def rescale(now, next_time); end
+
+  def size(); end
+
+  def snapshot(); end
+
+  def update(value, timestamp=T.unsafe(nil)); end
+
+  def weight(time); end
+  RESCALE_THRESHOLD = ::T.let(nil, ::T.untyped)
+end
+
+class Metriks::ExponentiallyDecayingSample
+end
+
+class Metriks::Gauge
+  def initialize(callable=T.unsafe(nil), &block); end
+
+  def set(val); end
+
+  def value(); end
+end
+
+class Metriks::Gauge
+end
+
+class Metriks::Histogram
+  def clear(); end
+
+  def count(); end
+
+  def initialize(sample); end
+
+  def max(); end
+
+  def max=(potential_max); end
+
+  def mean(); end
+
+  def min(); end
+
+  def min=(potential_min); end
+
+  def snapshot(); end
+
+  def stddev(); end
+
+  def sum(); end
+
+  def update(value); end
+
+  def update_variance(value); end
+
+  def variance(); end
+  DEFAULT_ALPHA = ::T.let(nil, ::T.untyped)
+  DEFAULT_SAMPLE_SIZE = ::T.let(nil, ::T.untyped)
+end
+
+class Metriks::Histogram
+  def self.new_exponentially_decaying(); end
+
+  def self.new_uniform(); end
+end
+
+class Metriks::Meter
+  def clear(); end
+
+  def count(); end
+
+  def fifteen_minute_rate(); end
+
+  def five_minute_rate(); end
+
+  def initialize(averager_klass=T.unsafe(nil)); end
+
+  def mark(val=T.unsafe(nil)); end
+
+  def mean_rate(); end
+
+  def one_minute_rate(); end
+
+  def stop(); end
+
+  def tick(); end
+
+  def tick_if_nessesary(); end
+  TICK_INTERVAL = ::T.let(nil, ::T.untyped)
+end
+
+class Metriks::Meter
+end
+
+class Metriks::Registry
+  def add(name, metric); end
+
+  def add_or_get(name, klass, &create_metric); end
+
+  def clear(); end
+
+  def counter(name); end
+
+  def each(&block); end
+
+  def gauge(name, callable=T.unsafe(nil), &block); end
+
+  def get(name); end
+
+  def histogram(name); end
+
+  def meter(name); end
+
+  def stop(); end
+
+  def timer(name); end
+
+  def utilization_timer(name); end
+end
+
+class Metriks::Registry
+  def self.default(); end
+end
+
+module Metriks::Reporter
+end
+
+class Metriks::Reporter::Graphite
+  def host(); end
+
+  def initialize(host, port, options=T.unsafe(nil)); end
+
+  def port(); end
+
+  def restart(); end
+
+  def socket(); end
+
+  def start(); end
+
+  def stop(); end
+
+  def write(); end
+
+  def write_metric(base_name, metric, keys, snapshot_keys=T.unsafe(nil)); end
+end
+
+class Metriks::Reporter::Graphite
+end
+
+class Metriks::Reporter::ProcTitle
+  def add(name, suffix=T.unsafe(nil), &block); end
+
+  def empty?(); end
+
+  def generate_title(); end
+
+  def initialize(options=T.unsafe(nil)); end
+
+  def restart(); end
+
+  def start(); end
+
+  def stop(); end
+end
+
+class Metriks::Reporter::ProcTitle
+end
+
+module Metriks::Reporter
+end
+
+class Metriks::Snapshot
+  def get_75th_percentile(); end
+
+  def get_95th_percentile(); end
+
+  def get_98th_percentile(); end
+
+  def get_999th_percentile(); end
+
+  def get_99th_percentile(); end
+
+  def initialize(values); end
+
+  def median(); end
+
+  def size(); end
+
+  def value(quantile); end
+
+  def values(); end
+  MEDIAN_Q = ::T.let(nil, ::T.untyped)
+  P75_Q = ::T.let(nil, ::T.untyped)
+  P95_Q = ::T.let(nil, ::T.untyped)
+  P98_Q = ::T.let(nil, ::T.untyped)
+  P999_Q = ::T.let(nil, ::T.untyped)
+  P99_Q = ::T.let(nil, ::T.untyped)
+end
+
+class Metriks::Snapshot
+end
+
+class Metriks::Timer
+  def clear(); end
+
+  def count(); end
+
+  def fifteen_minute_rate(); end
+
+  def five_minute_rate(); end
+
+  def initialize(histogram=T.unsafe(nil)); end
+
+  def max(); end
+
+  def mean(); end
+
+  def mean_rate(); end
+
+  def min(); end
+
+  def one_minute_rate(); end
+
+  def snapshot(); end
+
+  def stddev(); end
+
+  def stop(); end
+
+  def sum(); end
+
+  def time(callable=T.unsafe(nil), &block); end
+
+  def update(duration); end
+end
+
+class Metriks::Timer::Context
+  def initialize(timer); end
+
+  def restart(); end
+
+  def stop(); end
+end
+
+class Metriks::Timer::Context
+end
+
+class Metriks::Timer
+end
+
+class Metriks::UniformSample
+  def clear(); end
+
+  def initialize(reservoir_size); end
+
+  def size(); end
+
+  def snapshot(); end
+
+  def update(value); end
+end
+
+class Metriks::UniformSample
+end
+
+class Metriks::UtilizationTimer
+  def fifteen_minute_utilization(); end
+
+  def five_minute_utilization(); end
+
+  def initialize(); end
+
+  def mean_utilization(); end
+
+  def one_minute_utilization(); end
+end
+
+class Metriks::UtilizationTimer
+end
+
+module Metriks
+  def self.counter(name); end
+
+  def self.gauge(name, callable=T.unsafe(nil), &block); end
+
+  def self.get(name); end
+
+  def self.histogram(name); end
+
+  def self.meter(name); end
+
+  def self.timer(name); end
+
+  def self.utilization_timer(name); end
+end
+
+class Module
+  def context(*a, &b); end
+
+  def deprecate_constant(*_); end
+
+  def describe(*a, &b); end
+
+  def example_group(*a, &b); end
+
+  def fcontext(*a, &b); end
+
+  def fdescribe(*a, &b); end
+
+  def rake_extension(method); end
+
+  def shared_context(name, *args, &block); end
+
+  def shared_examples(name, *args, &block); end
+
+  def shared_examples_for(name, *args, &block); end
+
+  def undef_method(*_); end
+
+  def xcontext(*a, &b); end
+
+  def xdescribe(*a, &b); end
+end
+
+class Module
+  def self.used_modules(); end
+end
+
+class Monitor
+  def enter(); end
+
+  def exit(); end
+
+  def try_enter(); end
+end
+
+module MonitorMixin
+  def initialize(*args); end
+
+  def mon_enter(); end
+
+  def mon_exit(); end
+
+  def mon_locked?(); end
+
+  def mon_owned?(); end
+
+  def mon_synchronize(); end
+
+  def mon_try_enter(); end
+
+  def new_cond(); end
+
+  def synchronize(); end
+
+  def try_mon_enter(); end
+  EXCEPTION_IMMEDIATE = ::T.let(nil, ::T.untyped)
+  EXCEPTION_NEVER = ::T.let(nil, ::T.untyped)
+end
+
+class MonitorMixin::ConditionVariable
+  def broadcast(); end
+
+  def initialize(monitor); end
+
+  def signal(); end
+
+  def wait(timeout=T.unsafe(nil)); end
+
+  def wait_until(); end
+
+  def wait_while(); end
+end
+
+module MonitorMixin
+  def self.extend_object(obj); end
+end
+
+class NameError
+  include ::DidYouMean::Correctable
+  def name(); end
+
+  def receiver(); end
+end
+
+class Net::BufferedIO
+  def write_timeout(); end
+
+  def write_timeout=(write_timeout); end
+end
+
+class Net::HTTP
+  def max_retries(); end
+
+  def max_retries=(retries); end
+
+  def max_version(); end
+
+  def max_version=(max_version); end
+
+  def min_version(); end
+
+  def min_version=(min_version); end
+
+  def write_timeout(); end
+
+  def write_timeout=(sec); end
+  ENVIRONMENT_VARIABLE_IS_MULTIUSER_SAFE = ::T.let(nil, ::T.untyped)
+end
+
+Net::HTTP::ProxyMod = Net::HTTP::ProxyDelta
+
+class Net::HTTPAlreadyReported
+  HAS_BODY = ::T.let(nil, ::T.untyped)
+end
+
+class Net::HTTPAlreadyReported
+end
+
+Net::HTTPClientError::EXCEPTION_TYPE = Net::HTTPServerException
+
+Net::HTTPClientErrorCode = Net::HTTPClientError
+
+Net::HTTPClientException = Net::HTTPServerException
+
+class Net::HTTPEarlyHints
+  HAS_BODY = ::T.let(nil, ::T.untyped)
+end
+
+class Net::HTTPEarlyHints
+end
+
+Net::HTTPFatalErrorCode = Net::HTTPClientError
+
+class Net::HTTPGatewayTimeout
+  HAS_BODY = ::T.let(nil, ::T.untyped)
+end
+
+class Net::HTTPGatewayTimeout
+end
+
+Net::HTTPInformation::EXCEPTION_TYPE = Net::HTTPError
+
+Net::HTTPInformationCode = Net::HTTPInformation
+
+class Net::HTTPLoopDetected
+  HAS_BODY = ::T.let(nil, ::T.untyped)
+end
+
+class Net::HTTPLoopDetected
+end
+
+class Net::HTTPMisdirectedRequest
+  HAS_BODY = ::T.let(nil, ::T.untyped)
+end
+
+class Net::HTTPMisdirectedRequest
+end
+
+Net::HTTPMovedTemporarily = Net::HTTPFound
+
+Net::HTTPMultipleChoice = Net::HTTPMultipleChoices
+
+class Net::HTTPNotExtended
+  HAS_BODY = ::T.let(nil, ::T.untyped)
+end
+
+class Net::HTTPNotExtended
+end
+
+class Net::HTTPPayloadTooLarge
+  HAS_BODY = ::T.let(nil, ::T.untyped)
+end
+
+class Net::HTTPPayloadTooLarge
+end
+
+class Net::HTTPProcessing
+  HAS_BODY = ::T.let(nil, ::T.untyped)
+end
+
+class Net::HTTPProcessing
+end
+
+class Net::HTTPRangeNotSatisfiable
+  HAS_BODY = ::T.let(nil, ::T.untyped)
+end
+
+class Net::HTTPRangeNotSatisfiable
+end
+
+Net::HTTPRedirection::EXCEPTION_TYPE = Net::HTTPRetriableError
+
+Net::HTTPRedirectionCode = Net::HTTPRedirection
+
+class Net::HTTPRequestTimeout
+  HAS_BODY = ::T.let(nil, ::T.untyped)
+end
+
+class Net::HTTPRequestTimeout
+end
+
+Net::HTTPRequestURITooLarge = Net::HTTPURITooLong
+
+Net::HTTPResponceReceiver = Net::HTTPResponse
+
+Net::HTTPRetriableCode = Net::HTTPRedirection
+
+Net::HTTPServerError::EXCEPTION_TYPE = Net::HTTPFatalError
+
+Net::HTTPServerErrorCode = Net::HTTPServerError
+
+Net::HTTPSession = Net::HTTP
+
+Net::HTTPSuccess::EXCEPTION_TYPE = Net::HTTPError
+
+Net::HTTPSuccessCode = Net::HTTPSuccess
+
+class Net::HTTPURITooLong
+  HAS_BODY = ::T.let(nil, ::T.untyped)
+end
+
+class Net::HTTPURITooLong
+end
+
+Net::HTTPUnknownResponse::EXCEPTION_TYPE = Net::HTTPError
+
+class Net::HTTPVariantAlsoNegotiates
+  HAS_BODY = ::T.let(nil, ::T.untyped)
+end
+
+class Net::HTTPVariantAlsoNegotiates
+end
+
+Net::NetPrivate::HTTPRequest = Net::HTTPRequest
+
+Net::NetPrivate::Socket = Net::InternetMessageIO
+
+Net::ProtocRetryError = Net::ProtoRetriableError
+
+class Net::ReadTimeout
+  def initialize(io=T.unsafe(nil)); end
+
+  def io(); end
+end
+
+class Net::WriteTimeout
+  def initialize(io=T.unsafe(nil)); end
+
+  def io(); end
+end
+
+class Net::WriteTimeout
+end
+
+class NilClass
+  include ::JSON::Ext::Generator::GeneratorMethods::NilClass
+  def to_i(); end
+end
+
+class NoMethodError
+  def args(); end
+
+  def private_call?(); end
+end
+
+class Object
+  include ::JSON::Ext::Generator::GeneratorMethods::Object
+  include ::PP::ObjectMixin
+  def dclone(); end
+
+  def to_yaml(options=T.unsafe(nil)); end
+  ARGF = ::T.let(nil, ::T.untyped)
+  ARGV = ::T.let(nil, ::T.untyped)
+  CROSS_COMPILING = ::T.let(nil, ::T.untyped)
+  ENV = ::T.let(nil, ::T.untyped)
+  RUBY_COPYRIGHT = ::T.let(nil, ::T.untyped)
+  RUBY_DESCRIPTION = ::T.let(nil, ::T.untyped)
+  RUBY_ENGINE = ::T.let(nil, ::T.untyped)
+  RUBY_ENGINE_VERSION = ::T.let(nil, ::T.untyped)
+  RUBY_PATCHLEVEL = ::T.let(nil, ::T.untyped)
+  RUBY_PLATFORM = ::T.let(nil, ::T.untyped)
+  RUBY_RELEASE_DATE = ::T.let(nil, ::T.untyped)
+  RUBY_REVISION = ::T.let(nil, ::T.untyped)
+  RUBY_VERSION = ::T.let(nil, ::T.untyped)
+  STDERR = ::T.let(nil, ::T.untyped)
+  STDIN = ::T.let(nil, ::T.untyped)
+  STDOUT = ::T.let(nil, ::T.untyped)
+  TOPLEVEL_BINDING = ::T.let(nil, ::T.untyped)
+end
+
+class Object
+  def self.yaml_tag(url); end
+end
+
+class ObjectSpace::WeakMap
+  def [](_); end
+
+  def []=(_, _1); end
+
+  def each(&blk); end
+
+  def each_key(); end
+
+  def each_pair(); end
+
+  def each_value(); end
+
+  def key?(_); end
+
+  def keys(); end
+
+  def length(); end
+
+  def size(); end
+
+  def values(); end
+end
+
+module ObjectSpace
+  def self.count_objects(*_); end
+
+  def self.define_finalizer(*_); end
+
+  def self.garbage_collect(*_); end
+
+  def self.undefine_finalizer(_); end
+end
+
+class OpenSSL::ASN1::ASN1Data
+  def indefinite_length(); end
+
+  def indefinite_length=(indefinite_length); end
+end
+
+class OpenSSL::BN
+  def +@(); end
+
+  def -@(); end
+
+  def /(_); end
+
+  def negative?(); end
+end
+
+module OpenSSL::KDF
+end
+
+class OpenSSL::KDF::KDFError
+end
+
+class OpenSSL::KDF::KDFError
+end
+
+module OpenSSL::KDF
+  def self.hkdf(*_); end
+
+  def self.pbkdf2_hmac(*_); end
+
+  def self.scrypt(*_); end
+end
+
+class OpenSSL::OCSP::Request
+  def signed?(); end
+end
+
+OpenSSL::PKCS7::Signer = OpenSSL::PKCS7::SignerInfo
+
+class OpenSSL::PKey::EC
+  EXPLICIT_CURVE = ::T.let(nil, ::T.untyped)
+end
+
+class OpenSSL::PKey::EC::Point
+  def to_octet_string(_); end
+end
+
+class OpenSSL::PKey::RSA
+  def sign_pss(*_); end
+
+  def verify_pss(*_); end
+end
+
+module OpenSSL::SSL
+  OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION = ::T.let(nil, ::T.untyped)
+  OP_CRYPTOPRO_TLSEXT_BUG = ::T.let(nil, ::T.untyped)
+  OP_LEGACY_SERVER_CONNECT = ::T.let(nil, ::T.untyped)
+  OP_NO_ENCRYPT_THEN_MAC = ::T.let(nil, ::T.untyped)
+  OP_NO_RENEGOTIATION = ::T.let(nil, ::T.untyped)
+  OP_SAFARI_ECDHE_ECDSA_BUG = ::T.let(nil, ::T.untyped)
+  OP_TLSEXT_PADDING = ::T.let(nil, ::T.untyped)
+  SSL2_VERSION = ::T.let(nil, ::T.untyped)
+  SSL3_VERSION = ::T.let(nil, ::T.untyped)
+  TLS1_1_VERSION = ::T.let(nil, ::T.untyped)
+  TLS1_2_VERSION = ::T.let(nil, ::T.untyped)
+  TLS1_VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class OpenSSL::SSL::SSLContext
+  def add_certificate(*_); end
+
+  def alpn_protocols(); end
+
+  def alpn_protocols=(alpn_protocols); end
+
+  def alpn_select_cb(); end
+
+  def alpn_select_cb=(alpn_select_cb); end
+
+  def enable_fallback_scsv(); end
+
+  def max_version=(version); end
+
+  def min_version=(version); end
+  DEFAULT_TMP_DH_CALLBACK = ::T.let(nil, ::T.untyped)
+end
+
+class OpenSSL::SSL::SSLSocket
+  def alpn_protocol(); end
+
+  def tmp_key(); end
+end
+
+module OpenSSL::X509
+  V_FLAG_NO_CHECK_TIME = ::T.let(nil, ::T.untyped)
+  V_FLAG_TRUSTED_FIRST = ::T.let(nil, ::T.untyped)
+end
+
+class OpenSSL::X509::Attribute
+  def ==(other); end
+end
+
+class OpenSSL::X509::CRL
+  def ==(other); end
+end
+
+class OpenSSL::X509::Extension
+  def ==(other); end
+end
+
+class OpenSSL::X509::Name
+  def to_utf8(); end
+end
+
+class OpenSSL::X509::Request
+  def ==(other); end
+end
+
+class OpenSSL::X509::Revoked
+  def ==(other); end
+
+  def to_der(); end
+end
+
+module OpenSSL
+  def self.fips_mode(); end
+end
+
+module OpenTracing
+  FORMAT_BINARY = ::T.let(nil, ::T.untyped)
+  FORMAT_RACK = ::T.let(nil, ::T.untyped)
+  FORMAT_TEXT_MAP = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class OpenTracing::Reference
+  def context(); end
+
+  def initialize(type, context); end
+
+  def type(); end
+  CHILD_OF = ::T.let(nil, ::T.untyped)
+  FOLLOWS_FROM = ::T.let(nil, ::T.untyped)
+end
+
+class OpenTracing::Reference
+  def self.child_of(context); end
+
+  def self.follows_from(context); end
+end
+
+class OpenTracing::Scope
+  def close(); end
+
+  def span(); end
+  NOOP_INSTANCE = ::T.let(nil, ::T.untyped)
+end
+
+class OpenTracing::Scope
+end
+
+class OpenTracing::ScopeManager
+  def activate(span, finish_on_close: T.unsafe(nil)); end
+
+  def active(); end
+  NOOP_INSTANCE = ::T.let(nil, ::T.untyped)
+end
+
+class OpenTracing::ScopeManager
+end
+
+class OpenTracing::Span
+  def context(); end
+
+  def finish(end_time: T.unsafe(nil)); end
+
+  def get_baggage_item(key); end
+
+  def log(event: T.unsafe(nil), timestamp: T.unsafe(nil), **fields); end
+
+  def log_kv(timestamp: T.unsafe(nil), **fields); end
+
+  def operation_name=(name); end
+
+  def set_baggage_item(key, value); end
+
+  def set_tag(key, value); end
+  NOOP_INSTANCE = ::T.let(nil, ::T.untyped)
+end
+
+class OpenTracing::Span
+end
+
+class OpenTracing::SpanContext
+  def baggage(); end
+
+  def initialize(baggage: T.unsafe(nil)); end
+  NOOP_INSTANCE = ::T.let(nil, ::T.untyped)
+end
+
+class OpenTracing::SpanContext
+end
+
+class OpenTracing::Tracer
+  def active_span(); end
+
+  def extract(format, carrier); end
+
+  def inject(span_context, format, carrier); end
+
+  def scope_manager(); end
+
+  def start_active_span(operation_name, child_of: T.unsafe(nil), references: T.unsafe(nil), start_time: T.unsafe(nil), tags: T.unsafe(nil), ignore_active_scope: T.unsafe(nil), finish_on_close: T.unsafe(nil)); end
+
+  def start_span(operation_name, child_of: T.unsafe(nil), references: T.unsafe(nil), start_time: T.unsafe(nil), tags: T.unsafe(nil), ignore_active_scope: T.unsafe(nil)); end
+end
+
+class OpenTracing::Tracer
+end
+
+module OpenTracing
+  def self.active_span(*args, &block); end
+
+  def self.extract(*args, &block); end
+
+  def self.global_tracer(); end
+
+  def self.global_tracer=(global_tracer); end
+
+  def self.inject(*args, &block); end
+
+  def self.scope_manager(*args, &block); end
+
+  def self.start_active_span(*args, &block); end
+
+  def self.start_span(*args, &block); end
+end
+
+module Parallel
+  Stop = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+  Version = ::T.let(nil, ::T.untyped)
+end
+
+class Parallel::Break
+end
+
+class Parallel::Break
+end
+
+class Parallel::DeadWorker
+end
+
+class Parallel::DeadWorker
+end
+
+class Parallel::ExceptionWrapper
+  def exception(); end
+
+  def initialize(exception); end
+end
+
+class Parallel::ExceptionWrapper
+end
+
+class Parallel::JobFactory
+  def initialize(source, mutex); end
+
+  def next(); end
+
+  def pack(item, index); end
+
+  def size(); end
+
+  def unpack(data); end
+end
+
+class Parallel::JobFactory
+end
+
+class Parallel::Kill
+end
+
+class Parallel::Kill
+end
+
+module Parallel::ProcessorCount
+  def physical_processor_count(); end
+
+  def processor_count(); end
+end
+
+module Parallel::ProcessorCount
+end
+
+class Parallel::UndumpableException
+  def initialize(original); end
+end
+
+class Parallel::UndumpableException
+end
+
+class Parallel::UserInterruptHandler
+  INTERRUPT_SIGNAL = ::T.let(nil, ::T.untyped)
+end
+
+class Parallel::UserInterruptHandler
+  def self.kill(thing); end
+
+  def self.kill_on_ctrl_c(pids, options); end
+end
+
+class Parallel::Worker
+  def close_pipes(); end
+
+  def initialize(read, write, pid); end
+
+  def pid(); end
+
+  def read(); end
+
+  def stop(); end
+
+  def thread(); end
+
+  def thread=(thread); end
+
+  def work(data); end
+
+  def write(); end
+end
+
+class Parallel::Worker
+end
+
+module Parallel
+  extend ::Parallel::ProcessorCount
+  def self.all?(*args, &block); end
+
+  def self.any?(*args, &block); end
+
+  def self.each(array, options=T.unsafe(nil), &block); end
+
+  def self.each_with_index(array, options=T.unsafe(nil), &block); end
+
+  def self.flat_map(*args, &block); end
+
+  def self.in_processes(options=T.unsafe(nil), &block); end
+
+  def self.in_threads(options=T.unsafe(nil)); end
+
+  def self.map(source, options=T.unsafe(nil), &block); end
+
+  def self.map_with_index(array, options=T.unsafe(nil), &block); end
+
+  def self.worker_number(); end
+
+  def self.worker_number=(worker_num); end
+end
+
+ParseError = Racc::ParseError
+
+module Parser
+  MESSAGES = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+module Parser::AST
+end
+
+class Parser::AST::Node
+  def loc(); end
+
+  def location(); end
+end
+
+class Parser::AST::Node
+end
+
+class Parser::AST::Processor
+  def on_alias(node); end
+
+  def on_and(node); end
+
+  def on_and_asgn(node); end
+
+  def on_arg(node); end
+
+  def on_arg_expr(node); end
+
+  def on_args(node); end
+
+  def on_argument(node); end
+
+  def on_array(node); end
+
+  def on_array_pattern(node); end
+
+  def on_array_pattern_with_tail(node); end
+
+  def on_back_ref(node); end
+
+  def on_begin(node); end
+
+  def on_block(node); end
+
+  def on_block_pass(node); end
+
+  def on_blockarg(node); end
+
+  def on_blockarg_expr(node); end
+
+  def on_break(node); end
+
+  def on_case(node); end
+
+  def on_case_match(node); end
+
+  def on_casgn(node); end
+
+  def on_class(node); end
+
+  def on_const(node); end
+
+  def on_const_pattern(node); end
+
+  def on_csend(node); end
+
+  def on_cvar(node); end
+
+  def on_cvasgn(node); end
+
+  def on_def(node); end
+
+  def on_defined?(node); end
+
+  def on_defs(node); end
+
+  def on_dstr(node); end
+
+  def on_dsym(node); end
+
+  def on_eflipflop(node); end
+
+  def on_empty_else(node); end
+
+  def on_ensure(node); end
+
+  def on_erange(node); end
+
+  def on_for(node); end
+
+  def on_gvar(node); end
+
+  def on_gvasgn(node); end
+
+  def on_hash(node); end
+
+  def on_hash_pattern(node); end
+
+  def on_if(node); end
+
+  def on_if_guard(node); end
+
+  def on_iflipflop(node); end
+
+  def on_in_match(node); end
+
+  def on_in_pattern(node); end
+
+  def on_index(node); end
+
+  def on_indexasgn(node); end
+
+  def on_irange(node); end
+
+  def on_ivar(node); end
+
+  def on_ivasgn(node); end
+
+  def on_kwarg(node); end
+
+  def on_kwbegin(node); end
+
+  def on_kwoptarg(node); end
+
+  def on_kwrestarg(node); end
+
+  def on_kwsplat(node); end
+
+  def on_lambda(node); end
+
+  def on_lvar(node); end
+
+  def on_lvasgn(node); end
+
+  def on_masgn(node); end
+
+  def on_match_alt(node); end
+
+  def on_match_as(node); end
+
+  def on_match_current_line(node); end
+
+  def on_match_rest(node); end
+
+  def on_match_var(node); end
+
+  def on_match_with_lvasgn(node); end
+
+  def on_mlhs(node); end
+
+  def on_module(node); end
+
+  def on_next(node); end
+
+  def on_not(node); end
+
+  def on_nth_ref(node); end
+
+  def on_numblock(node); end
+
+  def on_op_asgn(node); end
+
+  def on_optarg(node); end
+
+  def on_or(node); end
+
+  def on_or_asgn(node); end
+
+  def on_pair(node); end
+
+  def on_pin(node); end
+
+  def on_postexe(node); end
+
+  def on_preexe(node); end
+
+  def on_procarg0(node); end
+
+  def on_redo(node); end
+
+  def on_regexp(node); end
+
+  def on_resbody(node); end
+
+  def on_rescue(node); end
+
+  def on_restarg(node); end
+
+  def on_restarg_expr(node); end
+
+  def on_retry(node); end
+
+  def on_return(node); end
+
+  def on_sclass(node); end
+
+  def on_send(node); end
+
+  def on_shadowarg(node); end
+
+  def on_splat(node); end
+
+  def on_super(node); end
+
+  def on_undef(node); end
+
+  def on_unless_guard(node); end
+
+  def on_until(node); end
+
+  def on_until_post(node); end
+
+  def on_var(node); end
+
+  def on_vasgn(node); end
+
+  def on_when(node); end
+
+  def on_while(node); end
+
+  def on_while_post(node); end
+
+  def on_xstr(node); end
+
+  def on_yield(node); end
+
+  def process_argument_node(node); end
+
+  def process_regular_node(node); end
+
+  def process_var_asgn_node(node); end
+
+  def process_variable_node(node); end
+end
+
+class Parser::AST::Processor
+end
+
+module Parser::AST
+end
+
+class Parser::Base
+  def builder(); end
+
+  def context(); end
+
+  def current_arg_stack(); end
+
+  def diagnostics(); end
+
+  def initialize(builder=T.unsafe(nil)); end
+
+  def max_numparam_stack(); end
+
+  def parse(source_buffer); end
+
+  def parse_with_comments(source_buffer); end
+
+  def pattern_hash_keys(); end
+
+  def pattern_variables(); end
+
+  def reset(); end
+
+  def source_buffer(); end
+
+  def static_env(); end
+
+  def tokenize(source_buffer, recover=T.unsafe(nil)); end
+end
+
+class Parser::Base
+  def self.default_parser(); end
+
+  def self.parse(string, file=T.unsafe(nil), line=T.unsafe(nil)); end
+
+  def self.parse_file(filename); end
+
+  def self.parse_file_with_comments(filename); end
+
+  def self.parse_with_comments(string, file=T.unsafe(nil), line=T.unsafe(nil)); end
+end
+
+module Parser::Builders
+end
+
+class Parser::Builders::Default
+  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_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=(emit_file_line_as_literals); end
+
+  def false(false_t); end
+
+  def float(float_t); end
+
+  def for(for_t, iterator, in_t, iteratee, do_t, body, end_t); end
+
+  def forward_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_rest(star_t, name_t=T.unsafe(nil)); end
+
+  def match_var(name_t); end
+
+  def match_with_trailing_comma(match); 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=(parser); 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
+end
+
+class Parser::Builders::Default
+  def self.emit_arg_inside_procarg0(); end
+
+  def self.emit_arg_inside_procarg0=(emit_arg_inside_procarg0); end
+
+  def self.emit_encoding(); end
+
+  def self.emit_encoding=(emit_encoding); end
+
+  def self.emit_index(); end
+
+  def self.emit_index=(emit_index); end
+
+  def self.emit_lambda(); end
+
+  def self.emit_lambda=(emit_lambda); end
+
+  def self.emit_procarg0(); end
+
+  def self.emit_procarg0=(emit_procarg0); end
+
+  def self.modernize(); end
+end
+
+module Parser::Builders
+end
+
+class Parser::ClobberingError
+end
+
+class Parser::ClobberingError
+end
+
+class Parser::Context
+  def class_definition_allowed?(); end
+
+  def dynamic_const_definition_allowed?(); end
+
+  def in_block?(); end
+
+  def in_class?(); end
+
+  def in_dynamic_block?(); end
+
+  def in_lambda?(); end
+
+  def indirectly_in_def?(); end
+
+  def module_definition_allowed?(); end
+
+  def pop(); end
+
+  def push(state); end
+
+  def reset(); end
+
+  def stack(); end
+end
+
+class Parser::Context
+end
+
+class Parser::CurrentArgStack
+  def pop(); end
+
+  def push(value); end
+
+  def reset(); end
+
+  def set(value); end
+
+  def stack(); end
+
+  def top(); end
+end
+
+class Parser::CurrentArgStack
+end
+
+module Parser::Deprecation
+  def warn_of_deprecation(); end
+
+  def warned_of_deprecation=(warned_of_deprecation); end
+end
+
+module Parser::Deprecation
+end
+
+class Parser::Diagnostic
+  def arguments(); end
+
+  def highlights(); end
+
+  def initialize(level, reason, arguments, location, highlights=T.unsafe(nil)); end
+
+  def level(); end
+
+  def location(); end
+
+  def message(); end
+
+  def reason(); end
+
+  def render(); end
+  LEVELS = ::T.let(nil, ::T.untyped)
+end
+
+class Parser::Diagnostic::Engine
+  def all_errors_are_fatal(); end
+
+  def all_errors_are_fatal=(all_errors_are_fatal); end
+
+  def consumer(); end
+
+  def consumer=(consumer); end
+
+  def ignore?(diagnostic); end
+
+  def ignore_warnings(); end
+
+  def ignore_warnings=(ignore_warnings); end
+
+  def initialize(consumer=T.unsafe(nil)); end
+
+  def process(diagnostic); end
+
+  def raise?(diagnostic); end
+end
+
+class Parser::Diagnostic::Engine
+end
+
+class Parser::Diagnostic
+end
+
+class Parser::Lexer
+  def advance(); end
+
+  def arg_or_cmdarg(cmd_state); end
+
+  def cmdarg(); end
+
+  def cmdarg=(cmdarg); end
+
+  def command_start(); end
+
+  def command_start=(command_start); end
+
+  def comments(); end
+
+  def comments=(comments); end
+
+  def cond(); end
+
+  def cond=(cond); end
+
+  def context(); end
+
+  def context=(context); end
+
+  def dedent_level(); end
+
+  def diagnostic(type, reason, arguments=T.unsafe(nil), location=T.unsafe(nil), highlights=T.unsafe(nil)); end
+
+  def diagnostics(); end
+
+  def diagnostics=(diagnostics); end
+
+  def emit(type, value=T.unsafe(nil), s=T.unsafe(nil), e=T.unsafe(nil)); end
+
+  def emit_comment(s=T.unsafe(nil), e=T.unsafe(nil)); end
+
+  def emit_do(do_block=T.unsafe(nil)); end
+
+  def emit_table(table, s=T.unsafe(nil), e=T.unsafe(nil)); end
+
+  def encode_escape(ord); end
+
+  def encoding(); end
+
+  def eof_codepoint?(point); end
+
+  def force_utf32(); end
+
+  def force_utf32=(force_utf32); end
+
+  def in_kwarg(); end
+
+  def in_kwarg=(in_kwarg); end
+
+  def initialize(version); end
+
+  def literal(); end
+
+  def next_state_for_literal(literal); end
+
+  def pop_cmdarg(); end
+
+  def pop_cond(); end
+
+  def pop_literal(); end
+
+  def push_cmdarg(); end
+
+  def push_cond(); end
+
+  def push_literal(*args); end
+
+  def range(s=T.unsafe(nil), e=T.unsafe(nil)); end
+
+  def reset(reset_state=T.unsafe(nil)); end
+
+  def source_buffer(); end
+
+  def source_buffer=(source_buffer); end
+
+  def stack_pop(); end
+
+  def state(); end
+
+  def state=(state); end
+
+  def static_env(); end
+
+  def static_env=(static_env); end
+
+  def tok(s=T.unsafe(nil), e=T.unsafe(nil)); end
+
+  def tokens(); end
+
+  def tokens=(tokens); end
+
+  def version?(*versions); end
+  ESCAPES = ::T.let(nil, ::T.untyped)
+  KEYWORDS = ::T.let(nil, ::T.untyped)
+  KEYWORDS_BEGIN = ::T.let(nil, ::T.untyped)
+  LEX_STATES = ::T.let(nil, ::T.untyped)
+  PUNCTUATION = ::T.let(nil, ::T.untyped)
+  PUNCTUATION_BEGIN = ::T.let(nil, ::T.untyped)
+  REGEXP_META_CHARACTERS = ::T.let(nil, ::T.untyped)
+end
+
+class Parser::Lexer::Dedenter
+  def dedent(string); end
+
+  def initialize(dedent_level); end
+
+  def interrupt(); end
+  TAB_WIDTH = ::T.let(nil, ::T.untyped)
+end
+
+class Parser::Lexer::Dedenter
+end
+
+class Parser::Lexer::Literal
+  def backslash_delimited?(); end
+
+  def clear_buffer(); end
+
+  def coerce_encoding(string); end
+
+  def dedent_level(); end
+
+  def delimiter?(delimiter); end
+
+  def emit(token, type, s, e); end
+
+  def emit_start_tok(); end
+
+  def end_interp_brace_and_try_closing(); end
+
+  def extend_content(); end
+
+  def extend_space(ts, te); end
+
+  def extend_string(string, ts, te); end
+
+  def flush_string(); end
+
+  def heredoc?(); end
+
+  def heredoc_e(); end
+
+  def infer_indent_level(line); end
+
+  def initialize(lexer, str_type, delimiter, str_s, heredoc_e=T.unsafe(nil), indent=T.unsafe(nil), dedent_body=T.unsafe(nil), label_allowed=T.unsafe(nil)); end
+
+  def interpolate?(); end
+
+  def munge_escape?(character); end
+
+  def nest_and_try_closing(delimiter, ts, te, lookahead=T.unsafe(nil)); end
+
+  def plain_heredoc?(); end
+
+  def regexp?(); end
+
+  def saved_herebody_s(); end
+
+  def saved_herebody_s=(saved_herebody_s); end
+
+  def squiggly_heredoc?(); end
+
+  def start_interp_brace(); end
+
+  def str_s(); end
+
+  def supports_line_continuation_via_slash?(); end
+
+  def type(); end
+
+  def words?(); end
+  DELIMITERS = ::T.let(nil, ::T.untyped)
+  TYPES = ::T.let(nil, ::T.untyped)
+end
+
+class Parser::Lexer::Literal
+end
+
+class Parser::Lexer::StackState
+  def active?(); end
+
+  def clear(); end
+
+  def empty?(); end
+
+  def initialize(name); end
+
+  def lexpop(); end
+
+  def pop(); end
+
+  def push(bit); end
+end
+
+class Parser::Lexer::StackState
+end
+
+class Parser::Lexer
+  def self.lex_en_expr_arg(); end
+
+  def self.lex_en_expr_arg=(lex_en_expr_arg); end
+
+  def self.lex_en_expr_beg(); end
+
+  def self.lex_en_expr_beg=(lex_en_expr_beg); end
+
+  def self.lex_en_expr_cmdarg(); end
+
+  def self.lex_en_expr_cmdarg=(lex_en_expr_cmdarg); end
+
+  def self.lex_en_expr_dot(); end
+
+  def self.lex_en_expr_dot=(lex_en_expr_dot); end
+
+  def self.lex_en_expr_end(); end
+
+  def self.lex_en_expr_end=(lex_en_expr_end); end
+
+  def self.lex_en_expr_endarg(); end
+
+  def self.lex_en_expr_endarg=(lex_en_expr_endarg); end
+
+  def self.lex_en_expr_endfn(); end
+
+  def self.lex_en_expr_endfn=(lex_en_expr_endfn); end
+
+  def self.lex_en_expr_fname(); end
+
+  def self.lex_en_expr_fname=(lex_en_expr_fname); end
+
+  def self.lex_en_expr_labelarg(); end
+
+  def self.lex_en_expr_labelarg=(lex_en_expr_labelarg); end
+
+  def self.lex_en_expr_mid(); end
+
+  def self.lex_en_expr_mid=(lex_en_expr_mid); end
+
+  def self.lex_en_expr_value(); end
+
+  def self.lex_en_expr_value=(lex_en_expr_value); end
+
+  def self.lex_en_expr_variable(); end
+
+  def self.lex_en_expr_variable=(lex_en_expr_variable); end
+
+  def self.lex_en_interp_backslash_delimited(); end
+
+  def self.lex_en_interp_backslash_delimited=(lex_en_interp_backslash_delimited); end
+
+  def self.lex_en_interp_backslash_delimited_words(); end
+
+  def self.lex_en_interp_backslash_delimited_words=(lex_en_interp_backslash_delimited_words); end
+
+  def self.lex_en_interp_string(); end
+
+  def self.lex_en_interp_string=(lex_en_interp_string); end
+
+  def self.lex_en_interp_words(); end
+
+  def self.lex_en_interp_words=(lex_en_interp_words); end
+
+  def self.lex_en_leading_dot(); end
+
+  def self.lex_en_leading_dot=(lex_en_leading_dot); end
+
+  def self.lex_en_line_begin(); end
+
+  def self.lex_en_line_begin=(lex_en_line_begin); end
+
+  def self.lex_en_line_comment(); end
+
+  def self.lex_en_line_comment=(lex_en_line_comment); end
+
+  def self.lex_en_plain_backslash_delimited(); end
+
+  def self.lex_en_plain_backslash_delimited=(lex_en_plain_backslash_delimited); end
+
+  def self.lex_en_plain_backslash_delimited_words(); end
+
+  def self.lex_en_plain_backslash_delimited_words=(lex_en_plain_backslash_delimited_words); end
+
+  def self.lex_en_plain_string(); end
+
+  def self.lex_en_plain_string=(lex_en_plain_string); end
+
+  def self.lex_en_plain_words(); end
+
+  def self.lex_en_plain_words=(lex_en_plain_words); end
+
+  def self.lex_en_regexp_modifiers(); end
+
+  def self.lex_en_regexp_modifiers=(lex_en_regexp_modifiers); end
+
+  def self.lex_error(); end
+
+  def self.lex_error=(lex_error); end
+
+  def self.lex_start(); end
+
+  def self.lex_start=(lex_start); end
+end
+
+class Parser::MaxNumparamStack
+  def has_numparams?(); end
+
+  def has_ordinary_params!(); end
+
+  def has_ordinary_params?(); end
+
+  def pop(); end
+
+  def push(); end
+
+  def register(numparam); end
+
+  def stack(); end
+
+  def top(); end
+end
+
+class Parser::MaxNumparamStack
+end
+
+module Parser::Meta
+  NODE_TYPES = ::T.let(nil, ::T.untyped)
+end
+
+module Parser::Meta
+end
+
+class Parser::Rewriter
+  def assignment?(node); end
+
+  def initialize(*_); end
+
+  def insert_after(range, content); end
+
+  def insert_before(range, content); end
+
+  def remove(range); end
+
+  def replace(range, content); end
+
+  def rewrite(source_buffer, ast); end
+
+  def wrap(range, before, after); end
+  DEPRECATION_WARNING = ::T.let(nil, ::T.untyped)
+end
+
+class Parser::Rewriter
+  extend ::Parser::Deprecation
+end
+
+module Parser::Source
+end
+
+class Parser::Source::Buffer
+  def column_for_position(position); end
+
+  def decompose_position(position); end
+
+  def first_line(); end
+
+  def initialize(name, first_line=T.unsafe(nil)); 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
+  ENCODING_RE = ::T.let(nil, ::T.untyped)
+end
+
+class Parser::Source::Buffer
+  def self.recognize_encoding(string); end
+
+  def self.reencode_string(input); end
+end
+
+class Parser::Source::Comment
+  def ==(other); end
+
+  def document?(); end
+
+  def initialize(range); end
+
+  def inline?(); end
+
+  def loc(); end
+
+  def location(); end
+
+  def text(); end
+
+  def type(); end
+end
+
+class Parser::Source::Comment::Associator
+  def associate(); end
+
+  def associate_locations(); end
+
+  def initialize(ast, comments); end
+
+  def skip_directives(); end
+
+  def skip_directives=(skip_directives); end
+  MAGIC_COMMENT_RE = ::T.let(nil, ::T.untyped)
+end
+
+class Parser::Source::Comment::Associator
+end
+
+class Parser::Source::Comment
+  def self.associate(ast, comments); end
+
+  def self.associate_locations(ast, comments); end
+end
+
+class Parser::Source::Map
+  def ==(other); end
+
+  def column(); end
+
+  def expression(); end
+
+  def first_line(); end
+
+  def initialize(expression); end
+
+  def last_column(); end
+
+  def last_line(); end
+
+  def line(); end
+
+  def node(); end
+
+  def node=(node); end
+
+  def to_hash(); end
+
+  def update_expression(expression_l); end
+
+  def with(&block); end
+
+  def with_expression(expression_l); end
+end
+
+class Parser::Source::Map::Collection
+  def begin(); end
+
+  def end(); end
+
+  def initialize(begin_l, end_l, expression_l); end
+end
+
+class Parser::Source::Map::Collection
+end
+
+class Parser::Source::Map::Condition
+  def begin(); end
+
+  def else(); end
+
+  def end(); end
+
+  def initialize(keyword_l, begin_l, else_l, end_l, expression_l); end
+
+  def keyword(); end
+end
+
+class Parser::Source::Map::Condition
+end
+
+class Parser::Source::Map::Constant
+  def double_colon(); end
+
+  def initialize(double_colon, name, expression); end
+
+  def name(); end
+
+  def operator(); end
+
+  def update_operator(operator_l); end
+
+  def with_operator(operator_l); end
+end
+
+class Parser::Source::Map::Constant
+end
+
+class Parser::Source::Map::Definition
+  def end(); end
+
+  def initialize(keyword_l, operator_l, name_l, end_l); end
+
+  def keyword(); end
+
+  def name(); end
+
+  def operator(); end
+end
+
+class Parser::Source::Map::Definition
+end
+
+class Parser::Source::Map::For
+  def begin(); end
+
+  def end(); end
+
+  def in(); end
+
+  def initialize(keyword_l, in_l, begin_l, end_l, expression_l); end
+
+  def keyword(); end
+end
+
+class Parser::Source::Map::For
+end
+
+class Parser::Source::Map::Heredoc
+  def heredoc_body(); end
+
+  def heredoc_end(); end
+
+  def initialize(begin_l, body_l, end_l); end
+end
+
+class Parser::Source::Map::Heredoc
+end
+
+class Parser::Source::Map::Index
+  def begin(); end
+
+  def end(); end
+
+  def initialize(begin_l, end_l, expression_l); end
+
+  def operator(); end
+
+  def update_operator(operator_l); end
+
+  def with_operator(operator_l); end
+end
+
+class Parser::Source::Map::Index
+end
+
+class Parser::Source::Map::Keyword
+  def begin(); end
+
+  def end(); end
+
+  def initialize(keyword_l, begin_l, end_l, expression_l); end
+
+  def keyword(); end
+end
+
+class Parser::Source::Map::Keyword
+end
+
+class Parser::Source::Map::ObjcKwarg
+  def argument(); end
+
+  def initialize(keyword_l, operator_l, argument_l, expression_l); end
+
+  def keyword(); end
+
+  def operator(); end
+end
+
+class Parser::Source::Map::ObjcKwarg
+end
+
+class Parser::Source::Map::Operator
+  def initialize(operator, expression); end
+
+  def operator(); end
+end
+
+class Parser::Source::Map::Operator
+end
+
+class Parser::Source::Map::RescueBody
+  def assoc(); end
+
+  def begin(); end
+
+  def initialize(keyword_l, assoc_l, begin_l, expression_l); end
+
+  def keyword(); end
+end
+
+class Parser::Source::Map::RescueBody
+end
+
+class Parser::Source::Map::Send
+  def begin(); end
+
+  def dot(); end
+
+  def end(); end
+
+  def initialize(dot_l, selector_l, begin_l, end_l, expression_l); end
+
+  def operator(); end
+
+  def selector(); end
+
+  def update_operator(operator_l); end
+
+  def with_operator(operator_l); end
+end
+
+class Parser::Source::Map::Send
+end
+
+class Parser::Source::Map::Ternary
+  def colon(); end
+
+  def initialize(question_l, colon_l, expression_l); end
+
+  def question(); end
+end
+
+class Parser::Source::Map::Ternary
+end
+
+class Parser::Source::Map::Variable
+  def initialize(name_l, expression_l=T.unsafe(nil)); end
+
+  def name(); end
+
+  def operator(); end
+
+  def update_operator(operator_l); end
+
+  def with_operator(operator_l); end
+end
+
+class Parser::Source::Map::Variable
+end
+
+class Parser::Source::Map
+end
+
+class Parser::Source::Range
+  include ::Comparable
+  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 first_line(); end
+
+  def initialize(source_buffer, begin_pos, end_pos); 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 with(begin_pos: T.unsafe(nil), end_pos: T.unsafe(nil)); end
+end
+
+class Parser::Source::Range
+end
+
+class Parser::Source::Rewriter
+  def diagnostics(); end
+
+  def initialize(source_buffer); end
+
+  def insert_after(range, content); end
+
+  def insert_after_multi(range, content); end
+
+  def insert_before(range, content); end
+
+  def insert_before_multi(range, content); end
+
+  def process(); end
+
+  def remove(range); end
+
+  def replace(range, content); end
+
+  def source_buffer(); end
+
+  def transaction(); end
+
+  def wrap(range, before, after); end
+  DEPRECATION_WARNING = ::T.let(nil, ::T.untyped)
+end
+
+class Parser::Source::Rewriter::Action
+  include ::Comparable
+  def allow_multiple_insertions(); end
+
+  def allow_multiple_insertions?(); end
+
+  def initialize(range, replacement=T.unsafe(nil), allow_multiple_insertions=T.unsafe(nil), order=T.unsafe(nil)); end
+
+  def order(); end
+
+  def range(); end
+
+  def replacement(); end
+end
+
+class Parser::Source::Rewriter::Action
+end
+
+class Parser::Source::Rewriter
+  extend ::Parser::Deprecation
+end
+
+class Parser::Source::TreeRewriter
+  def diagnostics(); end
+
+  def in_transaction?(); end
+
+  def initialize(source_buffer, crossing_deletions: T.unsafe(nil), different_replacements: T.unsafe(nil), swallowed_insertions: T.unsafe(nil)); 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 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
+  ACTIONS = ::T.let(nil, ::T.untyped)
+  DEPRECATION_WARNING = ::T.let(nil, ::T.untyped)
+  POLICY_TO_LEVEL = ::T.let(nil, ::T.untyped)
+end
+
+class Parser::Source::TreeRewriter::Action
+  def call_enforcer_for_merge(action); end
+
+  def combine(action); end
+
+  def do_combine(action); end
+
+  def fuse_deletions(action, fusible, other_sibblings); end
+
+  def initialize(range, enforcer, insert_before: T.unsafe(nil), replacement: T.unsafe(nil), insert_after: T.unsafe(nil), children: T.unsafe(nil)); end
+
+  def insert_after(); end
+
+  def insert_before(); end
+
+  def insertion?(); end
+
+  def merge(action); end
+
+  def ordered_replacements(); end
+
+  def place_in_hierarchy(action); end
+
+  def range(); end
+
+  def relationship_with(action); end
+
+  def replacement(); end
+
+  def swallow(children); end
+
+  def with(range: T.unsafe(nil), children: T.unsafe(nil), insert_before: T.unsafe(nil), replacement: T.unsafe(nil), insert_after: T.unsafe(nil)); end
+end
+
+class Parser::Source::TreeRewriter::Action
+end
+
+class Parser::Source::TreeRewriter
+  extend ::Parser::Deprecation
+end
+
+module Parser::Source
+end
+
+class Parser::StaticEnvironment
+  def declare(name); end
+
+  def declare_forward_args(); end
+
+  def declared?(name); end
+
+  def declared_forward_args?(); end
+
+  def extend_dynamic(); end
+
+  def extend_static(); end
+
+  def reset(); end
+
+  def unextend(); end
+  FORWARD_ARGS = ::T.let(nil, ::T.untyped)
+end
+
+class Parser::StaticEnvironment
+end
+
+class Parser::SyntaxError
+  def diagnostic(); end
+
+  def initialize(diagnostic); end
+end
+
+class Parser::SyntaxError
+end
+
+class Parser::TreeRewriter
+  def assignment?(node); end
+
+  def insert_after(range, content); end
+
+  def insert_before(range, content); end
+
+  def remove(range); end
+
+  def replace(range, content); end
+
+  def rewrite(source_buffer, ast, **policy); end
+
+  def wrap(range, before, after); end
+end
+
+class Parser::TreeRewriter
+end
+
+class Parser::VariablesStack
+  def declare(name); end
+
+  def declared?(name); end
+
+  def pop(); end
+
+  def push(); end
+
+  def reset(); end
+end
+
+class Parser::VariablesStack
+end
+
+module Parser
+end
+
+class Pathname
+  def empty?(); end
+
+  def fnmatch?(*_); end
+
+  def glob(*_); end
+
+  def make_symlink(_); end
+end
+
+class Proc
+  def <<(_); end
+
+  def ===(*_); end
+
+  def >>(_); end
+
+  def clone(); end
+
+  def yield(*_); end
+end
+
+module Process::Sys
+  def self.getegid(); end
+end
+
+class Process::Tms
+  def cstime(); end
+
+  def cstime=(_); end
+
+  def cutime(); end
+
+  def cutime=(_); end
+
+  def stime(); end
+
+  def stime=(_); end
+
+  def utime(); end
+
+  def utime=(_); end
+end
+
+class Process::Tms
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+module Process
+  def self.last_status(); end
+
+  def self.setpgrp(); end
+end
+
+class ProgressBar
+end
+
+class ProgressBar::Base
+  def autofinish(); end
+
+  def autofinish=(autofinish); end
+
+  def autostart(); end
+
+  def autostart=(autostart); end
+
+  def bar(); end
+
+  def bar=(bar); end
+
+  def clear(*args, &block); end
+
+  def decrement(); end
+
+  def finish(); end
+
+  def finished(); end
+
+  def finished=(finished); end
+
+  def finished?(); end
+
+  def format(other); end
+
+  def format=(other); end
+
+  def increment(); end
+
+  def initialize(options=T.unsafe(nil)); end
+
+  def log(*args, &block); end
+
+  def output(); end
+
+  def output=(output); end
+
+  def pause(); end
+
+  def paused?(); end
+
+  def percentage(); end
+
+  def percentage=(percentage); end
+
+  def progress(*args, &block); end
+
+  def progress=(new_progress); end
+
+  def progress_mark=(mark); end
+
+  def progressable(); end
+
+  def progressable=(progressable); end
+
+  def rate(); end
+
+  def rate=(rate); end
+
+  def refresh(*args, &block); end
+
+  def remainder_mark=(mark); end
+
+  def reset(); end
+
+  def resume(); end
+
+  def start(options=T.unsafe(nil)); end
+
+  def started?(); end
+
+  def stop(); end
+
+  def stopped?(); end
+
+  def time(); end
+
+  def time=(time); end
+
+  def timer(); end
+
+  def timer=(timer); end
+
+  def title(); end
+
+  def title=(title); end
+
+  def title_comp(); end
+
+  def title_comp=(title_comp); end
+
+  def to_h(); end
+
+  def to_s(new_format=T.unsafe(nil)); end
+
+  def total(*args, &block); end
+
+  def total=(new_total); end
+
+  def update_progress(*args); end
+end
+
+class ProgressBar::Base
+  extend ::Forwardable
+end
+
+module ProgressBar::Calculators
+end
+
+class ProgressBar::Calculators::Length
+  def calculate_length(); end
+
+  def current_length(); end
+
+  def current_length=(current_length); end
+
+  def initialize(options=T.unsafe(nil)); end
+
+  def length(); end
+
+  def length_changed?(); end
+
+  def length_override(); end
+
+  def length_override=(other); end
+
+  def output(); end
+
+  def output=(output); end
+
+  def reset_length(); end
+end
+
+class ProgressBar::Calculators::Length
+end
+
+class ProgressBar::Calculators::RunningAverage
+end
+
+class ProgressBar::Calculators::RunningAverage
+  def self.calculate(current_average, new_value_to_average, smoothing_factor); end
+end
+
+module ProgressBar::Calculators
+end
+
+module ProgressBar::Components
+end
+
+class ProgressBar::Components::Bar
+  def initialize(options=T.unsafe(nil)); end
+
+  def length(); end
+
+  def length=(length); end
+
+  def progress(); end
+
+  def progress=(progress); end
+
+  def progress_mark(); end
+
+  def progress_mark=(progress_mark); end
+
+  def remainder_mark(); end
+
+  def remainder_mark=(remainder_mark); end
+
+  def to_s(options=T.unsafe(nil)); end
+
+  def upa_steps(); end
+
+  def upa_steps=(upa_steps); end
+  DEFAULT_PROGRESS_MARK = ::T.let(nil, ::T.untyped)
+  DEFAULT_REMAINDER_MARK = ::T.let(nil, ::T.untyped)
+  DEFAULT_UPA_STEPS = ::T.let(nil, ::T.untyped)
+end
+
+class ProgressBar::Components::Bar
+end
+
+class ProgressBar::Components::Percentage
+  def initialize(options=T.unsafe(nil)); end
+
+  def progress(); end
+
+  def progress=(progress); end
+end
+
+class ProgressBar::Components::Percentage
+end
+
+class ProgressBar::Components::Rate
+  def initialize(options=T.unsafe(nil)); end
+
+  def progress(); end
+
+  def progress=(progress); end
+
+  def rate_scale(); end
+
+  def rate_scale=(rate_scale); end
+
+  def started_at(); end
+
+  def started_at=(started_at); end
+
+  def stopped_at(); end
+
+  def stopped_at=(stopped_at); end
+
+  def timer(); end
+
+  def timer=(timer); end
+end
+
+class ProgressBar::Components::Rate
+end
+
+class ProgressBar::Components::Time
+  def elapsed_with_label(); end
+
+  def estimated_with_friendly_oob(); end
+
+  def estimated_with_label(); end
+
+  def estimated_with_no_oob(); end
+
+  def estimated_with_unknown_oob(); end
+
+  def initialize(options=T.unsafe(nil)); end
+
+  def out_of_bounds_time_format(); end
+
+  def out_of_bounds_time_format=(format); end
+
+  def progress(); end
+
+  def progress=(progress); end
+
+  def timer(); end
+
+  def timer=(timer); end
+  ELAPSED_LABEL = ::T.let(nil, ::T.untyped)
+  ESTIMATED_LABEL = ::T.let(nil, ::T.untyped)
+  NO_TIME_ELAPSED_TEXT = ::T.let(nil, ::T.untyped)
+  OOB_FRIENDLY_TIME_TEXT = ::T.let(nil, ::T.untyped)
+  OOB_LIMIT_IN_HOURS = ::T.let(nil, ::T.untyped)
+  OOB_TIME_FORMATS = ::T.let(nil, ::T.untyped)
+  OOB_UNKNOWN_TIME_TEXT = ::T.let(nil, ::T.untyped)
+  TIME_FORMAT = ::T.let(nil, ::T.untyped)
+end
+
+class ProgressBar::Components::Time
+end
+
+class ProgressBar::Components::Title
+  def initialize(options=T.unsafe(nil)); end
+
+  def title(); end
+
+  def title=(title); end
+  DEFAULT_TITLE = ::T.let(nil, ::T.untyped)
+end
+
+class ProgressBar::Components::Title
+end
+
+module ProgressBar::Components
+end
+
+module ProgressBar::Format
+end
+
+class ProgressBar::Format::Formatter
+end
+
+class ProgressBar::Format::Formatter
+  def self.process(format_string, max_length, bar); end
+end
+
+class ProgressBar::Format::Molecule
+  def bar_molecule?(); end
+
+  def full_key(); end
+
+  def initialize(letter); end
+
+  def key(); end
+
+  def key=(key); end
+
+  def lookup_value(environment, length=T.unsafe(nil)); end
+
+  def method_name(); end
+
+  def method_name=(method_name); end
+
+  def non_bar_molecule?(); end
+  BAR_MOLECULES = ::T.let(nil, ::T.untyped)
+  MOLECULES = ::T.let(nil, ::T.untyped)
+end
+
+class ProgressBar::Format::Molecule
+end
+
+class ProgressBar::Format::String
+  def bar_molecule_placeholder_length(); end
+
+  def bar_molecules(); end
+
+  def displayable_length(); end
+
+  def molecules(); end
+
+  def non_bar_molecules(); end
+  ANSI_SGR_PATTERN = ::T.let(nil, ::T.untyped)
+  MOLECULE_PATTERN = ::T.let(nil, ::T.untyped)
+end
+
+class ProgressBar::Format::String
+end
+
+module ProgressBar::Format
+end
+
+class ProgressBar::InvalidProgressError
+end
+
+class ProgressBar::InvalidProgressError
+end
+
+class ProgressBar::Output
+  def bar(); end
+
+  def bar=(bar); end
+
+  def clear_string(); end
+
+  def initialize(options=T.unsafe(nil)); end
+
+  def length(); end
+
+  def length_calculator(); end
+
+  def length_calculator=(length_calculator); end
+
+  def log(string); end
+
+  def refresh(options=T.unsafe(nil)); end
+
+  def stream(); end
+
+  def stream=(stream); end
+
+  def throttle(); end
+
+  def throttle=(throttle); end
+
+  def with_refresh(); end
+  DEFAULT_OUTPUT_STREAM = ::T.let(nil, ::T.untyped)
+end
+
+class ProgressBar::Output
+  def self.detect(options=T.unsafe(nil)); end
+end
+
+module ProgressBar::Outputs
+end
+
+class ProgressBar::Outputs::NonTty
+  def bar_update_string(); end
+
+  def clear(); end
+
+  def default_format(); end
+
+  def eol(); end
+
+  def last_update_length(); end
+
+  def last_update_length=(last_update_length); end
+
+  def refresh_with_format_change(*_); end
+
+  def resolve_format(*_); end
+  DEFAULT_FORMAT_STRING = ::T.let(nil, ::T.untyped)
+end
+
+class ProgressBar::Outputs::NonTty
+end
+
+class ProgressBar::Outputs::Tty
+  def bar_update_string(); end
+
+  def clear(); end
+
+  def default_format(); end
+
+  def eol(); end
+
+  def refresh_with_format_change(); end
+
+  def resolve_format(other_format); end
+  DEFAULT_FORMAT_STRING = ::T.let(nil, ::T.untyped)
+end
+
+class ProgressBar::Outputs::Tty
+end
+
+module ProgressBar::Outputs
+end
+
+class ProgressBar::Progress
+  def absolute(); end
+
+  def decrement(); end
+
+  def finish(); end
+
+  def finished?(); end
+
+  def increment(); end
+
+  def initialize(options=T.unsafe(nil)); end
+
+  def none?(); end
+
+  def percentage_completed(); end
+
+  def percentage_completed_with_precision(); end
+
+  def progress(); end
+
+  def progress=(new_progress); end
+
+  def reset(); end
+
+  def running_average(); end
+
+  def running_average=(running_average); end
+
+  def smoothing(); end
+
+  def smoothing=(smoothing); end
+
+  def start(options=T.unsafe(nil)); end
+
+  def starting_position(); end
+
+  def starting_position=(starting_position); end
+
+  def total(); end
+
+  def total=(new_total); end
+
+  def total_with_unknown_indicator(); end
+
+  def unknown?(); end
+  DEFAULT_BEGINNING_POSITION = ::T.let(nil, ::T.untyped)
+  DEFAULT_SMOOTHING = ::T.let(nil, ::T.untyped)
+  DEFAULT_TOTAL = ::T.let(nil, ::T.untyped)
+end
+
+class ProgressBar::Progress
+end
+
+module ProgressBar::Refinements
+end
+
+module ProgressBar::Refinements::Enumerator
+end
+
+module ProgressBar::Refinements::Enumerator
+end
+
+module ProgressBar::Refinements
+end
+
+class ProgressBar::Throttle
+  def choke(options=T.unsafe(nil)); end
+
+  def initialize(options=T.unsafe(nil)); end
+
+  def rate(); end
+
+  def rate=(rate); end
+
+  def started_at(); end
+
+  def started_at=(started_at); end
+
+  def stopped_at(); end
+
+  def stopped_at=(stopped_at); end
+
+  def timer(); end
+
+  def timer=(timer); end
+end
+
+class ProgressBar::Throttle
+end
+
+class ProgressBar::Time
+  def initialize(time=T.unsafe(nil)); end
+
+  def now(); end
+
+  def time(); end
+
+  def time=(time); end
+
+  def unmocked_time_method(); end
+  TIME_MOCKING_LIBRARY_METHODS = ::T.let(nil, ::T.untyped)
+end
+
+class ProgressBar::Time
+end
+
+class ProgressBar::Timer
+  def divide_seconds(seconds); end
+
+  def elapsed_seconds(); end
+
+  def elapsed_whole_seconds(); end
+
+  def initialize(options=T.unsafe(nil)); end
+
+  def pause(); end
+
+  def reset(); end
+
+  def reset?(); end
+
+  def restart(); end
+
+  def resume(); end
+
+  def start(); end
+
+  def started?(); end
+
+  def started_at(); end
+
+  def started_at=(started_at); end
+
+  def stop(); end
+
+  def stopped?(); end
+
+  def stopped_at(); end
+
+  def stopped_at=(stopped_at); end
+
+  def time(); end
+
+  def time=(time); end
+end
+
+class ProgressBar::Timer
+end
+
+class ProgressBar
+  def self.create(*args); end
+end
+
+module Psych
+  LIBYAML_VERSION = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class Psych::BadAlias
+end
+
+class Psych::BadAlias
+end
+
+class Psych::ClassLoader
+  def big_decimal(); end
+
+  def complex(); end
+
+  def date(); end
+
+  def date_time(); end
+
+  def exception(); end
+
+  def load(klassname); end
+
+  def object(); end
+
+  def psych_omap(); end
+
+  def psych_set(); end
+
+  def range(); end
+
+  def rational(); end
+
+  def regexp(); end
+
+  def struct(); end
+
+  def symbol(); end
+
+  def symbolize(sym); end
+  BIG_DECIMAL = ::T.let(nil, ::T.untyped)
+  CACHE = ::T.let(nil, ::T.untyped)
+  COMPLEX = ::T.let(nil, ::T.untyped)
+  DATE = ::T.let(nil, ::T.untyped)
+  DATE_TIME = ::T.let(nil, ::T.untyped)
+  EXCEPTION = ::T.let(nil, ::T.untyped)
+  OBJECT = ::T.let(nil, ::T.untyped)
+  PSYCH_OMAP = ::T.let(nil, ::T.untyped)
+  PSYCH_SET = ::T.let(nil, ::T.untyped)
+  RANGE = ::T.let(nil, ::T.untyped)
+  RATIONAL = ::T.let(nil, ::T.untyped)
+  REGEXP = ::T.let(nil, ::T.untyped)
+  STRUCT = ::T.let(nil, ::T.untyped)
+  SYMBOL = ::T.let(nil, ::T.untyped)
+end
+
+class Psych::ClassLoader::Restricted
+  def initialize(classes, symbols); end
+end
+
+class Psych::ClassLoader::Restricted
+end
+
+class Psych::ClassLoader
+end
+
+class Psych::Coder
+  def [](k); end
+
+  def []=(k, v); end
+
+  def add(k, v); end
+
+  def implicit(); end
+
+  def implicit=(implicit); end
+
+  def initialize(tag); end
+
+  def map(tag=T.unsafe(nil), style=T.unsafe(nil)); end
+
+  def map=(map); end
+
+  def object(); end
+
+  def object=(object); end
+
+  def represent_map(tag, map); end
+
+  def represent_object(tag, obj); end
+
+  def represent_scalar(tag, value); end
+
+  def represent_seq(tag, list); end
+
+  def scalar(*args); end
+
+  def scalar=(value); end
+
+  def seq(); end
+
+  def seq=(list); end
+
+  def style(); end
+
+  def style=(style); end
+
+  def tag(); end
+
+  def tag=(tag); end
+
+  def type(); end
+end
+
+class Psych::Coder
+end
+
+class Psych::DisallowedClass
+  def initialize(klass_name); end
+end
+
+class Psych::DisallowedClass
+end
+
+class Psych::Emitter
+  def alias(_); end
+
+  def canonical(); end
+
+  def canonical=(canonical); end
+
+  def end_document(_); end
+
+  def indentation(); end
+
+  def indentation=(indentation); end
+
+  def initialize(*_); end
+
+  def line_width(); end
+
+  def line_width=(line_width); end
+
+  def scalar(_, _1, _2, _3, _4, _5); end
+
+  def start_document(_, _1, _2); end
+
+  def start_mapping(_, _1, _2, _3); end
+
+  def start_sequence(_, _1, _2, _3); end
+
+  def start_stream(_); end
+end
+
+class Psych::Emitter
+end
+
+class Psych::Exception
+end
+
+class Psych::Exception
+end
+
+class Psych::Handler
+  def alias(anchor); end
+
+  def empty(); end
+
+  def end_document(implicit); end
+
+  def end_mapping(); end
+
+  def end_sequence(); end
+
+  def end_stream(); end
+
+  def event_location(start_line, start_column, end_line, end_column); end
+
+  def scalar(value, anchor, tag, plain, quoted, style); end
+
+  def start_document(version, tag_directives, implicit); end
+
+  def start_mapping(anchor, tag, implicit, style); end
+
+  def start_sequence(anchor, tag, implicit, style); end
+
+  def start_stream(encoding); end
+
+  def streaming?(); end
+  EVENTS = ::T.let(nil, ::T.untyped)
+  OPTIONS = ::T.let(nil, ::T.untyped)
+end
+
+class Psych::Handler::DumperOptions
+  def canonical(); end
+
+  def canonical=(canonical); end
+
+  def indentation(); end
+
+  def indentation=(indentation); end
+
+  def line_width(); end
+
+  def line_width=(line_width); end
+end
+
+class Psych::Handler::DumperOptions
+end
+
+class Psych::Handler
+end
+
+module Psych::Handlers
+end
+
+class Psych::Handlers::DocumentStream
+  def initialize(&block); end
+end
+
+class Psych::Handlers::DocumentStream
+end
+
+module Psych::Handlers
+end
+
+module Psych::JSON
+end
+
+module Psych::JSON::RubyEvents
+  def visit_DateTime(o); end
+
+  def visit_String(o); end
+
+  def visit_Symbol(o); end
+
+  def visit_Time(o); end
+end
+
+module Psych::JSON::RubyEvents
+end
+
+class Psych::JSON::Stream
+  include ::Psych::Streaming
+end
+
+class Psych::JSON::Stream::Emitter
+  include ::Psych::JSON::YAMLEvents
+end
+
+class Psych::JSON::Stream::Emitter
+end
+
+class Psych::JSON::Stream
+  extend ::Psych::Streaming::ClassMethods
+end
+
+class Psych::JSON::TreeBuilder
+  include ::Psych::JSON::YAMLEvents
+end
+
+class Psych::JSON::TreeBuilder
+end
+
+module Psych::JSON::YAMLEvents
+  def end_document(implicit_end=T.unsafe(nil)); end
+
+  def scalar(value, anchor, tag, plain, quoted, style); end
+
+  def start_document(version, tag_directives, implicit); end
+
+  def start_mapping(anchor, tag, implicit, style); end
+
+  def start_sequence(anchor, tag, implicit, style); end
+end
+
+module Psych::JSON::YAMLEvents
+end
+
+module Psych::JSON
+end
+
+module Psych::Nodes
+end
+
+class Psych::Nodes::Alias
+  def anchor(); end
+
+  def anchor=(anchor); end
+
+  def initialize(anchor); end
+end
+
+class Psych::Nodes::Alias
+end
+
+class Psych::Nodes::Document
+  def implicit(); end
+
+  def implicit=(implicit); end
+
+  def implicit_end(); end
+
+  def implicit_end=(implicit_end); end
+
+  def initialize(version=T.unsafe(nil), tag_directives=T.unsafe(nil), implicit=T.unsafe(nil)); end
+
+  def root(); end
+
+  def tag_directives(); end
+
+  def tag_directives=(tag_directives); end
+
+  def version(); end
+
+  def version=(version); end
+end
+
+class Psych::Nodes::Document
+end
+
+class Psych::Nodes::Mapping
+  def anchor(); end
+
+  def anchor=(anchor); end
+
+  def implicit(); end
+
+  def implicit=(implicit); end
+
+  def initialize(anchor=T.unsafe(nil), tag=T.unsafe(nil), implicit=T.unsafe(nil), style=T.unsafe(nil)); end
+
+  def style(); end
+
+  def style=(style); end
+
+  def tag=(tag); end
+  ANY = ::T.let(nil, ::T.untyped)
+  BLOCK = ::T.let(nil, ::T.untyped)
+  FLOW = ::T.let(nil, ::T.untyped)
+end
+
+class Psych::Nodes::Mapping
+end
+
+class Psych::Nodes::Node
+  include ::Enumerable
+  def alias?(); end
+
+  def children(); end
+
+  def document?(); end
+
+  def each(&block); end
+
+  def end_column(); end
+
+  def end_column=(end_column); end
+
+  def end_line(); end
+
+  def end_line=(end_line); end
+
+  def mapping?(); end
+
+  def scalar?(); end
+
+  def sequence?(); end
+
+  def start_column(); end
+
+  def start_column=(start_column); end
+
+  def start_line(); end
+
+  def start_line=(start_line); end
+
+  def stream?(); end
+
+  def tag(); end
+
+  def to_ruby(); end
+
+  def to_yaml(io=T.unsafe(nil), options=T.unsafe(nil)); end
+
+  def transform(); end
+
+  def yaml(io=T.unsafe(nil), options=T.unsafe(nil)); end
+end
+
+class Psych::Nodes::Node
+end
+
+class Psych::Nodes::Scalar
+  def anchor(); end
+
+  def anchor=(anchor); end
+
+  def initialize(value, anchor=T.unsafe(nil), tag=T.unsafe(nil), plain=T.unsafe(nil), quoted=T.unsafe(nil), style=T.unsafe(nil)); end
+
+  def plain(); end
+
+  def plain=(plain); end
+
+  def quoted(); end
+
+  def quoted=(quoted); end
+
+  def style(); end
+
+  def style=(style); end
+
+  def tag=(tag); end
+
+  def value(); end
+
+  def value=(value); end
+  ANY = ::T.let(nil, ::T.untyped)
+  DOUBLE_QUOTED = ::T.let(nil, ::T.untyped)
+  FOLDED = ::T.let(nil, ::T.untyped)
+  LITERAL = ::T.let(nil, ::T.untyped)
+  PLAIN = ::T.let(nil, ::T.untyped)
+  SINGLE_QUOTED = ::T.let(nil, ::T.untyped)
+end
+
+class Psych::Nodes::Scalar
+end
+
+class Psych::Nodes::Sequence
+  def anchor(); end
+
+  def anchor=(anchor); end
+
+  def implicit(); end
+
+  def implicit=(implicit); end
+
+  def initialize(anchor=T.unsafe(nil), tag=T.unsafe(nil), implicit=T.unsafe(nil), style=T.unsafe(nil)); end
+
+  def style(); end
+
+  def style=(style); end
+
+  def tag=(tag); end
+  ANY = ::T.let(nil, ::T.untyped)
+  BLOCK = ::T.let(nil, ::T.untyped)
+  FLOW = ::T.let(nil, ::T.untyped)
+end
+
+class Psych::Nodes::Sequence
+end
+
+class Psych::Nodes::Stream
+  def encoding(); end
+
+  def encoding=(encoding); end
+
+  def initialize(encoding=T.unsafe(nil)); end
+  ANY = ::T.let(nil, ::T.untyped)
+  UTF16BE = ::T.let(nil, ::T.untyped)
+  UTF16LE = ::T.let(nil, ::T.untyped)
+  UTF8 = ::T.let(nil, ::T.untyped)
+end
+
+class Psych::Nodes::Stream
+end
+
+module Psych::Nodes
+end
+
+class Psych::Omap
+end
+
+class Psych::Omap
+end
+
+class Psych::Parser
+  def external_encoding=(external_encoding); end
+
+  def handler(); end
+
+  def handler=(handler); end
+
+  def initialize(handler=T.unsafe(nil)); end
+
+  def mark(); end
+
+  def parse(*_); end
+  ANY = ::T.let(nil, ::T.untyped)
+  UTF16BE = ::T.let(nil, ::T.untyped)
+  UTF16LE = ::T.let(nil, ::T.untyped)
+  UTF8 = ::T.let(nil, ::T.untyped)
+end
+
+class Psych::Parser::Mark
+end
+
+class Psych::Parser::Mark
+end
+
+class Psych::Parser
+end
+
+class Psych::ScalarScanner
+  def class_loader(); end
+
+  def initialize(class_loader); end
+
+  def parse_int(string); end
+
+  def parse_time(string); end
+
+  def tokenize(string); end
+  FLOAT = ::T.let(nil, ::T.untyped)
+  INTEGER = ::T.let(nil, ::T.untyped)
+  TIME = ::T.let(nil, ::T.untyped)
+end
+
+class Psych::ScalarScanner
+end
+
+class Psych::Set
+end
+
+class Psych::Set
+end
+
+class Psych::Stream
+  include ::Psych::Streaming
+end
+
+class Psych::Stream::Emitter
+  def end_document(implicit_end=T.unsafe(nil)); end
+end
+
+class Psych::Stream::Emitter
+end
+
+class Psych::Stream
+  extend ::Psych::Streaming::ClassMethods
+end
+
+module Psych::Streaming
+  def start(encoding=T.unsafe(nil)); end
+end
+
+module Psych::Streaming::ClassMethods
+  def new(io); end
+end
+
+module Psych::Streaming::ClassMethods
+end
+
+module Psych::Streaming
+end
+
+class Psych::SyntaxError
+  def column(); end
+
+  def context(); end
+
+  def file(); end
+
+  def initialize(file, line, col, offset, problem, context); end
+
+  def line(); end
+
+  def offset(); end
+
+  def problem(); end
+end
+
+class Psych::SyntaxError
+end
+
+class Psych::TreeBuilder
+  def end_document(implicit_end=T.unsafe(nil)); end
+
+  def root(); end
+end
+
+class Psych::TreeBuilder
+end
+
+module Psych::Visitors
+end
+
+class Psych::Visitors::DepthFirst
+  def initialize(block); end
+end
+
+class Psych::Visitors::DepthFirst
+end
+
+class Psych::Visitors::Emitter
+  def initialize(io, options=T.unsafe(nil)); end
+
+  def visit_Psych_Nodes_Alias(o); end
+
+  def visit_Psych_Nodes_Document(o); end
+
+  def visit_Psych_Nodes_Mapping(o); end
+
+  def visit_Psych_Nodes_Scalar(o); end
+
+  def visit_Psych_Nodes_Sequence(o); end
+
+  def visit_Psych_Nodes_Stream(o); end
+end
+
+class Psych::Visitors::Emitter
+end
+
+class Psych::Visitors::JSONTree
+  include ::Psych::JSON::RubyEvents
+end
+
+class Psych::Visitors::JSONTree
+  def self.create(options=T.unsafe(nil)); end
+end
+
+class Psych::Visitors::NoAliasRuby
+end
+
+class Psych::Visitors::NoAliasRuby
+end
+
+class Psych::Visitors::ToRuby
+  def class_loader(); end
+
+  def initialize(ss, class_loader); end
+
+  def visit_Psych_Nodes_Alias(o); end
+
+  def visit_Psych_Nodes_Document(o); end
+
+  def visit_Psych_Nodes_Mapping(o); end
+
+  def visit_Psych_Nodes_Scalar(o); end
+
+  def visit_Psych_Nodes_Sequence(o); end
+
+  def visit_Psych_Nodes_Stream(o); end
+  SHOVEL = ::T.let(nil, ::T.untyped)
+end
+
+class Psych::Visitors::ToRuby
+  def self.create(); end
+end
+
+class Psych::Visitors::Visitor
+  def accept(target); end
+  DISPATCH = ::T.let(nil, ::T.untyped)
+end
+
+class Psych::Visitors::Visitor
+end
+
+class Psych::Visitors::YAMLTree
+  def <<(object); end
+
+  def finish(); end
+
+  def finished(); end
+
+  def finished?(); end
+
+  def initialize(emitter, ss, options); end
+
+  def push(object); end
+
+  def start(encoding=T.unsafe(nil)); end
+
+  def started(); end
+
+  def started?(); end
+
+  def tree(); end
+
+  def visit_Array(o); end
+
+  def visit_BasicObject(o); end
+
+  def visit_BigDecimal(o); end
+
+  def visit_Class(o); end
+
+  def visit_Complex(o); end
+
+  def visit_Date(o); end
+
+  def visit_DateTime(o); end
+
+  def visit_Delegator(o); end
+
+  def visit_Encoding(o); end
+
+  def visit_Enumerator(o); end
+
+  def visit_Exception(o); end
+
+  def visit_FalseClass(o); end
+
+  def visit_Float(o); end
+
+  def visit_Hash(o); end
+
+  def visit_Integer(o); end
+
+  def visit_Module(o); end
+
+  def visit_NameError(o); end
+
+  def visit_NilClass(o); end
+
+  def visit_Object(o); end
+
+  def visit_Psych_Omap(o); end
+
+  def visit_Psych_Set(o); end
+
+  def visit_Range(o); end
+
+  def visit_Rational(o); end
+
+  def visit_Regexp(o); end
+
+  def visit_String(o); end
+
+  def visit_Struct(o); end
+
+  def visit_Symbol(o); end
+
+  def visit_Time(o); end
+
+  def visit_TrueClass(o); end
+end
+
+class Psych::Visitors::YAMLTree
+  def self.create(options=T.unsafe(nil), emitter=T.unsafe(nil)); end
+end
+
+module Psych::Visitors
+end
+
+module Psych
+  def self.add_builtin_type(type_tag, &block); end
+
+  def self.add_domain_type(domain, type_tag, &block); end
+
+  def self.add_tag(tag, klass); end
+
+  def self.domain_types(); end
+
+  def self.domain_types=(domain_types); end
+
+  def self.dump(o, io=T.unsafe(nil), options=T.unsafe(nil)); end
+
+  def self.dump_stream(*objects); end
+
+  def self.dump_tags(); end
+
+  def self.dump_tags=(dump_tags); end
+
+  def self.libyaml_version(); end
+
+  def self.load(yaml, legacy_filename=T.unsafe(nil), filename: T.unsafe(nil), fallback: T.unsafe(nil), symbolize_names: T.unsafe(nil)); end
+
+  def self.load_file(filename, fallback: T.unsafe(nil)); end
+
+  def self.load_stream(yaml, legacy_filename=T.unsafe(nil), filename: T.unsafe(nil), fallback: T.unsafe(nil)); end
+
+  def self.load_tags(); end
+
+  def self.load_tags=(load_tags); end
+
+  def self.parse(yaml, legacy_filename=T.unsafe(nil), filename: T.unsafe(nil), fallback: T.unsafe(nil)); end
+
+  def self.parse_file(filename, fallback: T.unsafe(nil)); end
+
+  def self.parse_stream(yaml, legacy_filename=T.unsafe(nil), filename: T.unsafe(nil), &block); end
+
+  def self.parser(); end
+
+  def self.remove_type(type_tag); end
+
+  def self.safe_load(yaml, legacy_permitted_classes=T.unsafe(nil), legacy_permitted_symbols=T.unsafe(nil), legacy_aliases=T.unsafe(nil), legacy_filename=T.unsafe(nil), permitted_classes: T.unsafe(nil), permitted_symbols: T.unsafe(nil), aliases: T.unsafe(nil), filename: T.unsafe(nil), fallback: T.unsafe(nil), symbolize_names: T.unsafe(nil)); end
+
+  def self.to_json(object); end
+end
+
+module REXML
+  COPYRIGHT = ::T.let(nil, ::T.untyped)
+  Copyright = ::T.let(nil, ::T.untyped)
+  DATE = ::T.let(nil, ::T.untyped)
+  REVISION = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+  Version = ::T.let(nil, ::T.untyped)
+end
+
+class REXML::AttlistDecl
+  include ::Enumerable
+  def [](key); end
+
+  def each(&block); end
+
+  def element_name(); end
+
+  def include?(key); end
+
+  def initialize(source); end
+
+  def node_type(); end
+
+  def write(out, indent=T.unsafe(nil)); end
+end
+
+class REXML::AttlistDecl
+end
+
+class REXML::Attribute
+  include ::REXML::Node
+  include ::REXML::Namespace
+  include ::REXML::XMLTokens
+  def ==(other); end
+
+  def clone(); end
+
+  def doctype(); end
+
+  def element(); end
+
+  def element=(element); end
+
+  def initialize(first, second=T.unsafe(nil), parent=T.unsafe(nil)); end
+
+  def namespace(arg=T.unsafe(nil)); end
+
+  def node_type(); end
+
+  def normalized=(normalized); end
+
+  def remove(); end
+
+  def to_s(); end
+
+  def to_string(); end
+
+  def value(); end
+
+  def write(output, indent=T.unsafe(nil)); end
+
+  def xpath(); end
+  NEEDS_A_SECOND_CHECK = ::T.let(nil, ::T.untyped)
+  PATTERN = ::T.let(nil, ::T.untyped)
+end
+
+class REXML::Attribute
+end
+
+class REXML::Attributes
+  def <<(attribute); end
+
+  def [](name); end
+
+  def []=(name, value); end
+
+  def add(attribute); end
+
+  def delete(attribute); end
+
+  def delete_all(name); end
+
+  def each_attribute(); end
+
+  def get_attribute(name); end
+
+  def get_attribute_ns(namespace, name); end
+
+  def initialize(element); end
+
+  def namespaces(); end
+
+  def prefixes(); end
+end
+
+class REXML::Attributes
+end
+
+class REXML::CData
+  def initialize(first, whitespace=T.unsafe(nil), parent=T.unsafe(nil)); end
+
+  def write(output=T.unsafe(nil), indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
+  ILLEGAL = ::T.let(nil, ::T.untyped)
+  START = ::T.let(nil, ::T.untyped)
+  STOP = ::T.let(nil, ::T.untyped)
+end
+
+class REXML::CData
+end
+
+class REXML::Child
+  include ::REXML::Node
+  def bytes(); end
+
+  def document(); end
+
+  def initialize(parent=T.unsafe(nil)); end
+
+  def next_sibling(); end
+
+  def next_sibling=(other); end
+
+  def parent(); end
+
+  def parent=(other); end
+
+  def previous_sibling(); end
+
+  def previous_sibling=(other); end
+
+  def remove(); end
+
+  def replace_with(child); end
+end
+
+class REXML::Child
+end
+
+class REXML::Comment
+  include ::Comparable
+  def ==(other); end
+
+  def clone(); end
+
+  def initialize(first, second=T.unsafe(nil)); end
+
+  def node_type(); end
+
+  def string(); end
+
+  def string=(string); end
+
+  def to_s(); end
+
+  def write(output, indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
+  START = ::T.let(nil, ::T.untyped)
+  STOP = ::T.let(nil, ::T.untyped)
+end
+
+class REXML::Comment
+end
+
+class REXML::Declaration
+  def initialize(src); end
+
+  def to_s(); end
+
+  def write(output, indent); end
+end
+
+class REXML::Declaration
+end
+
+class REXML::DocType
+  include ::REXML::XMLTokens
+  def add(child); end
+
+  def attribute_of(element, attribute); end
+
+  def attributes_of(element); end
+
+  def clone(); end
+
+  def context(); end
+
+  def entities(); end
+
+  def entity(name); end
+
+  def external_id(); end
+
+  def initialize(first, parent=T.unsafe(nil)); end
+
+  def name(); end
+
+  def namespaces(); end
+
+  def node_type(); end
+
+  def notation(name); end
+
+  def notations(); end
+
+  def public(); end
+
+  def system(); end
+
+  def write(output, indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
+  DEFAULT_ENTITIES = ::T.let(nil, ::T.untyped)
+  PUBLIC = ::T.let(nil, ::T.untyped)
+  START = ::T.let(nil, ::T.untyped)
+  STOP = ::T.let(nil, ::T.untyped)
+  SYSTEM = ::T.let(nil, ::T.untyped)
+end
+
+class REXML::DocType
+end
+
+class REXML::Document
+  def <<(child); end
+
+  def add(child); end
+
+  def add_element(arg=T.unsafe(nil), arg2=T.unsafe(nil)); end
+
+  def doctype(); end
+
+  def encoding(); end
+
+  def entity_expansion_count(); end
+
+  def initialize(source=T.unsafe(nil), context=T.unsafe(nil)); end
+
+  def record_entity_expansion(); end
+
+  def stand_alone?(); end
+
+  def version(); end
+
+  def write(*arguments); end
+
+  def xml_decl(); end
+  DECLARATION = ::T.let(nil, ::T.untyped)
+end
+
+class REXML::Document
+  def self.entity_expansion_limit(); end
+
+  def self.entity_expansion_limit=(val); end
+
+  def self.entity_expansion_text_limit(); end
+
+  def self.entity_expansion_text_limit=(val); end
+
+  def self.parse_stream(source, listener); end
+end
+
+class REXML::Element
+  include ::REXML::Namespace
+  include ::REXML::XMLTokens
+  def [](name_or_index); end
+
+  def add_attribute(key, value=T.unsafe(nil)); end
+
+  def add_attributes(hash); end
+
+  def add_element(element, attrs=T.unsafe(nil)); end
+
+  def add_namespace(prefix, uri=T.unsafe(nil)); end
+
+  def add_text(text); end
+
+  def attribute(name, namespace=T.unsafe(nil)); end
+
+  def attributes(); end
+
+  def cdatas(); end
+
+  def clone(); end
+
+  def comments(); end
+
+  def context(); end
+
+  def context=(context); end
+
+  def delete_attribute(key); end
+
+  def delete_element(element); end
+
+  def delete_namespace(namespace=T.unsafe(nil)); end
+
+  def each_element(xpath=T.unsafe(nil), &block); end
+
+  def each_element_with_attribute(key, value=T.unsafe(nil), max=T.unsafe(nil), name=T.unsafe(nil), &block); end
+
+  def each_element_with_text(text=T.unsafe(nil), max=T.unsafe(nil), name=T.unsafe(nil), &block); end
+
+  def elements(); end
+
+  def get_elements(xpath); end
+
+  def get_text(path=T.unsafe(nil)); end
+
+  def has_attributes?(); end
+
+  def has_elements?(); end
+
+  def has_text?(); end
+
+  def ignore_whitespace_nodes(); end
+
+  def initialize(arg=T.unsafe(nil), parent=T.unsafe(nil), context=T.unsafe(nil)); end
+
+  def instructions(); end
+
+  def namespace(prefix=T.unsafe(nil)); end
+
+  def namespaces(); end
+
+  def next_element(); end
+
+  def node_type(); end
+
+  def prefixes(); end
+
+  def previous_element(); end
+
+  def raw(); end
+
+  def root(); end
+
+  def root_node(); end
+
+  def text(path=T.unsafe(nil)); end
+
+  def text=(text); end
+
+  def texts(); end
+
+  def whitespace(); end
+
+  def write(output=T.unsafe(nil), indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
+
+  def xpath(); end
+  UNDEFINED = ::T.let(nil, ::T.untyped)
+end
+
+class REXML::Element
+end
+
+class REXML::ElementDecl
+end
+
+class REXML::ElementDecl
+end
+
+class REXML::Elements
+  include ::Enumerable
+  def <<(element=T.unsafe(nil)); end
+
+  def [](index, name=T.unsafe(nil)); end
+
+  def []=(index, element); end
+
+  def add(element=T.unsafe(nil)); end
+
+  def collect(xpath=T.unsafe(nil)); end
+
+  def delete(element); end
+
+  def delete_all(xpath); end
+
+  def each(xpath=T.unsafe(nil), &blk); end
+
+  def empty?(); end
+
+  def index(element); end
+
+  def initialize(parent); end
+
+  def inject(xpath=T.unsafe(nil), initial=T.unsafe(nil)); end
+
+  def size(); end
+
+  def to_a(xpath=T.unsafe(nil)); end
+end
+
+class REXML::Elements
+end
+
+module REXML::Encoding
+  def decode(string); end
+
+  def encode(string); end
+
+  def encoding(); end
+
+  def encoding=(encoding); end
+end
+
+module REXML::Encoding
+end
+
+class REXML::Entity
+  include ::REXML::XMLTokens
+  def external(); end
+
+  def initialize(stream, value=T.unsafe(nil), parent=T.unsafe(nil), reference=T.unsafe(nil)); end
+
+  def name(); end
+
+  def ndata(); end
+
+  def normalized(); end
+
+  def pubid(); end
+
+  def ref(); end
+
+  def to_s(); end
+
+  def unnormalized(); end
+
+  def value(); end
+
+  def write(out, indent=T.unsafe(nil)); end
+  ENTITYDECL = ::T.let(nil, ::T.untyped)
+  ENTITYDEF = ::T.let(nil, ::T.untyped)
+  ENTITYVALUE = ::T.let(nil, ::T.untyped)
+  EXTERNALID = ::T.let(nil, ::T.untyped)
+  GEDECL = ::T.let(nil, ::T.untyped)
+  NDATADECL = ::T.let(nil, ::T.untyped)
+  PEDECL = ::T.let(nil, ::T.untyped)
+  PEDEF = ::T.let(nil, ::T.untyped)
+  PEREFERENCE = ::T.let(nil, ::T.untyped)
+  PEREFERENCE_RE = ::T.let(nil, ::T.untyped)
+  PUBIDCHAR = ::T.let(nil, ::T.untyped)
+  PUBIDLITERAL = ::T.let(nil, ::T.untyped)
+  SYSTEMLITERAL = ::T.let(nil, ::T.untyped)
+end
+
+class REXML::Entity
+  def self.matches?(string); end
+end
+
+module REXML::EntityConst
+  AMP = ::T.let(nil, ::T.untyped)
+  APOS = ::T.let(nil, ::T.untyped)
+  GT = ::T.let(nil, ::T.untyped)
+  LT = ::T.let(nil, ::T.untyped)
+  QUOT = ::T.let(nil, ::T.untyped)
+end
+
+module REXML::EntityConst
+end
+
+class REXML::ExternalEntity
+  def initialize(src); end
+
+  def to_s(); end
+
+  def write(output, indent); end
+end
+
+class REXML::ExternalEntity
+end
+
+module REXML::Formatters
+end
+
+class REXML::Formatters::Default
+  def initialize(ie_hack=T.unsafe(nil)); end
+
+  def write(node, output); end
+
+  def write_cdata(node, output); end
+
+  def write_comment(node, output); end
+
+  def write_document(node, output); end
+
+  def write_element(node, output); end
+
+  def write_instruction(node, output); end
+
+  def write_text(node, output); end
+end
+
+class REXML::Formatters::Default
+end
+
+class REXML::Formatters::Pretty
+  def compact(); end
+
+  def compact=(compact); end
+
+  def initialize(indentation=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
+
+  def width(); end
+
+  def width=(width); end
+end
+
+class REXML::Formatters::Pretty
+end
+
+module REXML::Formatters
+end
+
+module REXML::Functions
+  INTERNAL_METHODS = ::T.let(nil, ::T.untyped)
+end
+
+module REXML::Functions
+  def self.boolean(object=T.unsafe(nil)); end
+
+  def self.ceiling(number); end
+
+  def self.compare_language(lang1, lang2); end
+
+  def self.concat(*objects); end
+
+  def self.contains(string, test); end
+
+  def self.context=(value); end
+
+  def self.count(node_set); end
+
+  def self.false(); end
+
+  def self.floor(number); end
+
+  def self.get_namespace(node_set=T.unsafe(nil)); end
+
+  def self.id(object); end
+
+  def self.lang(language); end
+
+  def self.last(); end
+
+  def self.local_name(node_set=T.unsafe(nil)); end
+
+  def self.name(node_set=T.unsafe(nil)); end
+
+  def self.namespace_context(); end
+
+  def self.namespace_context=(x); end
+
+  def self.namespace_uri(node_set=T.unsafe(nil)); end
+
+  def self.normalize_space(string=T.unsafe(nil)); end
+
+  def self.not(object); end
+
+  def self.number(object=T.unsafe(nil)); end
+
+  def self.position(); end
+
+  def self.processing_instruction(node); end
+
+  def self.round(number); end
+
+  def self.send(name, *args); end
+
+  def self.singleton_method_added(name); end
+
+  def self.starts_with(string, test); end
+
+  def self.string(object=T.unsafe(nil)); end
+
+  def self.string_length(string); end
+
+  def self.string_value(o); end
+
+  def self.substring(string, start, length=T.unsafe(nil)); end
+
+  def self.substring_after(string, test); end
+
+  def self.substring_before(string, test); end
+
+  def self.sum(nodes); end
+
+  def self.text(); end
+
+  def self.translate(string, tr1, tr2); end
+
+  def self.true(); end
+
+  def self.variables(); end
+
+  def self.variables=(x); end
+end
+
+class REXML::IOSource
+  def initialize(arg, block_size=T.unsafe(nil), encoding=T.unsafe(nil)); end
+end
+
+class REXML::IOSource
+end
+
+class REXML::Instruction
+  def ==(other); end
+
+  def clone(); end
+
+  def content(); end
+
+  def content=(content); end
+
+  def initialize(target, content=T.unsafe(nil)); end
+
+  def node_type(); end
+
+  def target(); end
+
+  def target=(target); end
+
+  def write(writer, indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
+  START = ::T.let(nil, ::T.untyped)
+  STOP = ::T.let(nil, ::T.untyped)
+end
+
+class REXML::Instruction
+end
+
+module REXML::Namespace
+  include ::REXML::XMLTokens
+  def expanded_name(); end
+
+  def fully_expanded_name(); end
+
+  def has_name?(other, ns=T.unsafe(nil)); end
+
+  def local_name(); end
+
+  def name(); end
+
+  def name=(name); end
+
+  def prefix(); end
+
+  def prefix=(prefix); end
+  NAMESPLIT = ::T.let(nil, ::T.untyped)
+end
+
+module REXML::Namespace
+end
+
+module REXML::Node
+  def each_recursive(&block); end
+
+  def find_first_recursive(&block); end
+
+  def indent(to, ind); end
+
+  def index_in_parent(); end
+
+  def next_sibling_node(); end
+
+  def parent?(); end
+
+  def previous_sibling_node(); end
+
+  def to_s(indent=T.unsafe(nil)); end
+end
+
+module REXML::Node
+end
+
+class REXML::NotationDecl
+  def initialize(name, middle, pub, sys); end
+
+  def name(); end
+
+  def public(); end
+
+  def public=(public); end
+
+  def system(); end
+
+  def system=(system); end
+
+  def to_s(); end
+
+  def write(output, indent=T.unsafe(nil)); end
+end
+
+class REXML::NotationDecl
+end
+
+class REXML::Output
+  include ::REXML::Encoding
+  def <<(content); end
+
+  def initialize(real_IO, encd=T.unsafe(nil)); end
+end
+
+class REXML::Output
+end
+
+class REXML::Parent
+  include ::Enumerable
+  def <<(object); end
+
+  def [](index); end
+
+  def []=(*args); end
+
+  def add(object); end
+
+  def children(); end
+
+  def deep_clone(); end
+
+  def delete(object); end
+
+  def delete_at(index); end
+
+  def delete_if(&block); end
+
+  def each(&block); end
+
+  def each_child(&block); end
+
+  def each_index(&block); end
+
+  def index(child); end
+
+  def insert_after(child1, child2); end
+
+  def insert_before(child1, child2); end
+
+  def length(); end
+
+  def push(object); end
+
+  def replace_child(to_replace, replacement); end
+
+  def size(); end
+
+  def to_a(); end
+
+  def unshift(object); end
+end
+
+class REXML::Parent
+end
+
+class REXML::ParseException
+  def context(); end
+
+  def continued_exception(); end
+
+  def continued_exception=(continued_exception); end
+
+  def initialize(message, source=T.unsafe(nil), parser=T.unsafe(nil), exception=T.unsafe(nil)); end
+
+  def line(); end
+
+  def parser(); end
+
+  def parser=(parser); end
+
+  def position(); end
+
+  def source(); end
+
+  def source=(source); end
+end
+
+class REXML::ParseException
+end
+
+module REXML::Parsers
+end
+
+class REXML::Parsers::BaseParser
+  def add_listener(listener); end
+
+  def empty?(); end
+
+  def entity(reference, entities); end
+
+  def has_next?(); end
+
+  def initialize(source); end
+
+  def normalize(input, entities=T.unsafe(nil), entity_filter=T.unsafe(nil)); end
+
+  def peek(depth=T.unsafe(nil)); end
+
+  def position(); end
+
+  def pull(); end
+
+  def source(); end
+
+  def stream=(source); end
+
+  def unnormalize(string, entities=T.unsafe(nil), filter=T.unsafe(nil)); end
+
+  def unshift(token); end
+  ATTDEF = ::T.let(nil, ::T.untyped)
+  ATTDEF_RE = ::T.let(nil, ::T.untyped)
+  ATTLISTDECL_PATTERN = ::T.let(nil, ::T.untyped)
+  ATTLISTDECL_START = ::T.let(nil, ::T.untyped)
+  ATTRIBUTE_PATTERN = ::T.let(nil, ::T.untyped)
+  ATTTYPE = ::T.let(nil, ::T.untyped)
+  ATTVALUE = ::T.let(nil, ::T.untyped)
+  CDATA_END = ::T.let(nil, ::T.untyped)
+  CDATA_PATTERN = ::T.let(nil, ::T.untyped)
+  CDATA_START = ::T.let(nil, ::T.untyped)
+  CLOSE_MATCH = ::T.let(nil, ::T.untyped)
+  COMBININGCHAR = ::T.let(nil, ::T.untyped)
+  COMMENT_PATTERN = ::T.let(nil, ::T.untyped)
+  COMMENT_START = ::T.let(nil, ::T.untyped)
+  DEFAULTDECL = ::T.let(nil, ::T.untyped)
+  DEFAULT_ENTITIES = ::T.let(nil, ::T.untyped)
+  DIGIT = ::T.let(nil, ::T.untyped)
+  DOCTYPE_END = ::T.let(nil, ::T.untyped)
+  DOCTYPE_PATTERN = ::T.let(nil, ::T.untyped)
+  DOCTYPE_START = ::T.let(nil, ::T.untyped)
+  ELEMENTDECL_PATTERN = ::T.let(nil, ::T.untyped)
+  ELEMENTDECL_START = ::T.let(nil, ::T.untyped)
+  ENCODING = ::T.let(nil, ::T.untyped)
+  ENTITYDECL = ::T.let(nil, ::T.untyped)
+  ENTITYDEF = ::T.let(nil, ::T.untyped)
+  ENTITYVALUE = ::T.let(nil, ::T.untyped)
+  ENTITY_START = ::T.let(nil, ::T.untyped)
+  ENUMERATEDTYPE = ::T.let(nil, ::T.untyped)
+  ENUMERATION = ::T.let(nil, ::T.untyped)
+  EREFERENCE = ::T.let(nil, ::T.untyped)
+  EXTENDER = ::T.let(nil, ::T.untyped)
+  EXTERNALID = ::T.let(nil, ::T.untyped)
+  GEDECL = ::T.let(nil, ::T.untyped)
+  IDENTITY = ::T.let(nil, ::T.untyped)
+  INSTRUCTION_PATTERN = ::T.let(nil, ::T.untyped)
+  INSTRUCTION_START = ::T.let(nil, ::T.untyped)
+  LETTER = ::T.let(nil, ::T.untyped)
+  NAME = ::T.let(nil, ::T.untyped)
+  NAMECHAR = ::T.let(nil, ::T.untyped)
+  NCNAME_STR = ::T.let(nil, ::T.untyped)
+  NDATADECL = ::T.let(nil, ::T.untyped)
+  NMTOKEN = ::T.let(nil, ::T.untyped)
+  NMTOKENS = ::T.let(nil, ::T.untyped)
+  NOTATIONDECL_START = ::T.let(nil, ::T.untyped)
+  NOTATIONTYPE = ::T.let(nil, ::T.untyped)
+  PEDECL = ::T.let(nil, ::T.untyped)
+  PEDEF = ::T.let(nil, ::T.untyped)
+  PEREFERENCE = ::T.let(nil, ::T.untyped)
+  PUBIDCHAR = ::T.let(nil, ::T.untyped)
+  PUBIDLITERAL = ::T.let(nil, ::T.untyped)
+  PUBLIC = ::T.let(nil, ::T.untyped)
+  QNAME = ::T.let(nil, ::T.untyped)
+  QNAME_STR = ::T.let(nil, ::T.untyped)
+  REFERENCE = ::T.let(nil, ::T.untyped)
+  REFERENCE_RE = ::T.let(nil, ::T.untyped)
+  STANDALONE = ::T.let(nil, ::T.untyped)
+  SYSTEM = ::T.let(nil, ::T.untyped)
+  SYSTEMENTITY = ::T.let(nil, ::T.untyped)
+  SYSTEMLITERAL = ::T.let(nil, ::T.untyped)
+  TAG_MATCH = ::T.let(nil, ::T.untyped)
+  TEXT_PATTERN = ::T.let(nil, ::T.untyped)
+  UNAME_STR = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+  XMLDECL_PATTERN = ::T.let(nil, ::T.untyped)
+  XMLDECL_START = ::T.let(nil, ::T.untyped)
+end
+
+class REXML::Parsers::BaseParser
+end
+
+class REXML::Parsers::StreamParser
+  def add_listener(listener); end
+
+  def initialize(source, listener); end
+
+  def parse(); end
+end
+
+class REXML::Parsers::StreamParser
+end
+
+class REXML::Parsers::TreeParser
+  def add_listener(listener); end
+
+  def initialize(source, build_context=T.unsafe(nil)); end
+
+  def parse(); end
+end
+
+class REXML::Parsers::TreeParser
+end
+
+class REXML::Parsers::XPathParser
+  include ::REXML::XMLTokens
+  def abbreviate(path); end
+
+  def expand(path); end
+
+  def namespaces=(namespaces); end
+
+  def parse(path); end
+
+  def predicate(path); end
+
+  def predicate_to_string(path, &block); end
+  AXIS = ::T.let(nil, ::T.untyped)
+  LITERAL = ::T.let(nil, ::T.untyped)
+  LOCAL_NAME_WILDCARD = ::T.let(nil, ::T.untyped)
+  NODE_TYPE = ::T.let(nil, ::T.untyped)
+  NT = ::T.let(nil, ::T.untyped)
+  NUMBER = ::T.let(nil, ::T.untyped)
+  PI = ::T.let(nil, ::T.untyped)
+  PREFIX_WILDCARD = ::T.let(nil, ::T.untyped)
+  QNAME = ::T.let(nil, ::T.untyped)
+  VARIABLE_REFERENCE = ::T.let(nil, ::T.untyped)
+end
+
+class REXML::Parsers::XPathParser
+end
+
+module REXML::Parsers
+end
+
+module REXML::Security
+end
+
+module REXML::Security
+  def self.entity_expansion_limit(); end
+
+  def self.entity_expansion_limit=(val); end
+
+  def self.entity_expansion_text_limit(); end
+
+  def self.entity_expansion_text_limit=(val); end
+end
+
+class REXML::Source
+  include ::REXML::Encoding
+  def buffer(); end
+
+  def consume(pattern); end
+
+  def current_line(); end
+
+  def empty?(); end
+
+  def encoding=(enc); end
+
+  def initialize(arg, encoding=T.unsafe(nil)); end
+
+  def line(); end
+
+  def match(pattern, cons=T.unsafe(nil)); end
+
+  def match_to(char, pattern); end
+
+  def match_to_consume(char, pattern); end
+
+  def position(); end
+
+  def read(); end
+
+  def scan(pattern, cons=T.unsafe(nil)); end
+end
+
+class REXML::Source
+end
+
+class REXML::SourceFactory
+end
+
+class REXML::SourceFactory
+  def self.create_from(arg); end
+end
+
+class REXML::Text
+  include ::Comparable
+  def <<(to_append); end
+
+  def clone(); end
+
+  def doctype(); end
+
+  def empty?(); end
+
+  def indent_text(string, level=T.unsafe(nil), style=T.unsafe(nil), indentfirstline=T.unsafe(nil)); end
+
+  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
+
+  def node_type(); end
+
+  def parent=(parent); end
+
+  def raw(); end
+
+  def raw=(raw); end
+
+  def to_s(); end
+
+  def value(); end
+
+  def value=(val); end
+
+  def wrap(string, width, addnewline=T.unsafe(nil)); end
+
+  def write(writer, indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
+
+  def write_with_substitution(out, input); end
+
+  def xpath(); end
+  EREFERENCE = ::T.let(nil, ::T.untyped)
+  NEEDS_A_SECOND_CHECK = ::T.let(nil, ::T.untyped)
+  NUMERICENTITY = ::T.let(nil, ::T.untyped)
+  REFERENCE = ::T.let(nil, ::T.untyped)
+  SETUTITSBUS = ::T.let(nil, ::T.untyped)
+  SLAICEPS = ::T.let(nil, ::T.untyped)
+  SPECIALS = ::T.let(nil, ::T.untyped)
+  SUBSTITUTES = ::T.let(nil, ::T.untyped)
+  VALID_CHAR = ::T.let(nil, ::T.untyped)
+  VALID_XML_CHARS = ::T.let(nil, ::T.untyped)
+end
+
+class REXML::Text
+  def self.check(string, pattern, doctype); end
+
+  def self.expand(ref, doctype, filter); end
+
+  def self.normalize(input, doctype=T.unsafe(nil), entity_filter=T.unsafe(nil)); end
+
+  def self.read_with_substitution(input, illegal=T.unsafe(nil)); end
+
+  def self.unnormalize(string, doctype=T.unsafe(nil), filter=T.unsafe(nil), illegal=T.unsafe(nil)); end
+end
+
+class REXML::UndefinedNamespaceException
+  def initialize(prefix, source, parser); end
+end
+
+class REXML::UndefinedNamespaceException
+end
+
+module REXML::Validation
+end
+
+class REXML::Validation::ValidationException
+  def initialize(msg); end
+end
+
+class REXML::Validation::ValidationException
+end
+
+module REXML::Validation
+end
+
+class REXML::XMLDecl
+  include ::REXML::Encoding
+  def ==(other); end
+
+  def clone(); end
+
+  def dowrite(); end
+
+  def encoding=(enc); end
+
+  def initialize(version=T.unsafe(nil), encoding=T.unsafe(nil), standalone=T.unsafe(nil)); end
+
+  def node_type(); end
+
+  def nowrite(); end
+
+  def old_enc=(encoding); end
+
+  def stand_alone?(); end
+
+  def standalone(); end
+
+  def standalone=(standalone); end
+
+  def version(); end
+
+  def version=(version); end
+
+  def write(writer, indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end
+
+  def writeencoding(); end
+
+  def writethis(); end
+
+  def xmldecl(version, encoding, standalone); end
+  DEFAULT_ENCODING = ::T.let(nil, ::T.untyped)
+  DEFAULT_STANDALONE = ::T.let(nil, ::T.untyped)
+  DEFAULT_VERSION = ::T.let(nil, ::T.untyped)
+  START = ::T.let(nil, ::T.untyped)
+  STOP = ::T.let(nil, ::T.untyped)
+end
+
+class REXML::XMLDecl
+  def self.default(); end
+end
+
+module REXML::XMLTokens
+  NAME = ::T.let(nil, ::T.untyped)
+  NAMECHAR = ::T.let(nil, ::T.untyped)
+  NAME_CHAR = ::T.let(nil, ::T.untyped)
+  NAME_START_CHAR = ::T.let(nil, ::T.untyped)
+  NAME_STR = ::T.let(nil, ::T.untyped)
+  NCNAME_STR = ::T.let(nil, ::T.untyped)
+  NMTOKEN = ::T.let(nil, ::T.untyped)
+  NMTOKENS = ::T.let(nil, ::T.untyped)
+  REFERENCE = ::T.let(nil, ::T.untyped)
+end
+
+module REXML::XMLTokens
+end
+
+class REXML::XPath
+  include ::REXML::Functions
+  EMPTY_HASH = ::T.let(nil, ::T.untyped)
+end
+
+class REXML::XPath
+  def self.each(element, path=T.unsafe(nil), namespaces=T.unsafe(nil), variables=T.unsafe(nil), options=T.unsafe(nil), &block); end
+
+  def self.first(element, path=T.unsafe(nil), namespaces=T.unsafe(nil), variables=T.unsafe(nil), options=T.unsafe(nil)); end
+
+  def self.match(element, path=T.unsafe(nil), namespaces=T.unsafe(nil), variables=T.unsafe(nil), options=T.unsafe(nil)); end
+end
+
+class REXML::XPathNode
+  def context(); end
+
+  def initialize(node, context=T.unsafe(nil)); end
+
+  def position(); end
+
+  def raw_node(); end
+end
+
+class REXML::XPathNode
+end
+
+class REXML::XPathParser
+  include ::REXML::XMLTokens
+  def []=(variable_name, value); end
+
+  def first(path_stack, node); end
+
+  def get_first(path, nodeset); end
+
+  def initialize(strict: T.unsafe(nil)); end
+
+  def match(path_stack, nodeset); end
+
+  def namespaces=(namespaces=T.unsafe(nil)); end
+
+  def parse(path, nodeset); end
+
+  def predicate(path, nodeset); end
+
+  def variables=(vars=T.unsafe(nil)); end
+  DEBUG = ::T.let(nil, ::T.untyped)
+  LITERAL = ::T.let(nil, ::T.untyped)
+end
+
+class REXML::XPathParser
+end
+
+module REXML
+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
+
+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_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=(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 default_color(); end
+
+  def default_path(); end
+
+  def deprecation_stream(); end
+
+  def detail_color(); end
+
+  def drb(); end
+
+  def drb_port(); end
+
+  def dry_run(); end
+
+  def error_stream(); end
+
+  def example_status_persistence_file_path(); end
+
+  def exclude_pattern(); 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 profile_examples(); end
+
+  def project_source_dirs(); end
+
+  def requires(); 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
+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_aliases(name, alias_name); end
+
+  def self.define_predicate_for(*names); 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 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 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 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
+  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::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.[](*_); 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.[](*_); 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(*_); 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::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 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 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 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 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_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_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
+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.[](*_); 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.[](*_); 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(*_); 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
+
+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.[](*_); 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.[](*_); 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.[](*_); 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.[](*_); 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.[](*_); 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.[](*_); 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.[](*_); 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 autoclose=(*args, &block); end
+
+  def autoclose?(*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 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 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 gets(*args, &block); end
+
+  def initialize(output); end
+
+  def inspect(*args, &block); end
+
+  def internal_encoding(*args, &block); end
+
+  def ioctl(*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 nread(*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 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 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 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 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
+  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.[](*_); 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_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
+
+RSpec::SharedContext = RSpec::Core::SharedContext
+
+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::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
+
+RSpec::Support::Mutex = Thread::Mutex
+
+module RSpec::Support::OS
+end
+
+module RSpec::Support::OS
+  def self.windows?(); end
+
+  def self.windows_file_path?(); 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
+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
+
+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
+  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_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
+  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
+
+module Racc
+  Racc_No_Extensions = ::T.let(nil, ::T.untyped)
+end
+
+class Racc::CparseParams
+end
+
+class Racc::CparseParams
+end
+
+class Racc::Parser
+  Racc_Main_Parsing_Routine = ::T.let(nil, ::T.untyped)
+  Racc_Runtime_Core_Id_C = ::T.let(nil, ::T.untyped)
+  Racc_Runtime_Core_Revision = ::T.let(nil, ::T.untyped)
+  Racc_Runtime_Core_Revision_C = ::T.let(nil, ::T.untyped)
+  Racc_Runtime_Core_Revision_R = ::T.let(nil, ::T.untyped)
+  Racc_Runtime_Core_Version = ::T.let(nil, ::T.untyped)
+  Racc_Runtime_Core_Version_C = ::T.let(nil, ::T.untyped)
+  Racc_Runtime_Core_Version_R = ::T.let(nil, ::T.untyped)
+  Racc_Runtime_Revision = ::T.let(nil, ::T.untyped)
+  Racc_Runtime_Type = ::T.let(nil, ::T.untyped)
+  Racc_Runtime_Version = ::T.let(nil, ::T.untyped)
+  Racc_YY_Parse_Method = ::T.let(nil, ::T.untyped)
+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, *_); 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
+  def self.method_added(name); end
+end
+
+class Rack::ForwardRequest
+  def env(); end
+
+  def initialize(url, env=T.unsafe(nil)); end
+
+  def url(); end
+end
+
+class Rack::ForwardRequest
+end
+
+module Rack::Handler
+end
+
+class Rack::Handler::CGI
+end
+
+class Rack::Handler::CGI
+  def self.run(app, **options); end
+
+  def self.send_body(body); end
+
+  def self.send_headers(status, headers); end
+
+  def self.serve(app); end
+end
+
+class Rack::Handler::WEBrick
+  def initialize(server, app); end
+end
+
+class Rack::Handler::WEBrick
+  def self.run(app, **options); end
+
+  def self.shutdown(); end
+
+  def self.valid_options(); end
+end
+
+module Rack::Handler
+  def self.default(); end
+
+  def self.get(server); end
+
+  def self.pick(server_names); end
+
+  def self.register(server, klass); end
+
+  def self.try_require(prefix, const_name); end
+end
+
+class Rack::Head
+  def call(env); end
+
+  def initialize(app); end
+end
+
+class Rack::Head
+end
+
+class Rack::Lint
+  include ::Rack::Lint::Assertion
+  def _call(env); end
+
+  def call(env=T.unsafe(nil)); end
+
+  def check_content_length(status, headers); end
+
+  def check_content_type(status, headers); end
+
+  def check_env(env); end
+
+  def check_error(error); end
+
+  def check_headers(header); end
+
+  def check_hijack(env); end
+
+  def check_hijack_response(headers, env); end
+
+  def check_input(input); end
+
+  def check_status(status); end
+
+  def close(); end
+
+  def each(&blk); end
+
+  def initialize(app); end
+
+  def verify_content_length(bytes); end
+end
+
+module Rack::Lint::Assertion
+  def assert(message); end
+end
+
+module Rack::Lint::Assertion
+end
+
+class Rack::Lint::ErrorWrapper
+  include ::Rack::Lint::Assertion
+  def close(*args); end
+
+  def flush(); end
+
+  def initialize(error); end
+
+  def puts(str); end
+
+  def write(str); end
+end
+
+class Rack::Lint::ErrorWrapper
+end
+
+class Rack::Lint::HijackWrapper
+  include ::Rack::Lint::Assertion
+  def close(*args, &block); end
+
+  def close_read(*args, &block); end
+
+  def close_write(*args, &block); end
+
+  def closed?(*args, &block); end
+
+  def flush(*args, &block); end
+
+  def initialize(io); end
+
+  def read(*args, &block); end
+
+  def read_nonblock(*args, &block); end
+
+  def write(*args, &block); end
+
+  def write_nonblock(*args, &block); end
+  REQUIRED_METHODS = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::Lint::HijackWrapper
+  extend ::Forwardable
+end
+
+class Rack::Lint::InputWrapper
+  include ::Rack::Lint::Assertion
+  def close(*args); end
+
+  def each(*args, &blk); end
+
+  def gets(*args); end
+
+  def initialize(input); end
+
+  def read(*args); end
+
+  def rewind(*args); end
+end
+
+class Rack::Lint::InputWrapper
+end
+
+class Rack::Lint::LintError
+end
+
+class Rack::Lint::LintError
+end
+
+class Rack::Lint
+end
+
+class Rack::Lock
+  def call(env); end
+
+  def initialize(app, mutex=T.unsafe(nil)); end
+end
+
+class Rack::Lock
+end
+
+class Rack::Logger
+  def call(env); end
+
+  def initialize(app, level=T.unsafe(nil)); end
+end
+
+class Rack::Logger
+end
+
+class Rack::MediaType
+  SPLIT_PATTERN = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::MediaType
+  def self.params(content_type); end
+
+  def self.type(content_type); end
+end
+
+class Rack::MethodOverride
+  def call(env); end
+
+  def initialize(app); end
+
+  def method_override(env); end
+  ALLOWED_METHODS = ::T.let(nil, ::T.untyped)
+  HTTP_METHODS = ::T.let(nil, ::T.untyped)
+  HTTP_METHOD_OVERRIDE_HEADER = ::T.let(nil, ::T.untyped)
+  METHOD_OVERRIDE_PARAM_KEY = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::MethodOverride
+end
+
+module Rack::Mime
+  MIME_TYPES = ::T.let(nil, ::T.untyped)
+end
+
+module Rack::Mime
+  def self.match?(value, matcher); end
+
+  def self.mime_type(ext, fallback=T.unsafe(nil)); end
+end
+
+class Rack::MockRequest
+  def delete(uri, opts=T.unsafe(nil)); end
+
+  def get(uri, opts=T.unsafe(nil)); end
+
+  def head(uri, opts=T.unsafe(nil)); end
+
+  def initialize(app); end
+
+  def options(uri, opts=T.unsafe(nil)); end
+
+  def patch(uri, opts=T.unsafe(nil)); end
+
+  def post(uri, opts=T.unsafe(nil)); end
+
+  def put(uri, opts=T.unsafe(nil)); end
+
+  def request(method=T.unsafe(nil), uri=T.unsafe(nil), opts=T.unsafe(nil)); end
+  DEFAULT_ENV = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::MockRequest::FatalWarner
+  def flush(); end
+
+  def puts(warning); end
+
+  def string(); end
+
+  def write(warning); end
+end
+
+class Rack::MockRequest::FatalWarner
+end
+
+class Rack::MockRequest::FatalWarning
+end
+
+class Rack::MockRequest::FatalWarning
+end
+
+class Rack::MockRequest
+  def self.env_for(uri=T.unsafe(nil), opts=T.unsafe(nil)); end
+
+  def self.parse_uri_rfc2396(uri); end
+end
+
+class Rack::MockResponse
+  def =~(other); end
+
+  def cookie(name); end
+
+  def cookies(); end
+
+  def errors(); end
+
+  def errors=(errors); end
+
+  def initialize(status, headers, body, errors=T.unsafe(nil)); end
+
+  def match(other); end
+
+  def original_headers(); end
+end
+
+class Rack::MockResponse
+  def self.[](*_); end
+end
+
+class Rack::MockSession
+  def after_request(&block); end
+
+  def clear_cookies(); end
+
+  def cookie_jar(); end
+
+  def cookie_jar=(cookie_jar); end
+
+  def default_host(); end
+
+  def initialize(app, default_host=T.unsafe(nil)); end
+
+  def last_request(); end
+
+  def last_response(); end
+
+  def request(uri, env); end
+
+  def set_cookie(cookie, uri=T.unsafe(nil)); end
+end
+
+class Rack::MockSession
+end
+
+module Rack::Multipart
+  ATTRIBUTE = ::T.let(nil, ::T.untyped)
+  ATTRIBUTE_CHAR = ::T.let(nil, ::T.untyped)
+  BROKEN_QUOTED = ::T.let(nil, ::T.untyped)
+  BROKEN_UNQUOTED = ::T.let(nil, ::T.untyped)
+  CONDISP = ::T.let(nil, ::T.untyped)
+  DISPPARM = ::T.let(nil, ::T.untyped)
+  EOL = ::T.let(nil, ::T.untyped)
+  EXTENDED_INITIAL_NAME = ::T.let(nil, ::T.untyped)
+  EXTENDED_INITIAL_PARAMETER = ::T.let(nil, ::T.untyped)
+  EXTENDED_INITIAL_VALUE = ::T.let(nil, ::T.untyped)
+  EXTENDED_OTHER_NAME = ::T.let(nil, ::T.untyped)
+  EXTENDED_OTHER_PARAMETER = ::T.let(nil, ::T.untyped)
+  EXTENDED_OTHER_VALUE = ::T.let(nil, ::T.untyped)
+  EXTENDED_PARAMETER = ::T.let(nil, ::T.untyped)
+  MULTIPART = ::T.let(nil, ::T.untyped)
+  MULTIPART_BOUNDARY = ::T.let(nil, ::T.untyped)
+  MULTIPART_CONTENT_DISPOSITION = ::T.let(nil, ::T.untyped)
+  MULTIPART_CONTENT_ID = ::T.let(nil, ::T.untyped)
+  MULTIPART_CONTENT_TYPE = ::T.let(nil, ::T.untyped)
+  REGULAR_PARAMETER = ::T.let(nil, ::T.untyped)
+  REGULAR_PARAMETER_NAME = ::T.let(nil, ::T.untyped)
+  RFC2183 = ::T.let(nil, ::T.untyped)
+  SECTION = ::T.let(nil, ::T.untyped)
+  TOKEN = ::T.let(nil, ::T.untyped)
+  VALUE = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::Multipart::Generator
+  def dump(); end
+
+  def initialize(params, first=T.unsafe(nil)); end
+end
+
+class Rack::Multipart::Generator
+end
+
+class Rack::Multipart::MultipartPartLimitError
+end
+
+class Rack::Multipart::MultipartPartLimitError
+end
+
+class Rack::Multipart::Parser
+  def initialize(boundary, tempfile, bufsize, query_parser); end
+
+  def on_read(content); end
+
+  def result(); end
+
+  def state(); end
+  BOUNDARY_REGEX = ::T.let(nil, ::T.untyped)
+  BUFSIZE = ::T.let(nil, ::T.untyped)
+  CHARSET = ::T.let(nil, ::T.untyped)
+  EMPTY = ::T.let(nil, ::T.untyped)
+  TEMPFILE_FACTORY = ::T.let(nil, ::T.untyped)
+  TEXT_PLAIN = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::Multipart::Parser::BoundedIO
+  def initialize(io, content_length); end
+
+  def read(size, outbuf=T.unsafe(nil)); end
+
+  def rewind(); end
+end
+
+class Rack::Multipart::Parser::BoundedIO
+end
+
+class Rack::Multipart::Parser::Collector
+  include ::Enumerable
+  def each(&blk); end
+
+  def initialize(tempfile); end
+
+  def on_mime_body(mime_index, content); end
+
+  def on_mime_finish(mime_index); end
+
+  def on_mime_head(mime_index, head, filename, content_type, name); end
+end
+
+class Rack::Multipart::Parser::Collector::BufferPart
+  def close(); end
+
+  def file?(); end
+end
+
+class Rack::Multipart::Parser::Collector::BufferPart
+end
+
+class Rack::Multipart::Parser::Collector::MimePart
+  def get_data(); end
+end
+
+class Rack::Multipart::Parser::Collector::MimePart
+end
+
+class Rack::Multipart::Parser::Collector::TempfilePart
+  def close(); end
+
+  def file?(); end
+end
+
+class Rack::Multipart::Parser::Collector::TempfilePart
+end
+
+class Rack::Multipart::Parser::Collector
+end
+
+class Rack::Multipart::Parser::MultipartInfo
+  def params(); end
+
+  def params=(_); end
+
+  def tmp_files(); end
+
+  def tmp_files=(_); end
+end
+
+class Rack::Multipart::Parser::MultipartInfo
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+class Rack::Multipart::Parser
+  def self.parse(io, content_length, content_type, tmpfile, bufsize, qp); end
+
+  def self.parse_boundary(content_type); end
+end
+
+class Rack::Multipart::UploadedFile
+  def content_type(); end
+
+  def content_type=(content_type); end
+
+  def initialize(filepath=T.unsafe(nil), ct=T.unsafe(nil), bin=T.unsafe(nil), path: T.unsafe(nil), content_type: T.unsafe(nil), binary: T.unsafe(nil), filename: T.unsafe(nil), io: T.unsafe(nil)); end
+
+  def local_path(); end
+
+  def method_missing(method_name, *args, &block); end
+
+  def original_filename(); end
+
+  def path(); end
+
+  def respond_to?(*args); end
+end
+
+class Rack::Multipart::UploadedFile
+end
+
+module Rack::Multipart
+  def self.build_multipart(params, first=T.unsafe(nil)); end
+
+  def self.extract_multipart(req, params=T.unsafe(nil)); end
+
+  def self.parse_multipart(env, params=T.unsafe(nil)); end
+end
+
+class Rack::NullLogger
+  def <<(msg); end
+
+  def add(severity, message=T.unsafe(nil), progname=T.unsafe(nil), &block); end
+
+  def call(env); end
+
+  def close(); end
+
+  def datetime_format(); end
+
+  def datetime_format=(datetime_format); end
+
+  def debug(progname=T.unsafe(nil), &block); end
+
+  def debug?(); end
+
+  def error(progname=T.unsafe(nil), &block); end
+
+  def error?(); end
+
+  def fatal(progname=T.unsafe(nil), &block); end
+
+  def fatal?(); end
+
+  def formatter(); end
+
+  def formatter=(formatter); end
+
+  def info(progname=T.unsafe(nil), &block); end
+
+  def info?(); end
+
+  def initialize(app); end
+
+  def level(); end
+
+  def level=(level); end
+
+  def progname(); end
+
+  def progname=(progname); end
+
+  def sev_threshold(); end
+
+  def sev_threshold=(sev_threshold); end
+
+  def unknown(progname=T.unsafe(nil), &block); end
+
+  def warn(progname=T.unsafe(nil), &block); end
+
+  def warn?(); end
+end
+
+class Rack::NullLogger
+end
+
+class Rack::QueryParser
+  def initialize(params_class, key_space_limit, param_depth_limit); end
+
+  def key_space_limit(); end
+
+  def make_params(); end
+
+  def new_depth_limit(param_depth_limit); end
+
+  def new_space_limit(key_space_limit); end
+
+  def normalize_params(params, name, v, depth); end
+
+  def param_depth_limit(); end
+
+  def parse_nested_query(qs, d=T.unsafe(nil)); end
+
+  def parse_query(qs, d=T.unsafe(nil), &unescaper); end
+  COMMON_SEP = ::T.let(nil, ::T.untyped)
+  DEFAULT_SEP = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::QueryParser::InvalidParameterError
+end
+
+class Rack::QueryParser::InvalidParameterError
+end
+
+class Rack::QueryParser::ParameterTypeError
+end
+
+class Rack::QueryParser::ParameterTypeError
+end
+
+class Rack::QueryParser::Params
+  def [](key); end
+
+  def []=(key, value); end
+
+  def initialize(limit); end
+
+  def key?(key); end
+
+  def to_h(); end
+
+  def to_params_hash(); end
+end
+
+class Rack::QueryParser::Params
+end
+
+class Rack::QueryParser
+  def self.make_default(key_space_limit, param_depth_limit); end
+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
+
+class Rack::Session::Abstract::Persisted
+  def call(env); end
+
+  def commit_session(req, res); end
+
+  def context(env, app=T.unsafe(nil)); end
+
+  def default_options(); end
+
+  def initialize(app, options=T.unsafe(nil)); end
+
+  def key(); end
+
+  def sid_secure(); end
+  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::Session::Abstract::Persisted
+end
+
+class Rack::Session::Abstract::PersistedSecure
+  def extract_session_id(*_); end
+
+  def generate_sid(*_); end
+end
+
+class Rack::Session::Abstract::PersistedSecure
+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
+
+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
+
+module Rack::Test
+  DEFAULT_HOST = ::T.let(nil, ::T.untyped)
+  MULTIPART_BOUNDARY = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::Test::Cookie
+  include ::Rack::Utils
+  def default_uri(); end
+
+  def domain(); end
+
+  def empty?(); end
+
+  def expired?(); end
+
+  def expires(); end
+
+  def http_only?(); end
+
+  def initialize(raw, uri=T.unsafe(nil), default_host=T.unsafe(nil)); end
+
+  def matches?(uri); end
+
+  def name(); end
+
+  def path(); end
+
+  def raw(); end
+
+  def replaces?(other); end
+
+  def secure?(); end
+
+  def to_h(); end
+
+  def to_hash(); end
+
+  def valid?(uri); end
+
+  def value(); end
+end
+
+class Rack::Test::Cookie
+end
+
+class Rack::Test::CookieJar
+  def <<(new_cookie); end
+
+  def [](name); end
+
+  def []=(name, value); end
+
+  def delete(name); end
+
+  def for(uri); end
+
+  def get_cookie(name); end
+
+  def hash_for(uri=T.unsafe(nil)); end
+
+  def initialize(cookies=T.unsafe(nil), default_host=T.unsafe(nil)); end
+
+  def merge(raw_cookies, uri=T.unsafe(nil)); end
+
+  def to_hash(); end
+  DELIMITER = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::Test::CookieJar
+end
+
+class Rack::Test::Error
+end
+
+class Rack::Test::Error
+end
+
+module Rack::Test::Methods
+  def _current_session_names(); end
+
+  def authorize(*args, &block); end
+
+  def basic_authorize(*args, &block); end
+
+  def build_rack_mock_session(); end
+
+  def build_rack_test_session(name); end
+
+  def clear_cookies(*args, &block); end
+
+  def current_session(); end
+
+  def custom_request(*args, &block); end
+
+  def delete(*args, &block); end
+
+  def digest_authorize(*args, &block); end
+
+  def env(*args, &block); end
+
+  def follow_redirect!(*args, &block); end
+
+  def get(*args, &block); end
+
+  def head(*args, &block); end
+
+  def header(*args, &block); end
+
+  def last_request(*args, &block); end
+
+  def last_response(*args, &block); end
+
+  def options(*args, &block); end
+
+  def patch(*args, &block); end
+
+  def post(*args, &block); end
+
+  def put(*args, &block); end
+
+  def rack_mock_session(name=T.unsafe(nil)); end
+
+  def rack_test_session(name=T.unsafe(nil)); end
+
+  def request(*args, &block); end
+
+  def set_cookie(*args, &block); end
+
+  def with_session(name); end
+  METHODS = ::T.let(nil, ::T.untyped)
+end
+
+module Rack::Test::Methods
+  extend ::Forwardable
+end
+
+class Rack::Test::MockDigestRequest
+  def initialize(params); end
+
+  def method(); end
+
+  def method_missing(sym); end
+
+  def response(password); end
+end
+
+class Rack::Test::MockDigestRequest
+end
+
+class Rack::Test::Session
+  include ::Rack::Test::Utils
+  include ::Rack::Utils
+  def authorize(username, password); end
+
+  def basic_authorize(username, password); end
+
+  def clear_cookies(*args, &block); end
+
+  def custom_request(verb, uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end
+
+  def delete(uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end
+
+  def digest_authorize(username, password); end
+
+  def env(name, value); end
+
+  def follow_redirect!(); end
+
+  def get(uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end
+
+  def head(uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end
+
+  def header(name, value); end
+
+  def initialize(mock_session); end
+
+  def last_request(*args, &block); end
+
+  def last_response(*args, &block); end
+
+  def options(uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end
+
+  def patch(uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end
+
+  def post(uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end
+
+  def put(uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end
+
+  def request(uri, env=T.unsafe(nil), &block); end
+
+  def set_cookie(*args, &block); end
+end
+
+class Rack::Test::Session
+  extend ::Forwardable
+end
+
+class Rack::Test::UploadedFile
+  def content_type(); end
+
+  def content_type=(content_type); end
+
+  def initialize(content, content_type=T.unsafe(nil), binary=T.unsafe(nil), original_filename: T.unsafe(nil)); end
+
+  def local_path(); end
+
+  def method_missing(method_name, *args, &block); end
+
+  def original_filename(); end
+
+  def path(); end
+
+  def tempfile(); end
+end
+
+class Rack::Test::UploadedFile
+  def self.actually_finalize(file); end
+
+  def self.finalize(file); end
+end
+
+module Rack::Test::Utils
+  include ::Rack::Utils
+end
+
+module Rack::Test::Utils
+  extend ::Rack::Utils
+  def self.build_file_part(parameter_name, uploaded_file); end
+
+  def self.build_multipart(params, first=T.unsafe(nil), multipart=T.unsafe(nil)); end
+
+  def self.build_parts(parameters); end
+
+  def self.build_primitive_part(parameter_name, value); end
+
+  def self.get_parts(parameters); end
+end
+
+module Rack::Test
+  def self.encoding_aware_strings?(); end
+end
+
+class Rack::Tracer
+  def call(env); end
+
+  def initialize(app, tracer: T.unsafe(nil), on_start_span: T.unsafe(nil), on_finish_span: T.unsafe(nil), trust_incoming_span: T.unsafe(nil), errors: T.unsafe(nil)); end
+  REQUEST_METHOD = ::T.let(nil, ::T.untyped)
+  REQUEST_URI = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::Tracer
+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::Utils
+  COMMON_SEP = ::T.let(nil, ::T.untyped)
+  DEFAULT_SEP = ::T.let(nil, ::T.untyped)
+  ESCAPE_HTML = ::T.let(nil, ::T.untyped)
+  ESCAPE_HTML_PATTERN = ::T.let(nil, ::T.untyped)
+  HTTP_STATUS_CODES = ::T.let(nil, ::T.untyped)
+  NULL_BYTE = ::T.let(nil, ::T.untyped)
+  PATH_SEPS = ::T.let(nil, ::T.untyped)
+  STATUS_WITH_NO_ENTITY_BODY = ::T.let(nil, ::T.untyped)
+  SYMBOL_TO_STATUS_CODE = ::T.let(nil, ::T.untyped)
+end
+
+class Rack::Utils::Context
+  def app(); end
+
+  def call(env); end
+
+  def context(env, app=T.unsafe(nil)); end
+
+  def for(); end
+
+  def initialize(app_f, app_r); end
+
+  def recontext(app); end
+end
+
+class Rack::Utils::Context
+end
+
+class Rack::Utils::HeaderHash
+  def [](k); end
+
+  def []=(k, v); end
+
+  def delete(k); end
+
+  def has_key?(k); end
+
+  def include?(k); end
+
+  def initialize(hash=T.unsafe(nil)); end
+
+  def key?(k); end
+
+  def member?(k); end
+
+  def merge(other); end
+
+  def merge!(other); end
+
+  def names(); end
+
+  def replace(other); end
+end
+
+class Rack::Utils::HeaderHash
+  def self.[](headers); end
+end
+
+Rack::Utils::InvalidParameterError = Rack::QueryParser::InvalidParameterError
+
+Rack::Utils::KeySpaceConstrainedParams = Rack::QueryParser::Params
+
+Rack::Utils::ParameterTypeError = Rack::QueryParser::ParameterTypeError
+
+module Rack::Utils
+  def self.add_cookie_to_header(header, key, value); end
+
+  def self.add_remove_cookie_to_header(header, key, value=T.unsafe(nil)); end
+
+  def self.best_q_match(q_value_header, available_mimes); end
+
+  def self.build_nested_query(value, prefix=T.unsafe(nil)); end
+
+  def self.build_query(params); end
+
+  def self.byte_ranges(env, size); end
+
+  def self.clean_path_info(path_info); end
+
+  def self.clock_time(); end
+
+  def self.default_query_parser(); end
+
+  def self.default_query_parser=(default_query_parser); end
+
+  def self.delete_cookie_header!(header, key, value=T.unsafe(nil)); end
+
+  def self.escape(s); end
+
+  def self.escape_html(string); end
+
+  def self.escape_path(s); end
+
+  def self.get_byte_ranges(http_range, size); end
+
+  def self.key_space_limit(); end
+
+  def self.key_space_limit=(v); end
+
+  def self.make_delete_cookie_header(header, key, value); end
+
+  def self.multipart_part_limit(); end
+
+  def self.multipart_part_limit=(multipart_part_limit); end
+
+  def self.param_depth_limit(); end
+
+  def self.param_depth_limit=(v); end
+
+  def self.parse_cookies(env); end
+
+  def self.parse_cookies_header(header); end
+
+  def self.parse_nested_query(qs, d=T.unsafe(nil)); end
+
+  def self.parse_query(qs, d=T.unsafe(nil), &unescaper); end
+
+  def self.q_values(q_value_header); end
+
+  def self.rfc2109(time); end
+
+  def self.rfc2822(time); end
+
+  def self.secure_compare(a, b); end
+
+  def self.select_best_encoding(available_encodings, accept_encoding); end
+
+  def self.set_cookie_header!(header, key, value); end
+
+  def self.status_code(status); end
+
+  def self.unescape(s, encoding=T.unsafe(nil)); end
+
+  def self.unescape_path(s); end
+
+  def self.valid_path?(path); end
+end
+
+module Rack
+  def self.release(); end
+
+  def self.version(); end
+end
+
+class Rainbow::Color::RGB
+  def self.to_ansi_domain(value); end
+end
+
+class Rainbow::NullPresenter
+  def method_missing(method_name, *args); end
+end
+
+class Rainbow::Presenter
+  def method_missing(method_name, *args); end
+end
+
+class Rainbow::StringUtils
+  def self.uncolor(string); end
+end
+
+module Rainbow
+  def self.new(); end
+end
+
+module Rake
+  EARLY = ::T.let(nil, ::T.untyped)
+  EMPTY_TASK_ARGS = ::T.let(nil, ::T.untyped)
+  LATE = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class Rake::Application
+  include ::Rake::TaskManager
+  include ::Rake::TraceOutput
+  def add_import(fn); end
+
+  def add_loader(ext, loader); end
+
+  def collect_command_line_tasks(args); end
+
+  def default_task_name(); end
+
+  def deprecate(old_usage, new_usage, call_site); end
+
+  def display_cause_details(ex); end
+
+  def display_error_message(ex); end
+
+  def display_exception_backtrace(ex); end
+
+  def display_exception_details(ex); end
+
+  def display_exception_details_seen(); end
+
+  def display_exception_message_details(ex); end
+
+  def display_prerequisites(); end
+
+  def display_tasks_and_comments(); end
+
+  def dynamic_width(); end
+
+  def dynamic_width_stty(); end
+
+  def dynamic_width_tput(); end
+
+  def exit_because_of_exception(ex); end
+
+  def find_rakefile_location(); end
+
+  def handle_options(argv); end
+
+  def has_cause?(ex); end
+
+  def have_rakefile(); end
+
+  def init(app_name=T.unsafe(nil), argv=T.unsafe(nil)); end
+
+  def invoke_task(task_string); end
+
+  def load_imports(); end
+
+  def load_rakefile(); end
+
+  def name(); end
+
+  def options(); end
+
+  def original_dir(); end
+
+  def parse_task_string(string); end
+
+  def print_rakefile_directory(location); end
+
+  def rake_require(file_name, paths=T.unsafe(nil), loaded=T.unsafe(nil)); end
+
+  def rakefile(); end
+
+  def rakefile_location(backtrace=T.unsafe(nil)); end
+
+  def raw_load_rakefile(); end
+
+  def run(argv=T.unsafe(nil)); end
+
+  def run_with_threads(); end
+
+  def set_default_options(); end
+
+  def standard_exception_handling(); end
+
+  def standard_rake_options(); end
+
+  def system_dir(); end
+
+  def terminal_columns(); end
+
+  def terminal_columns=(terminal_columns); end
+
+  def terminal_width(); end
+
+  def thread_pool(); end
+
+  def top_level(); end
+
+  def top_level_tasks(); end
+
+  def trace(*strings); end
+
+  def truncate(string, width); end
+
+  def truncate_output?(); end
+
+  def tty_output=(tty_output); end
+
+  def tty_output?(); end
+
+  def unix?(); end
+
+  def windows?(); end
+  DEFAULT_RAKEFILES = ::T.let(nil, ::T.untyped)
+end
+
+class Rake::Application
+end
+
+module Rake::Backtrace
+  SUPPRESSED_PATHS = ::T.let(nil, ::T.untyped)
+  SUPPRESSED_PATHS_RE = ::T.let(nil, ::T.untyped)
+  SUPPRESS_PATTERN = ::T.let(nil, ::T.untyped)
+  SYS_KEYS = ::T.let(nil, ::T.untyped)
+  SYS_PATHS = ::T.let(nil, ::T.untyped)
+end
+
+module Rake::Backtrace
+  def self.collapse(backtrace); end
+end
+
+module Rake::Cloneable
+end
+
+module Rake::Cloneable
+end
+
+class Rake::CommandLineOptionError
+end
+
+class Rake::CommandLineOptionError
+end
+
+class Rake::CpuCounter
+  def count(); end
+
+  def count_with_default(default=T.unsafe(nil)); end
+end
+
+class Rake::CpuCounter
+  def self.count(); end
+end
+
+module Rake::DSL
+  include ::Rake::FileUtilsExt
+  include ::FileUtils
+  include ::FileUtils::StreamUtils_
+end
+
+module Rake::DSL
+end
+
+class Rake::DefaultLoader
+  def load(fn); end
+end
+
+class Rake::DefaultLoader
+end
+
+class Rake::EarlyTime
+  include ::Comparable
+  include ::Singleton
+end
+
+class Rake::EarlyTime
+  extend ::Singleton::SingletonClassMethods
+  def self.instance(); end
+end
+
+class Rake::FileCreationTask
+end
+
+class Rake::FileCreationTask
+end
+
+class Rake::FileList
+  include ::Rake::Cloneable
+  def &(*args, &block); end
+
+  def *(other); end
+
+  def +(*args, &block); end
+
+  def -(*args, &block); end
+
+  def <<(obj); end
+
+  def ==(array); end
+
+  def [](*args, &block); end
+
+  def []=(*args, &block); end
+
+  def add(*filenames); end
+
+  def all?(*args, &block); end
+
+  def any?(*args, &block); end
+
+  def append(*args, &block); end
+
+  def assoc(*args, &block); end
+
+  def at(*args, &block); end
+
+  def bsearch(*args, &block); end
+
+  def bsearch_index(*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 clear_exclude(); end
+
+  def collect(*args, &block); end
+
+  def collect!(*args, &block); end
+
+  def collect_concat(*args, &block); end
+
+  def combination(*args, &block); end
+
+  def compact(*args, &block); end
+
+  def compact!(*args, &block); end
+
+  def concat(*args, &block); end
+
+  def count(*args, &block); end
+
+  def cycle(*args, &block); end
+
+  def delete(*args, &block); end
+
+  def delete_at(*args, &block); end
+
+  def delete_if(*args, &block); end
+
+  def detect(*args, &block); end
+
+  def difference(*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_index(*args, &block); end
+
+  def each_slice(*args, &block); end
+
+  def each_with_index(*args, &block); end
+
+  def each_with_object(*args, &block); end
+
+  def egrep(pattern, *options); end
+
+  def empty?(*args, &block); end
+
+  def entries(*args, &block); end
+
+  def exclude(*patterns, &block); end
+
+  def excluded_from_list?(fn); end
+
+  def existing(); end
+
+  def existing!(); end
+
+  def ext(newext=T.unsafe(nil)); end
+
+  def fetch(*args, &block); end
+
+  def fill(*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 flatten!(*args, &block); end
+
+  def grep(*args, &block); end
+
+  def grep_v(*args, &block); end
+
+  def group_by(*args, &block); end
+
+  def gsub(pat, rep); end
+
+  def gsub!(pat, rep); end
+
+  def import(array); end
+
+  def include(*filenames); end
+
+  def include?(*args, &block); end
+
+  def index(*args, &block); end
+
+  def initialize(*patterns); end
+
+  def inject(*args, &block); end
+
+  def insert(*args, &block); end
+
+  def inspect(*args, &block); end
+
+  def is_a?(klass); end
+
+  def join(*args, &block); end
+
+  def keep_if(*args, &block); end
+
+  def kind_of?(klass); end
+
+  def last(*args, &block); end
+
+  def lazy(*args, &block); end
+
+  def length(*args, &block); end
+
+  def map(*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 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 pack(*args, &block); end
+
+  def partition(&block); end
+
+  def pathmap(spec=T.unsafe(nil), &block); end
+
+  def permutation(*args, &block); end
+
+  def pop(*args, &block); end
+
+  def prepend(*args, &block); end
+
+  def product(*args, &block); end
+
+  def push(*args, &block); end
+
+  def rassoc(*args, &block); end
+
+  def reduce(*args, &block); end
+
+  def reject(*args, &block); end
+
+  def reject!(*args, &block); end
+
+  def repeated_combination(*args, &block); end
+
+  def repeated_permutation(*args, &block); end
+
+  def replace(*args, &block); end
+
+  def resolve(); end
+
+  def reverse(*args, &block); end
+
+  def reverse!(*args, &block); end
+
+  def reverse_each(*args, &block); end
+
+  def rindex(*args, &block); end
+
+  def rotate(*args, &block); end
+
+  def rotate!(*args, &block); end
+
+  def sample(*args, &block); end
+
+  def select(*args, &block); end
+
+  def select!(*args, &block); end
+
+  def shift(*args, &block); end
+
+  def shuffle(*args, &block); end
+
+  def shuffle!(*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!(*args, &block); end
+
+  def sort_by(*args, &block); end
+
+  def sort_by!(*args, &block); end
+
+  def sub(pat, rep); end
+
+  def sub!(pat, rep); end
+
+  def sum(*args, &block); end
+
+  def take(*args, &block); end
+
+  def take_while(*args, &block); end
+
+  def to_a(); end
+
+  def to_ary(); end
+
+  def to_h(*args, &block); end
+
+  def to_set(*args, &block); end
+
+  def transpose(*args, &block); end
+
+  def union(*args, &block); end
+
+  def uniq(*args, &block); end
+
+  def uniq!(*args, &block); end
+
+  def unshift(*args, &block); end
+
+  def values_at(*args, &block); end
+
+  def zip(*args, &block); end
+
+  def |(*args, &block); end
+  ARRAY_METHODS = ::T.let(nil, ::T.untyped)
+  DEFAULT_IGNORE_PATTERNS = ::T.let(nil, ::T.untyped)
+  DEFAULT_IGNORE_PROCS = ::T.let(nil, ::T.untyped)
+  DELEGATING_METHODS = ::T.let(nil, ::T.untyped)
+  GLOB_PATTERN = ::T.let(nil, ::T.untyped)
+  MUST_DEFINE = ::T.let(nil, ::T.untyped)
+  MUST_NOT_DEFINE = ::T.let(nil, ::T.untyped)
+  SPECIAL_RETURN = ::T.let(nil, ::T.untyped)
+end
+
+class Rake::FileList
+  def self.[](*args); end
+
+  def self.glob(pattern, *args); end
+end
+
+class Rake::FileTask
+end
+
+class Rake::FileTask
+end
+
+module Rake::FileUtilsExt
+  include ::FileUtils
+  include ::FileUtils::StreamUtils_
+  def cd(*args, **options, &block); end
+
+  def chdir(*args, **options, &block); end
+
+  def chmod(*args, **options, &block); end
+
+  def chmod_R(*args, **options, &block); end
+
+  def chown(*args, **options, &block); end
+
+  def chown_R(*args, **options, &block); end
+
+  def copy(*args, **options, &block); end
+
+  def cp(*args, **options, &block); end
+
+  def cp_lr(*args, **options, &block); end
+
+  def cp_r(*args, **options, &block); end
+
+  def install(*args, **options, &block); end
+
+  def link(*args, **options, &block); end
+
+  def ln(*args, **options, &block); end
+
+  def ln_s(*args, **options, &block); end
+
+  def ln_sf(*args, **options, &block); end
+
+  def makedirs(*args, **options, &block); end
+
+  def mkdir(*args, **options, &block); end
+
+  def mkdir_p(*args, **options, &block); end
+
+  def mkpath(*args, **options, &block); end
+
+  def move(*args, **options, &block); end
+
+  def mv(*args, **options, &block); end
+
+  def nowrite(value=T.unsafe(nil)); end
+
+  def rake_check_options(options, *optdecl); end
+
+  def rake_output_message(message); end
+
+  def remove(*args, **options, &block); end
+
+  def rm(*args, **options, &block); end
+
+  def rm_f(*args, **options, &block); end
+
+  def rm_r(*args, **options, &block); end
+
+  def rm_rf(*args, **options, &block); end
+
+  def rmdir(*args, **options, &block); end
+
+  def rmtree(*args, **options, &block); end
+
+  def safe_unlink(*args, **options, &block); end
+
+  def symlink(*args, **options, &block); end
+
+  def touch(*args, **options, &block); end
+
+  def verbose(value=T.unsafe(nil)); end
+
+  def when_writing(msg=T.unsafe(nil)); end
+  DEFAULT = ::T.let(nil, ::T.untyped)
+end
+
+module Rake::FileUtilsExt
+  extend ::Rake::FileUtilsExt
+  extend ::FileUtils
+  extend ::FileUtils::StreamUtils_
+  def self.nowrite_flag(); end
+
+  def self.nowrite_flag=(nowrite_flag); end
+
+  def self.verbose_flag(); end
+
+  def self.verbose_flag=(verbose_flag); end
+end
+
+class Rake::InvocationChain
+  def append(invocation); end
+
+  def member?(invocation); end
+  EMPTY = ::T.let(nil, ::T.untyped)
+end
+
+class Rake::InvocationChain::EmptyInvocationChain
+  def append(invocation); end
+
+  def member?(obj); end
+end
+
+class Rake::InvocationChain::EmptyInvocationChain
+end
+
+class Rake::InvocationChain
+  def self.append(invocation, chain); end
+end
+
+module Rake::InvocationExceptionMixin
+  def chain(); end
+
+  def chain=(value); end
+end
+
+module Rake::InvocationExceptionMixin
+end
+
+class Rake::LateTime
+  include ::Comparable
+  include ::Singleton
+end
+
+class Rake::LateTime
+  extend ::Singleton::SingletonClassMethods
+  def self.instance(); end
+end
+
+class Rake::LinkedList
+  include ::Enumerable
+  def ==(other); end
+
+  def conj(item); end
+
+  def each(&blk); end
+
+  def empty?(); end
+
+  def head(); end
+
+  def initialize(head, tail=T.unsafe(nil)); end
+
+  def tail(); end
+  EMPTY = ::T.let(nil, ::T.untyped)
+end
+
+class Rake::LinkedList::EmptyLinkedList
+  def initialize(); end
+end
+
+class Rake::LinkedList::EmptyLinkedList
+end
+
+class Rake::LinkedList
+  def self.cons(head, tail); end
+
+  def self.empty(); end
+
+  def self.make(*args); end
+end
+
+class Rake::MultiTask
+end
+
+class Rake::MultiTask
+end
+
+class Rake::NameSpace
+  def [](name); end
+
+  def initialize(task_manager, scope_list); end
+
+  def scope(); end
+
+  def tasks(); end
+end
+
+class Rake::NameSpace
+end
+
+module Rake::PrivateReader
+end
+
+module Rake::PrivateReader::ClassMethods
+  def private_reader(*names); end
+end
+
+module Rake::PrivateReader::ClassMethods
+end
+
+module Rake::PrivateReader
+  def self.included(base); end
+end
+
+class Rake::Promise
+  def initialize(args, &block); end
+
+  def recorder(); end
+
+  def recorder=(recorder); end
+
+  def value(); end
+
+  def work(); end
+  NOT_SET = ::T.let(nil, ::T.untyped)
+end
+
+class Rake::Promise
+end
+
+class Rake::PseudoStatus
+  def >>(n); end
+
+  def exited?(); end
+
+  def exitstatus(); end
+
+  def initialize(code=T.unsafe(nil)); end
+
+  def stopped?(); end
+
+  def to_i(); end
+end
+
+class Rake::PseudoStatus
+end
+
+class Rake::RuleRecursionOverflowError
+  def add_target(target); end
+
+  def initialize(*args); end
+end
+
+class Rake::RuleRecursionOverflowError
+end
+
+class Rake::Scope
+  def path(); end
+
+  def path_with_task_name(task_name); end
+
+  def trim(n); end
+  EMPTY = ::T.let(nil, ::T.untyped)
+end
+
+class Rake::Scope::EmptyScope
+  def path(); end
+
+  def path_with_task_name(task_name); end
+end
+
+class Rake::Scope::EmptyScope
+end
+
+class Rake::Scope
+end
+
+class Rake::Task
+  def actions(); end
+
+  def add_description(description); end
+
+  def all_prerequisite_tasks(); end
+
+  def already_invoked(); end
+
+  def application(); end
+
+  def application=(application); end
+
+  def arg_description(); end
+
+  def arg_names(); end
+
+  def clear(); end
+
+  def clear_actions(); end
+
+  def clear_args(); end
+
+  def clear_comments(); end
+
+  def clear_prerequisites(); end
+
+  def collect_prerequisites(seen); end
+
+  def comment(); end
+
+  def comment=(comment); end
+
+  def enhance(deps=T.unsafe(nil), &block); end
+
+  def execute(args=T.unsafe(nil)); end
+
+  def full_comment(); end
+
+  def initialize(task_name, app); end
+
+  def investigation(); end
+
+  def invoke(*args); end
+
+  def invoke_prerequisites(task_args, invocation_chain); end
+
+  def invoke_prerequisites_concurrently(task_args, invocation_chain); end
+
+  def invoke_with_call_chain(task_args, invocation_chain); end
+
+  def locations(); end
+
+  def name(); end
+
+  def name_with_args(); end
+
+  def needed?(); end
+
+  def order_only_prerequisites(); end
+
+  def prereqs(); end
+
+  def prerequisite_tasks(); end
+
+  def prerequisites(); end
+
+  def reenable(); end
+
+  def scope(); end
+
+  def set_arg_names(args); end
+
+  def source(); end
+
+  def sources(); end
+
+  def sources=(sources); end
+
+  def timestamp(); end
+
+  def |(deps); end
+end
+
+class Rake::Task
+  def self.[](task_name); end
+
+  def self.clear(); end
+
+  def self.create_rule(*args, &block); end
+
+  def self.define_task(*args, &block); end
+
+  def self.format_deps(deps); end
+
+  def self.scope_name(scope, task_name); end
+
+  def self.task_defined?(task_name); end
+
+  def self.tasks(); end
+end
+
+class Rake::TaskArgumentError
+end
+
+class Rake::TaskArgumentError
+end
+
+class Rake::TaskArguments
+  include ::Enumerable
+  def [](index); end
+
+  def each(&block); end
+
+  def extras(); end
+
+  def fetch(*args, &block); end
+
+  def has_key?(key); end
+
+  def initialize(names, values, parent=T.unsafe(nil)); end
+
+  def key?(key); end
+
+  def lookup(name); end
+
+  def method_missing(sym, *args); end
+
+  def names(); end
+
+  def new_scope(names); end
+
+  def to_a(); end
+
+  def to_hash(); end
+
+  def values_at(*keys); end
+
+  def with_defaults(defaults); end
+end
+
+class Rake::TaskArguments
+end
+
+module Rake::TaskManager
+  def [](task_name, scopes=T.unsafe(nil)); end
+
+  def clear(); end
+
+  def create_rule(*args, &block); end
+
+  def current_scope(); end
+
+  def define_task(task_class, *args, &block); end
+
+  def enhance_with_matching_rule(task_name, level=T.unsafe(nil)); end
+
+  def generate_did_you_mean_suggestions(task_name); end
+
+  def generate_message_for_undefined_task(task_name); end
+
+  def in_namespace(name); end
+
+  def initialize(); end
+
+  def intern(task_class, task_name); end
+
+  def last_description(); end
+
+  def last_description=(last_description); end
+
+  def lookup(task_name, initial_scope=T.unsafe(nil)); end
+
+  def resolve_args(args); end
+
+  def synthesize_file_task(task_name); end
+
+  def tasks(); end
+
+  def tasks_in_scope(scope); end
+end
+
+module Rake::TaskManager
+  def self.record_task_metadata(); end
+
+  def self.record_task_metadata=(record_task_metadata); end
+end
+
+class Rake::ThreadHistoryDisplay
+  include ::Rake::PrivateReader
+  def initialize(stats); end
+
+  def show(); end
+end
+
+class Rake::ThreadHistoryDisplay
+  extend ::Rake::PrivateReader::ClassMethods
+end
+
+class Rake::ThreadPool
+  def future(*args, &block); end
+
+  def gather_history(); end
+
+  def history(); end
+
+  def initialize(thread_count); end
+
+  def join(); end
+
+  def statistics(); end
+end
+
+class Rake::ThreadPool
+end
+
+module Rake::TraceOutput
+  def trace_on(out, *strings); end
+end
+
+module Rake::TraceOutput
+end
+
+module Rake::Version
+  BUILD = ::T.let(nil, ::T.untyped)
+  MAJOR = ::T.let(nil, ::T.untyped)
+  MINOR = ::T.let(nil, ::T.untyped)
+  NUMBERS = ::T.let(nil, ::T.untyped)
+  OTHER = ::T.let(nil, ::T.untyped)
+end
+
+module Rake::Version
+end
+
+module Rake::Win32
+end
+
+class Rake::Win32::Win32HomeError
+end
+
+class Rake::Win32::Win32HomeError
+end
+
+module Rake::Win32
+  def self.normalize(path); end
+
+  def self.win32_system_dir(); end
+
+  def self.windows?(); end
+end
+
+module Rake
+  extend ::Rake::FileUtilsExt
+  extend ::FileUtils
+  extend ::FileUtils::StreamUtils_
+  def self.add_rakelib(*files); end
+
+  def self.application(); end
+
+  def self.application=(app); end
+
+  def self.each_dir_parent(dir); end
+
+  def self.from_pathname(path); end
+
+  def self.load_rakefile(path); end
+
+  def self.original_dir(); end
+
+  def self.suggested_thread_count(); end
+
+  def self.with_application(block_application=T.unsafe(nil)); end
+end
+
+RakeFileUtils = Rake::FileUtilsExt
+
+module Random::Formatter
+  def alphanumeric(n=T.unsafe(nil)); end
+
+  ALPHANUMERIC = ::T.let(nil, ::T.untyped)
+end
+
+class Random
+  def self.bytes(_); end
+
+  def self.urandom(_); end
+end
+
+class Range
+  def %(_); end
+
+  def entries(); end
+
+  def to_a(); end
+end
+
+module RbConfig
+  def self.expand(val, config=T.unsafe(nil)); end
+
+  def self.fire_update!(key, val, mkconf=T.unsafe(nil), conf=T.unsafe(nil)); end
+
+  def self.ruby(); end
+end
+
+class RedBlackTree
+  include ::Enumerable
+  def [](key); end
+
+  def []=(key, value); end
+
+  def clear(); end
+
+  def default(); end
+
+  def default=(default); end
+
+  def default_proc(); end
+
+  def delete(key); end
+
+  def dump_sexp(); end
+
+  def dump_tree(io=T.unsafe(nil)); end
+
+  def each(&block); end
+
+  def each_key(); end
+
+  def each_pair(&block); end
+
+  def each_value(); end
+
+  def empty?(); end
+
+  def has_key?(key); end
+
+  def initialize(default=T.unsafe(nil), &block); end
+
+  def insert(key, value); end
+
+  def key?(key); end
+
+  def keys(); end
+
+  def length(); end
+
+  def root(); end
+
+  def size(); end
+
+  def to_hash(); end
+
+  def values(); end
+  DEFAULT = ::T.let(nil, ::T.untyped)
+end
+
+class RedBlackTree::Node
+  def balanced_rotate_left(); end
+
+  def balanced_rotate_right(); end
+
+  def black?(); end
+
+  def check_height(); end
+
+  def children_color?(color); end
+
+  def color(); end
+
+  def color=(color); end
+
+  def color_flip(other); end
+
+  def delete(key); end
+
+  def delete_min(); end
+
+  def dump_sexp(); end
+
+  def dump_tree(io, indent=T.unsafe(nil)); end
+
+  def each(&block); end
+
+  def each_key(); end
+
+  def each_value(); end
+
+  def empty?(); end
+
+  def initialize(key, value, left, right, color=T.unsafe(nil)); end
+
+  def insert(key, value); end
+
+  def key(); end
+
+  def keys(); end
+
+  def left(); end
+
+  def left=(left); end
+
+  def pullup_red(); end
+
+  def rebalance_for_left_delete(); end
+
+  def rebalance_for_right_delete(); end
+
+  def red?(); end
+
+  def retrieve(key); end
+
+  def right(); end
+
+  def right=(right); end
+
+  def rotate_left(); end
+
+  def rotate_right(); end
+
+  def set_root(); end
+
+  def size(); end
+
+  def value(); end
+
+  def values(); end
+  EMPTY = ::T.let(nil, ::T.untyped)
+  UNDEFINED = ::T.let(nil, ::T.untyped)
+end
+
+class RedBlackTree::Node::EmptyNode
+  def initialize(); end
+end
+
+class RedBlackTree::Node::EmptyNode
+end
+
+class RedBlackTree::Node
+end
+
+class RedBlackTree
+end
+
+class Resolv::DNS
+  def extract_resources(msg, name, typeclass); end
+
+  def fetch_resource(name, typeclass); end
+
+  def lazy_initialize(); end
+
+  def make_tcp_requester(host, port); end
+
+  def make_udp_requester(); end
+  RequestID = ::T.let(nil, ::T.untyped)
+  RequestIDMutex = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Config
+  def generate_candidates(name); end
+
+  def generate_timeouts(); end
+
+  def initialize(config_info=T.unsafe(nil)); end
+
+  def lazy_initialize(); end
+
+  def nameserver_port(); end
+
+  def resolv(name); end
+
+  def single?(); end
+
+  def timeouts=(values); end
+  InitialTimeout = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Config::NXDomain
+end
+
+class Resolv::DNS::Config::NXDomain
+end
+
+class Resolv::DNS::Config::OtherResolvError
+end
+
+class Resolv::DNS::Config::OtherResolvError
+end
+
+class Resolv::DNS::Config
+  def self.default_config_hash(filename=T.unsafe(nil)); end
+
+  def self.parse_resolv_conf(filename); end
+end
+
+module Resolv::DNS::Label
+end
+
+class Resolv::DNS::Label::Str
+  def ==(other); end
+
+  def downcase(); end
+
+  def eql?(other); end
+
+  def initialize(string); end
+
+  def string(); end
+end
+
+class Resolv::DNS::Label::Str
+end
+
+module Resolv::DNS::Label
+  def self.split(arg); end
+end
+
+class Resolv::DNS::Message
+  def ==(other); end
+
+  def aa(); end
+
+  def aa=(aa); end
+
+  def add_additional(name, ttl, data); end
+
+  def add_answer(name, ttl, data); end
+
+  def add_authority(name, ttl, data); end
+
+  def add_question(name, typeclass); end
+
+  def additional(); end
+
+  def answer(); end
+
+  def authority(); end
+
+  def each_additional(); end
+
+  def each_answer(); end
+
+  def each_authority(); end
+
+  def each_question(); end
+
+  def each_resource(); end
+
+  def encode(); end
+
+  def id(); end
+
+  def id=(id); end
+
+  def initialize(id=T.unsafe(nil)); end
+
+  def opcode(); end
+
+  def opcode=(opcode); end
+
+  def qr(); end
+
+  def qr=(qr); end
+
+  def question(); end
+
+  def ra(); end
+
+  def ra=(ra); end
+
+  def rcode(); end
+
+  def rcode=(rcode); end
+
+  def rd(); end
+
+  def rd=(rd); end
+
+  def tc(); end
+
+  def tc=(tc); end
+end
+
+class Resolv::DNS::Message::MessageDecoder
+  def get_bytes(len=T.unsafe(nil)); end
+
+  def get_label(); end
+
+  def get_labels(); end
+
+  def get_length16(); end
+
+  def get_name(); end
+
+  def get_question(); end
+
+  def get_rr(); end
+
+  def get_string(); end
+
+  def get_string_list(); end
+
+  def get_unpack(template); end
+
+  def initialize(data); end
+end
+
+class Resolv::DNS::Message::MessageDecoder
+end
+
+class Resolv::DNS::Message::MessageEncoder
+  def put_bytes(d); end
+
+  def put_label(d); end
+
+  def put_labels(d); end
+
+  def put_length16(); end
+
+  def put_name(d); end
+
+  def put_pack(template, *d); end
+
+  def put_string(d); end
+
+  def put_string_list(ds); end
+end
+
+class Resolv::DNS::Message::MessageEncoder
+end
+
+class Resolv::DNS::Message
+  def self.decode(m); end
+end
+
+class Resolv::DNS::Name
+  def ==(other); end
+
+  def [](i); end
+
+  def eql?(other); end
+
+  def length(); end
+
+  def to_a(); end
+end
+
+module Resolv::DNS::OpCode
+  IQuery = ::T.let(nil, ::T.untyped)
+  Notify = ::T.let(nil, ::T.untyped)
+  Query = ::T.let(nil, ::T.untyped)
+  Status = ::T.let(nil, ::T.untyped)
+  Update = ::T.let(nil, ::T.untyped)
+end
+
+module Resolv::DNS::OpCode
+end
+
+class Resolv::DNS::Query
+  def encode_rdata(msg); end
+end
+
+class Resolv::DNS::Query
+  def self.decode_rdata(msg); end
+end
+
+module Resolv::DNS::RCode
+  BADALG = ::T.let(nil, ::T.untyped)
+  BADKEY = ::T.let(nil, ::T.untyped)
+  BADMODE = ::T.let(nil, ::T.untyped)
+  BADNAME = ::T.let(nil, ::T.untyped)
+  BADSIG = ::T.let(nil, ::T.untyped)
+  BADTIME = ::T.let(nil, ::T.untyped)
+  BADVERS = ::T.let(nil, ::T.untyped)
+  FormErr = ::T.let(nil, ::T.untyped)
+  NXDomain = ::T.let(nil, ::T.untyped)
+  NXRRSet = ::T.let(nil, ::T.untyped)
+  NoError = ::T.let(nil, ::T.untyped)
+  NotAuth = ::T.let(nil, ::T.untyped)
+  NotImp = ::T.let(nil, ::T.untyped)
+  NotZone = ::T.let(nil, ::T.untyped)
+  Refused = ::T.let(nil, ::T.untyped)
+  ServFail = ::T.let(nil, ::T.untyped)
+  YXDomain = ::T.let(nil, ::T.untyped)
+  YXRRSet = ::T.let(nil, ::T.untyped)
+end
+
+module Resolv::DNS::RCode
+end
+
+class Resolv::DNS::Requester
+  def close(); end
+
+  def request(sender, tout); end
+
+  def sender_for(addr, msg); end
+end
+
+class Resolv::DNS::Requester::ConnectedUDP
+  def initialize(host, port=T.unsafe(nil)); end
+
+  def lazy_initialize(); end
+
+  def recv_reply(readable_socks); end
+
+  def sender(msg, data, host=T.unsafe(nil), port=T.unsafe(nil)); end
+end
+
+class Resolv::DNS::Requester::ConnectedUDP::Sender
+  def data(); end
+
+  def send(); end
+end
+
+class Resolv::DNS::Requester::ConnectedUDP::Sender
+end
+
+class Resolv::DNS::Requester::ConnectedUDP
+end
+
+class Resolv::DNS::Requester::MDNSOneShot
+end
+
+class Resolv::DNS::Requester::MDNSOneShot
+end
+
+class Resolv::DNS::Requester::RequestError
+end
+
+class Resolv::DNS::Requester::RequestError
+end
+
+class Resolv::DNS::Requester::Sender
+  def initialize(msg, data, sock); end
+end
+
+class Resolv::DNS::Requester::Sender
+end
+
+class Resolv::DNS::Requester::TCP
+  def initialize(host, port=T.unsafe(nil)); end
+
+  def recv_reply(readable_socks); end
+
+  def sender(msg, data, host=T.unsafe(nil), port=T.unsafe(nil)); end
+end
+
+class Resolv::DNS::Requester::TCP::Sender
+  def data(); end
+
+  def send(); end
+end
+
+class Resolv::DNS::Requester::TCP::Sender
+end
+
+class Resolv::DNS::Requester::TCP
+end
+
+class Resolv::DNS::Requester::UnconnectedUDP
+  def initialize(*nameserver_port); end
+
+  def lazy_initialize(); end
+
+  def recv_reply(readable_socks); end
+
+  def sender(msg, data, host, port=T.unsafe(nil)); end
+end
+
+class Resolv::DNS::Requester::UnconnectedUDP::Sender
+  def data(); end
+
+  def initialize(msg, data, sock, host, port); end
+
+  def send(); end
+end
+
+class Resolv::DNS::Requester::UnconnectedUDP::Sender
+end
+
+class Resolv::DNS::Requester::UnconnectedUDP
+end
+
+class Resolv::DNS::Requester
+end
+
+class Resolv::DNS::Resource
+  def ==(other); end
+
+  def eql?(other); end
+  ClassHash = ::T.let(nil, ::T.untyped)
+  ClassInsensitiveTypes = ::T.let(nil, ::T.untyped)
+  ClassValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::ANY
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::CNAME
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::Generic
+  def self.create(type_value, class_value); end
+end
+
+class Resolv::DNS::Resource::HINFO
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+module Resolv::DNS::Resource::IN
+  ClassValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::IN::A
+  ClassValue = ::T.let(nil, ::T.untyped)
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::IN::AAAA
+  ClassValue = ::T.let(nil, ::T.untyped)
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::IN::ANY
+  ClassValue = ::T.let(nil, ::T.untyped)
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::IN::ANY
+end
+
+class Resolv::DNS::Resource::IN::CNAME
+  ClassValue = ::T.let(nil, ::T.untyped)
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::IN::CNAME
+end
+
+class Resolv::DNS::Resource::IN::HINFO
+  ClassValue = ::T.let(nil, ::T.untyped)
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::IN::HINFO
+end
+
+class Resolv::DNS::Resource::IN::LOC
+  ClassValue = ::T.let(nil, ::T.untyped)
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::IN::LOC
+end
+
+class Resolv::DNS::Resource::IN::MINFO
+  ClassValue = ::T.let(nil, ::T.untyped)
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::IN::MINFO
+end
+
+class Resolv::DNS::Resource::IN::MX
+  ClassValue = ::T.let(nil, ::T.untyped)
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::IN::MX
+end
+
+class Resolv::DNS::Resource::IN::NS
+  ClassValue = ::T.let(nil, ::T.untyped)
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::IN::NS
+end
+
+class Resolv::DNS::Resource::IN::PTR
+  ClassValue = ::T.let(nil, ::T.untyped)
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::IN::PTR
+end
+
+class Resolv::DNS::Resource::IN::SOA
+  ClassValue = ::T.let(nil, ::T.untyped)
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::IN::SOA
+end
+
+class Resolv::DNS::Resource::IN::SRV
+  ClassValue = ::T.let(nil, ::T.untyped)
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::IN::TXT
+  ClassValue = ::T.let(nil, ::T.untyped)
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::IN::TXT
+end
+
+class Resolv::DNS::Resource::IN::WKS
+  ClassValue = ::T.let(nil, ::T.untyped)
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::LOC
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::MINFO
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::MX
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::NS
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::PTR
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::SOA
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource::TXT
+  TypeValue = ::T.let(nil, ::T.untyped)
+end
+
+class Resolv::DNS::Resource
+  def self.get_class(type_value, class_value); end
+end
+
+class Resolv::DNS
+  def self.allocate_request_id(host, port); end
+
+  def self.bind_random_port(udpsock, bind_host=T.unsafe(nil)); end
+
+  def self.free_request_id(host, port, id); end
+
+  def self.random(arg); end
+end
+
+class Resolv::Hosts
+  def lazy_initialize(); end
+end
+
+class Resolv::IPv4
+  def ==(other); end
+
+  def eql?(other); end
+end
+
+class Resolv::IPv6
+  def ==(other); end
+
+  def eql?(other); end
+end
+
+class Resolv::LOC::Alt
+  def ==(other); end
+
+  def eql?(other); end
+end
+
+class Resolv::LOC::Coord
+  def ==(other); end
+
+  def eql?(other); end
+end
+
+class Resolv::LOC::Size
+  def ==(other); end
+
+  def eql?(other); end
+end
+
+module RuboCop
+end
+
+module RuboCop::AST
+end
+
+class RuboCop::AST::AliasNode
+  def new_identifier(); end
+
+  def old_identifier(); end
+end
+
+class RuboCop::AST::AliasNode
+end
+
+class RuboCop::AST::AndNode
+  include ::RuboCop::AST::BinaryOperatorNode
+  include ::RuboCop::AST::PredicateOperatorNode
+  def alternate_operator(); end
+
+  def inverse_operator(); end
+end
+
+class RuboCop::AST::AndNode
+end
+
+class RuboCop::AST::ArgsNode
+  include ::RuboCop::AST::CollectionNode
+  def empty_and_without_delimiters?(); end
+end
+
+class RuboCop::AST::ArgsNode
+end
+
+class RuboCop::AST::ArrayNode
+  def bracketed?(); end
+
+  def percent_literal?(type=T.unsafe(nil)); end
+
+  def square_brackets?(); end
+
+  def values(); end
+  PERCENT_LITERAL_TYPES = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::AST::ArrayNode
+end
+
+module RuboCop::AST::BasicLiteralNode
+  def value(); end
+end
+
+module RuboCop::AST::BasicLiteralNode
+end
+
+module RuboCop::AST::BinaryOperatorNode
+  def conditions(); end
+
+  def lhs(); end
+
+  def rhs(); end
+end
+
+module RuboCop::AST::BinaryOperatorNode
+end
+
+class RuboCop::AST::BlockNode
+  include ::RuboCop::AST::MethodIdentifierPredicates
+  def arguments(); end
+
+  def arguments?(); end
+
+  def body(); end
+
+  def braces?(); end
+
+  def closing_delimiter(); end
+
+  def delimiters(); end
+
+  def keywords?(); end
+
+  def lambda?(); end
+
+  def method_name(); end
+
+  def opening_delimiter(); end
+
+  def send_node(); end
+
+  def void_context?(); end
+  VOID_CONTEXT_METHODS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::AST::BlockNode
+end
+
+class RuboCop::AST::BreakNode
+  include ::RuboCop::AST::MethodDispatchNode
+  include ::RuboCop::AST::MethodIdentifierPredicates
+  include ::RuboCop::AST::ParameterizedNode
+end
+
+class RuboCop::AST::BreakNode
+end
+
+class RuboCop::AST::Builder
+  NODE_MAP = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::AST::Builder
+end
+
+class RuboCop::AST::CaseNode
+  include ::RuboCop::AST::ConditionalNode
+  def each_when(); end
+
+  def else?(); end
+
+  def else_branch(); end
+
+  def keyword(); end
+
+  def when_branches(); end
+end
+
+class RuboCop::AST::CaseNode
+end
+
+class RuboCop::AST::ClassNode
+  def body(); end
+
+  def identifier(); end
+
+  def parent_class(); end
+end
+
+class RuboCop::AST::ClassNode
+end
+
+module RuboCop::AST::CollectionNode
+  def &(*args, &block); end
+
+  def *(*args, &block); end
+
+  def +(*args, &block); end
+
+  def -(*args, &block); end
+
+  def <<(*args, &block); end
+
+  def [](*args, &block); end
+
+  def []=(*args, &block); end
+
+  def all?(*args, &block); end
+
+  def any?(*args, &block); end
+
+  def append(*args, &block); end
+
+  def assoc(*args, &block); end
+
+  def at(*args, &block); end
+
+  def bsearch(*args, &block); end
+
+  def bsearch_index(*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!(*args, &block); end
+
+  def collect_concat(*args, &block); end
+
+  def combination(*args, &block); end
+
+  def compact(*args, &block); end
+
+  def compact!(*args, &block); end
+
+  def concat(*args, &block); end
+
+  def count(*args, &block); end
+
+  def cycle(*args, &block); end
+
+  def delete(*args, &block); end
+
+  def delete_at(*args, &block); end
+
+  def delete_if(*args, &block); end
+
+  def detect(*args, &block); end
+
+  def difference(*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_index(*args, &block); end
+
+  def each_slice(*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 fetch(*args, &block); end
+
+  def fill(*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 flatten!(*args, &block); end
+
+  def grep(*args, &block); end
+
+  def grep_v(*args, &block); end
+
+  def group_by(*args, &block); end
+
+  def include?(*args, &block); end
+
+  def index(*args, &block); end
+
+  def inject(*args, &block); end
+
+  def insert(*args, &block); end
+
+  def join(*args, &block); end
+
+  def keep_if(*args, &block); end
+
+  def last(*args, &block); end
+
+  def lazy(*args, &block); end
+
+  def length(*args, &block); end
+
+  def map(*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 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 pack(*args, &block); end
+
+  def partition(*args, &block); end
+
+  def permutation(*args, &block); end
+
+  def pop(*args, &block); end
+
+  def prepend(*args, &block); end
+
+  def product(*args, &block); end
+
+  def push(*args, &block); end
+
+  def rassoc(*args, &block); end
+
+  def reduce(*args, &block); end
+
+  def reject(*args, &block); end
+
+  def reject!(*args, &block); end
+
+  def repeated_combination(*args, &block); end
+
+  def repeated_permutation(*args, &block); end
+
+  def replace(*args, &block); end
+
+  def reverse(*args, &block); end
+
+  def reverse!(*args, &block); end
+
+  def reverse_each(*args, &block); end
+
+  def rindex(*args, &block); end
+
+  def rotate(*args, &block); end
+
+  def rotate!(*args, &block); end
+
+  def sample(*args, &block); end
+
+  def select(*args, &block); end
+
+  def select!(*args, &block); end
+
+  def shelljoin(*args, &block); end
+
+  def shift(*args, &block); end
+
+  def shuffle(*args, &block); end
+
+  def shuffle!(*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!(*args, &block); end
+
+  def sort_by(*args, &block); end
+
+  def sort_by!(*args, &block); end
+
+  def sum(*args, &block); end
+
+  def take(*args, &block); end
+
+  def take_while(*args, &block); end
+
+  def to_ary(*args, &block); end
+
+  def to_h(*args, &block); end
+
+  def to_set(*args, &block); end
+
+  def transpose(*args, &block); end
+
+  def union(*args, &block); end
+
+  def uniq(*args, &block); end
+
+  def uniq!(*args, &block); end
+
+  def unshift(*args, &block); end
+
+  def values_at(*args, &block); end
+
+  def zip(*args, &block); end
+
+  def |(*args, &block); end
+  ARRAY_METHODS = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::AST::CollectionNode
+  extend ::Forwardable
+end
+
+module RuboCop::AST::ConditionalNode
+  def body(); end
+
+  def condition(); end
+
+  def multiline_condition?(); end
+
+  def single_line_condition?(); end
+end
+
+module RuboCop::AST::ConditionalNode
+end
+
+class RuboCop::AST::DefNode
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::MethodIdentifierPredicates
+  def argument_forwarding?(); end
+
+  def arguments(); end
+
+  def body(); end
+
+  def method_name(); end
+
+  def receiver(); end
+
+  def void_context?(); end
+end
+
+class RuboCop::AST::DefNode
+end
+
+class RuboCop::AST::DefinedNode
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::MethodDispatchNode
+  include ::RuboCop::AST::MethodIdentifierPredicates
+end
+
+class RuboCop::AST::DefinedNode
+end
+
+class RuboCop::AST::EnsureNode
+  def body(); end
+end
+
+class RuboCop::AST::EnsureNode
+end
+
+class RuboCop::AST::FloatNode
+  include ::RuboCop::AST::NumericNode
+end
+
+class RuboCop::AST::FloatNode
+end
+
+class RuboCop::AST::ForNode
+  def body(); end
+
+  def collection(); end
+
+  def do?(); end
+
+  def keyword(); end
+
+  def variable(); end
+
+  def void_context?(); end
+end
+
+class RuboCop::AST::ForNode
+end
+
+class RuboCop::AST::ForwardArgsNode
+  include ::RuboCop::AST::CollectionNode
+end
+
+class RuboCop::AST::ForwardArgsNode
+end
+
+module RuboCop::AST::HashElementNode
+  def delimiter_delta(other); end
+
+  def key(); end
+
+  def key_delta(other, alignment=T.unsafe(nil)); end
+
+  def same_line?(other); end
+
+  def value(); end
+
+  def value_delta(other); end
+end
+
+module RuboCop::AST::HashElementNode
+end
+
+class RuboCop::AST::HashNode
+  def braces?(); end
+
+  def each_key(); end
+
+  def each_pair(); end
+
+  def each_value(); end
+
+  def empty?(); end
+
+  def keys(); end
+
+  def mixed_delimiters?(); end
+
+  def pairs(); end
+
+  def pairs_on_same_line?(); end
+
+  def values(); end
+end
+
+class RuboCop::AST::HashNode
+end
+
+class RuboCop::AST::IfNode
+  include ::RuboCop::AST::ConditionalNode
+  include ::RuboCop::AST::ModifierNode
+  def branches(); end
+
+  def each_branch(); end
+
+  def else?(); end
+
+  def else_branch(); end
+
+  def elsif?(); end
+
+  def elsif_conditional?(); end
+
+  def if?(); end
+
+  def if_branch(); end
+
+  def inverse_keyword(); end
+
+  def keyword(); end
+
+  def nested_conditional?(); end
+
+  def ternary?(); end
+
+  def unless?(); end
+end
+
+class RuboCop::AST::IfNode
+end
+
+class RuboCop::AST::IntNode
+  include ::RuboCop::AST::NumericNode
+end
+
+class RuboCop::AST::IntNode
+end
+
+class RuboCop::AST::KeywordSplatNode
+  include ::RuboCop::AST::HashElementNode
+  def colon?(); end
+
+  def hash_rocket?(); end
+
+  def operator(); end
+  DOUBLE_SPLAT = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::AST::KeywordSplatNode
+end
+
+module RuboCop::AST::MethodDispatchNode
+  include ::RuboCop::AST::MethodIdentifierPredicates
+  def access_modifier?(); end
+
+  def adjacent_def_modifier?(node=T.unsafe(nil)); end
+
+  def arguments(); end
+
+  def arithmetic_operation?(); end
+
+  def assignment?(); end
+
+  def bare_access_modifier?(); end
+
+  def bare_access_modifier_declaration?(node=T.unsafe(nil)); end
+
+  def binary_operation?(); end
+
+  def block_literal?(); end
+
+  def block_node(); end
+
+  def command?(name); end
+
+  def const_receiver?(); end
+
+  def def_modifier?(); end
+
+  def dot?(); end
+
+  def double_colon?(); end
+
+  def implicit_call?(); end
+
+  def lambda?(); end
+
+  def lambda_literal?(); end
+
+  def macro?(); end
+
+  def macro_scope?(node=T.unsafe(nil)); end
+
+  def method_name(); end
+
+  def non_bare_access_modifier?(); end
+
+  def non_bare_access_modifier_declaration?(node=T.unsafe(nil)); end
+
+  def receiver(); end
+
+  def self_receiver?(); end
+
+  def setter_method?(); end
+
+  def special_modifier?(); end
+
+  def unary_operation?(); end
+  ARITHMETIC_OPERATORS = ::T.let(nil, ::T.untyped)
+  SPECIAL_MODIFIERS = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::AST::MethodDispatchNode
+  extend ::RuboCop::NodePattern::Macros
+end
+
+module RuboCop::AST::MethodIdentifierPredicates
+  def assignment_method?(); end
+
+  def bang_method?(); end
+
+  def camel_case_method?(); end
+
+  def comparison_method?(); end
+
+  def const_receiver?(); end
+
+  def enumerator_method?(); end
+
+  def method?(name); end
+
+  def negation_method?(); end
+
+  def operator_method?(); end
+
+  def predicate_method?(); end
+
+  def prefix_bang?(); end
+
+  def prefix_not?(); end
+
+  def self_receiver?(); end
+  ENUMERATOR_METHODS = ::T.let(nil, ::T.untyped)
+  OPERATOR_METHODS = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::AST::MethodIdentifierPredicates
+end
+
+module RuboCop::AST::ModifierNode
+  def modifier_form?(); end
+end
+
+module RuboCop::AST::ModifierNode
+end
+
+class RuboCop::AST::ModuleNode
+  def body(); end
+
+  def identifier(); end
+end
+
+class RuboCop::AST::ModuleNode
+end
+
+class RuboCop::AST::Node
+  include ::RuboCop::AST::Sexp
+  def __ENCODING___type?(); end
+
+  def __FILE___type?(); end
+
+  def __LINE___type?(); end
+
+  def alias_type?(); end
+
+  def ancestors(); end
+
+  def and_asgn_type?(); end
+
+  def and_type?(); end
+
+  def arg_expr_type?(); end
+
+  def arg_type?(); end
+
+  def args_type?(); end
+
+  def argument?(); end
+
+  def array_pattern_type?(); end
+
+  def array_pattern_with_tail_type?(); end
+
+  def array_type?(); end
+
+  def assignment?(); end
+
+  def assignment_or_similar?(node=T.unsafe(nil)); end
+
+  def back_ref_type?(); end
+
+  def basic_conditional?(); end
+
+  def basic_literal?(); end
+
+  def begin_type?(); end
+
+  def block_pass_type?(); end
+
+  def block_type?(); end
+
+  def blockarg_expr_type?(); end
+
+  def blockarg_type?(); end
+
+  def boolean_type?(); end
+
+  def break_type?(); end
+
+  def call_type?(); end
+
+  def case_match_type?(); end
+
+  def case_type?(); end
+
+  def casgn_type?(); end
+
+  def cbase_type?(); end
+
+  def chained?(); end
+
+  def child_nodes(); end
+
+  def class_constructor?(node=T.unsafe(nil)); end
+
+  def class_type?(); end
+
+  def complete!(); end
+
+  def complete?(); end
+
+  def complex_type?(); end
+
+  def conditional?(); end
+
+  def const_name(); end
+
+  def const_pattern_type?(); end
+
+  def const_type?(); end
+
+  def csend_type?(); end
+
+  def cvar_type?(); end
+
+  def cvasgn_type?(); end
+
+  def def_type?(); end
+
+  def defined_module(); end
+
+  def defined_module_name(); end
+
+  def defined_type?(); end
+
+  def defs_type?(); end
+
+  def descendants(); end
+
+  def dstr_type?(); end
+
+  def dsym_type?(); end
+
+  def each_ancestor(*types, &block); end
+
+  def each_child_node(*types); end
+
+  def each_descendant(*types, &block); end
+
+  def each_node(*types, &block); end
+
+  def eflipflop_type?(); end
+
+  def empty_else_type?(); end
+
+  def empty_source?(); end
+
+  def ensure_type?(); end
+
+  def equals_asgn?(); end
+
+  def erange_type?(); end
+
+  def false_type?(); end
+
+  def falsey_literal?(); end
+
+  def first_line(); end
+
+  def float_type?(); end
+
+  def for_type?(); end
+
+  def forward_args_type?(); end
+
+  def forwarded_args_type?(); end
+
+  def guard_clause?(node=T.unsafe(nil)); end
+
+  def gvar_type?(); end
+
+  def gvasgn_type?(); end
+
+  def hash_pattern_type?(); end
+
+  def hash_type?(); end
+
+  def ident_type?(); end
+
+  def if_guard_type?(); end
+
+  def if_type?(); end
+
+  def iflipflop_type?(); end
+
+  def immutable_literal?(); end
+
+  def in_match_type?(); end
+
+  def in_pattern_type?(); end
+
+  def index_type?(); end
+
+  def indexasgn_type?(); end
+
+  def int_type?(); end
+
+  def irange_type?(); end
+
+  def ivar_type?(); end
+
+  def ivasgn_type?(); end
+
+  def keyword?(); end
+
+  def kwarg_type?(); end
+
+  def kwbegin_type?(); end
+
+  def kwnilarg_type?(); end
+
+  def kwoptarg_type?(); end
+
+  def kwrestarg_type?(); end
+
+  def kwsplat_type?(); end
+
+  def lambda?(node=T.unsafe(nil)); end
+
+  def lambda_or_proc?(node=T.unsafe(nil)); end
+
+  def lambda_type?(); end
+
+  def last_line(); end
+
+  def line_count(); end
+
+  def literal?(); end
+
+  def lvar_type?(); end
+
+  def lvasgn_type?(); end
+
+  def masgn_type?(); end
+
+  def match_alt_type?(); end
+
+  def match_as_type?(); end
+
+  def match_current_line_type?(); end
+
+  def match_nil_pattern_type?(); end
+
+  def match_rest_type?(); end
+
+  def match_var_type?(); end
+
+  def match_with_lvasgn_type?(); end
+
+  def match_with_trailing_comma_type?(); end
+
+  def mlhs_type?(); end
+
+  def module_type?(); end
+
+  def multiline?(); end
+
+  def mutable_literal?(); end
+
+  def new_class_or_module_block?(node=T.unsafe(nil)); end
+
+  def next_type?(); end
+
+  def nil_type?(); end
+
+  def node_parts(); end
+
+  def nonempty_line_count(); end
+
+  def not_type?(); end
+
+  def nth_ref_type?(); end
+
+  def numargs_type?(); end
+
+  def numblock_type?(); end
+
+  def numeric_type?(); end
+
+  def objc_kwarg_type?(); end
+
+  def objc_restarg_type?(); end
+
+  def objc_varargs_type?(); end
+
+  def op_asgn_type?(); end
+
+  def operator_keyword?(); end
+
+  def optarg_type?(); end
+
+  def or_asgn_type?(); end
+
+  def or_type?(); end
+
+  def pair_type?(); end
+
+  def parent(); end
+
+  def parent=(node); end
+
+  def parent_module_name(); end
+
+  def parenthesized_call?(); end
+
+  def pin_type?(); end
+
+  def postexe_type?(); end
+
+  def preexe_type?(); end
+
+  def proc?(node=T.unsafe(nil)); end
+
+  def procarg0_type?(); end
+
+  def pure?(); end
+
+  def range_type?(); end
+
+  def rational_type?(); end
+
+  def receiver(node=T.unsafe(nil)); end
+
+  def recursive_basic_literal?(); end
+
+  def recursive_literal?(); end
+
+  def redo_type?(); end
+
+  def reference?(); end
+
+  def regexp_type?(); end
+
+  def regopt_type?(); end
+
+  def resbody_type?(); end
+
+  def rescue_type?(); end
+
+  def restarg_expr_type?(); end
+
+  def restarg_type?(); end
+
+  def retry_type?(); end
+
+  def return_type?(); end
+
+  def root_type?(); end
+
+  def sclass_type?(); end
+
+  def self_type?(); end
+
+  def send_type?(); end
+
+  def shadowarg_type?(); end
+
+  def shorthand_asgn?(); end
+
+  def sibling_index(); end
+
+  def single_line?(); end
+
+  def source(); end
+
+  def source_length(); end
+
+  def source_range(); end
+
+  def special_keyword?(); end
+
+  def splat_type?(); end
+
+  def str_content(node=T.unsafe(nil)); end
+
+  def str_type?(); end
+
+  def super_type?(); end
+
+  def sym_type?(); end
+
+  def true_type?(); end
+
+  def truthy_literal?(); end
+
+  def undef_type?(); end
+
+  def unless_guard_type?(); end
+
+  def until_post_type?(); end
+
+  def until_type?(); end
+
+  def value_used?(); end
+
+  def variable?(); end
+
+  def visit_descendants(types, &block); end
+
+  def when_type?(); end
+
+  def while_post_type?(); end
+
+  def while_type?(); end
+
+  def xstr_type?(); end
+
+  def yield_type?(); end
+
+  def zsuper_type?(); end
+  ASSIGNMENTS = ::T.let(nil, ::T.untyped)
+  BASIC_CONDITIONALS = ::T.let(nil, ::T.untyped)
+  BASIC_LITERALS = ::T.let(nil, ::T.untyped)
+  COMPARISON_OPERATORS = ::T.let(nil, ::T.untyped)
+  COMPOSITE_LITERALS = ::T.let(nil, ::T.untyped)
+  CONDITIONALS = ::T.let(nil, ::T.untyped)
+  EQUALS_ASSIGNMENTS = ::T.let(nil, ::T.untyped)
+  FALSEY_LITERALS = ::T.let(nil, ::T.untyped)
+  IMMUTABLE_LITERALS = ::T.let(nil, ::T.untyped)
+  KEYWORDS = ::T.let(nil, ::T.untyped)
+  LITERALS = ::T.let(nil, ::T.untyped)
+  MUTABLE_LITERALS = ::T.let(nil, ::T.untyped)
+  OPERATOR_KEYWORDS = ::T.let(nil, ::T.untyped)
+  REFERENCES = ::T.let(nil, ::T.untyped)
+  SHORTHAND_ASSIGNMENTS = ::T.let(nil, ::T.untyped)
+  SPECIAL_KEYWORDS = ::T.let(nil, ::T.untyped)
+  TRUTHY_LITERALS = ::T.let(nil, ::T.untyped)
+  VARIABLES = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::AST::Node
+  extend ::RuboCop::NodePattern::Macros
+end
+
+module RuboCop::AST::NumericNode
+  def sign?(); end
+  SIGN_REGEX = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::AST::NumericNode
+end
+
+class RuboCop::AST::OrNode
+  include ::RuboCop::AST::BinaryOperatorNode
+  include ::RuboCop::AST::PredicateOperatorNode
+  def alternate_operator(); end
+
+  def inverse_operator(); end
+end
+
+class RuboCop::AST::OrNode
+end
+
+class RuboCop::AST::PairNode
+  include ::RuboCop::AST::HashElementNode
+  def colon?(); end
+
+  def delimiter(with_spacing=T.unsafe(nil)); end
+
+  def hash_rocket?(); end
+
+  def inverse_delimiter(with_spacing=T.unsafe(nil)); end
+
+  def value_on_new_line?(); end
+  COLON = ::T.let(nil, ::T.untyped)
+  HASH_ROCKET = ::T.let(nil, ::T.untyped)
+  SPACED_COLON = ::T.let(nil, ::T.untyped)
+  SPACED_HASH_ROCKET = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::AST::PairNode
+end
+
+module RuboCop::AST::ParameterizedNode
+  def arguments?(); end
+
+  def block_argument?(); end
+
+  def first_argument(); end
+
+  def last_argument(); end
+
+  def parenthesized?(); end
+
+  def rest_argument?(); end
+
+  def splat_argument?(); end
+end
+
+module RuboCop::AST::ParameterizedNode
+end
+
+module RuboCop::AST::PredicateOperatorNode
+  def logical_operator?(); end
+
+  def operator(); end
+
+  def semantic_operator?(); end
+  LOGICAL_AND = ::T.let(nil, ::T.untyped)
+  LOGICAL_OR = ::T.let(nil, ::T.untyped)
+  SEMANTIC_AND = ::T.let(nil, ::T.untyped)
+  SEMANTIC_OR = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::AST::PredicateOperatorNode
+end
+
+class RuboCop::AST::RangeNode
+  def begin(); end
+
+  def end(); end
+end
+
+class RuboCop::AST::RangeNode
+end
+
+class RuboCop::AST::RegexpNode
+  def content(); end
+
+  def regopt(); end
+
+  def to_regexp(); end
+  OPTIONS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::AST::RegexpNode
+end
+
+class RuboCop::AST::ResbodyNode
+  def body(); end
+
+  def exception_variable(); end
+end
+
+class RuboCop::AST::ResbodyNode
+end
+
+class RuboCop::AST::RetryNode
+  include ::RuboCop::AST::MethodDispatchNode
+  include ::RuboCop::AST::MethodIdentifierPredicates
+  include ::RuboCop::AST::ParameterizedNode
+end
+
+class RuboCop::AST::RetryNode
+end
+
+class RuboCop::AST::ReturnNode
+  include ::RuboCop::AST::MethodDispatchNode
+  include ::RuboCop::AST::MethodIdentifierPredicates
+  include ::RuboCop::AST::ParameterizedNode
+end
+
+class RuboCop::AST::ReturnNode
+end
+
+class RuboCop::AST::SelfClassNode
+  def body(); end
+
+  def identifier(); end
+end
+
+class RuboCop::AST::SelfClassNode
+end
+
+class RuboCop::AST::SendNode
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::MethodDispatchNode
+  include ::RuboCop::AST::MethodIdentifierPredicates
+end
+
+class RuboCop::AST::SendNode
+end
+
+module RuboCop::AST::Sexp
+  def s(type, *children); end
+end
+
+module RuboCop::AST::Sexp
+end
+
+class RuboCop::AST::StrNode
+  include ::RuboCop::AST::BasicLiteralNode
+  def heredoc?(); end
+end
+
+class RuboCop::AST::StrNode
+end
+
+class RuboCop::AST::SuperNode
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::MethodDispatchNode
+  include ::RuboCop::AST::MethodIdentifierPredicates
+end
+
+class RuboCop::AST::SuperNode
+end
+
+class RuboCop::AST::SymbolNode
+  include ::RuboCop::AST::BasicLiteralNode
+end
+
+class RuboCop::AST::SymbolNode
+end
+
+module RuboCop::AST::Traversal
+  def on_alias(node); end
+
+  def on_and(node); end
+
+  def on_and_asgn(node); end
+
+  def on_arg(node); end
+
+  def on_arg_expr(node); end
+
+  def on_args(node); end
+
+  def on_array(node); end
+
+  def on_array_pattern(node); end
+
+  def on_array_pattern_with_tail(node); end
+
+  def on_back_ref(node); end
+
+  def on_begin(node); end
+
+  def on_block(node); end
+
+  def on_block_pass(node); end
+
+  def on_blockarg(node); end
+
+  def on_break(node); end
+
+  def on_case(node); end
+
+  def on_case_match(node); end
+
+  def on_casgn(node); end
+
+  def on_cbase(node); end
+
+  def on_class(node); end
+
+  def on_complex(node); end
+
+  def on_const(node); end
+
+  def on_const_pattern(node); end
+
+  def on_csend(node); end
+
+  def on_cvar(node); end
+
+  def on_cvasgn(node); end
+
+  def on_def(node); end
+
+  def on_defined?(node); end
+
+  def on_defs(node); end
+
+  def on_dstr(node); end
+
+  def on_dsym(node); end
+
+  def on_eflipflop(node); end
+
+  def on_ensure(node); end
+
+  def on_erange(node); end
+
+  def on_false(node); end
+
+  def on_float(node); end
+
+  def on_for(node); end
+
+  def on_forward_args(node); end
+
+  def on_forwarded_args(node); end
+
+  def on_gvar(node); end
+
+  def on_gvasgn(node); end
+
+  def on_hash(node); end
+
+  def on_hash_pattern(node); end
+
+  def on_if(node); end
+
+  def on_if_guard(node); end
+
+  def on_iflipflop(node); end
+
+  def on_in_match(node); end
+
+  def on_in_pattern(node); end
+
+  def on_int(node); end
+
+  def on_irange(node); end
+
+  def on_ivar(node); end
+
+  def on_ivasgn(node); end
+
+  def on_kwarg(node); end
+
+  def on_kwbegin(node); end
+
+  def on_kwoptarg(node); end
+
+  def on_kwrestarg(node); end
+
+  def on_kwsplat(node); end
+
+  def on_lambda(node); end
+
+  def on_lvar(node); end
+
+  def on_lvasgn(node); end
+
+  def on_masgn(node); end
+
+  def on_match_alt(node); end
+
+  def on_match_as(node); end
+
+  def on_match_current_line(node); end
+
+  def on_match_nil_pattern(node); end
+
+  def on_match_rest(node); end
+
+  def on_match_var(node); end
+
+  def on_match_with_lvasgn(node); end
+
+  def on_match_with_trailing_comma(node); end
+
+  def on_mlhs(node); end
+
+  def on_module(node); end
+
+  def on_next(node); end
+
+  def on_nil(node); end
+
+  def on_not(node); end
+
+  def on_nth_ref(node); end
+
+  def on_numblock(node); end
+
+  def on_op_asgn(node); end
+
+  def on_optarg(node); end
+
+  def on_or(node); end
+
+  def on_or_asgn(node); end
+
+  def on_pair(node); end
+
+  def on_pin(node); end
+
+  def on_postexe(node); end
+
+  def on_preexe(node); end
+
+  def on_rational(node); end
+
+  def on_redo(node); end
+
+  def on_regexp(node); end
+
+  def on_regopt(node); end
+
+  def on_resbody(node); end
+
+  def on_rescue(node); end
+
+  def on_restarg(node); end
+
+  def on_retry(node); end
+
+  def on_return(node); end
+
+  def on_sclass(node); end
+
+  def on_self(node); end
+
+  def on_send(node); end
+
+  def on_shadowarg(node); end
+
+  def on_splat(node); end
+
+  def on_str(node); end
+
+  def on_super(node); end
+
+  def on_sym(node); end
+
+  def on_true(node); end
+
+  def on_undef(node); end
+
+  def on_unless_guard(node); end
+
+  def on_until(node); end
+
+  def on_until_post(node); end
+
+  def on_when(node); end
+
+  def on_while(node); end
+
+  def on_while_post(node); end
+
+  def on_xstr(node); end
+
+  def on_yield(node); end
+
+  def on_zsuper(node); end
+
+  def walk(node); end
+  MANY_CHILD_NODES = ::T.let(nil, ::T.untyped)
+  NO_CHILD_NODES = ::T.let(nil, ::T.untyped)
+  ONE_CHILD_NODE = ::T.let(nil, ::T.untyped)
+  SECOND_CHILD_ONLY = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::AST::Traversal
+end
+
+class RuboCop::AST::UntilNode
+  include ::RuboCop::AST::ConditionalNode
+  include ::RuboCop::AST::ModifierNode
+  def do?(); end
+
+  def inverse_keyword(); end
+
+  def keyword(); end
+end
+
+class RuboCop::AST::UntilNode
+end
+
+class RuboCop::AST::WhenNode
+  def body(); end
+
+  def branch_index(); end
+
+  def conditions(); end
+
+  def each_condition(); end
+
+  def then?(); end
+end
+
+class RuboCop::AST::WhenNode
+end
+
+class RuboCop::AST::WhileNode
+  include ::RuboCop::AST::ConditionalNode
+  include ::RuboCop::AST::ModifierNode
+  def do?(); end
+
+  def inverse_keyword(); end
+
+  def keyword(); end
+end
+
+class RuboCop::AST::WhileNode
+end
+
+class RuboCop::AST::YieldNode
+  include ::RuboCop::AST::ParameterizedNode
+  include ::RuboCop::AST::MethodDispatchNode
+  include ::RuboCop::AST::MethodIdentifierPredicates
+end
+
+class RuboCop::AST::YieldNode
+end
+
+module RuboCop::AST
+end
+
+class RuboCop::CLI
+  def config_store(); end
+
+  def options(); end
+
+  def run(args=T.unsafe(nil)); end
+  STATUS_ERROR = ::T.let(nil, ::T.untyped)
+  STATUS_INTERRUPTED = ::T.let(nil, ::T.untyped)
+  STATUS_OFFENSES = ::T.let(nil, ::T.untyped)
+  STATUS_SUCCESS = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::CLI::Command
+end
+
+class RuboCop::CLI::Command::AutoGenerateConfig
+  def run(); end
+  PHASE_1 = ::T.let(nil, ::T.untyped)
+  PHASE_1_DISABLED = ::T.let(nil, ::T.untyped)
+  PHASE_1_OVERRIDDEN = ::T.let(nil, ::T.untyped)
+  PHASE_2 = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::CLI::Command::AutoGenerateConfig
+end
+
+class RuboCop::CLI::Command::Base
+  def env(); end
+
+  def initialize(env); end
+end
+
+class RuboCop::CLI::Command::Base
+  def self.by_command_name(name); end
+
+  def self.command_name(); end
+
+  def self.command_name=(command_name); end
+
+  def self.inherited(subclass); end
+end
+
+class RuboCop::CLI::Command::ExecuteRunner
+  include ::RuboCop::Formatter::TextUtil
+  def run(); end
+end
+
+class RuboCop::CLI::Command::ExecuteRunner
+end
+
+class RuboCop::CLI::Command::InitDotfile
+  def run(); end
+  DOTFILE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::CLI::Command::InitDotfile
+end
+
+class RuboCop::CLI::Command::ShowCops
+  def run(); end
+end
+
+class RuboCop::CLI::Command::ShowCops
+end
+
+class RuboCop::CLI::Command::Version
+  def run(); end
+end
+
+class RuboCop::CLI::Command::Version
+end
+
+module RuboCop::CLI::Command
+  def self.run(env, name); end
+end
+
+class RuboCop::CLI::Environment
+  def config_store(); end
+
+  def initialize(options, config_store, paths); end
+
+  def options(); end
+
+  def paths(); end
+
+  def run(name); end
+end
+
+class RuboCop::CLI::Environment
+end
+
+class RuboCop::CLI::Finished
+end
+
+class RuboCop::CLI::Finished
+end
+
+class RuboCop::CLI
+end
+
+class RuboCop::CachedData
+  def from_json(text); end
+
+  def initialize(filename); end
+
+  def to_json(offenses); end
+end
+
+class RuboCop::CachedData
+end
+
+class RuboCop::CommentConfig
+  def cop_disabled_line_ranges(); end
+
+  def cop_enabled_at_line?(cop, line_number); end
+
+  def extra_enabled_comments(); end
+
+  def initialize(processed_source); end
+
+  def processed_source(); end
+  COMMENT_DIRECTIVE_REGEXP = ::T.let(nil, ::T.untyped)
+  COPS_PATTERN = ::T.let(nil, ::T.untyped)
+  COP_NAMES_PATTERN = ::T.let(nil, ::T.untyped)
+  COP_NAME_PATTERN = ::T.let(nil, ::T.untyped)
+  REDUNDANT_DISABLE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::CommentConfig::CopAnalysis
+  def line_ranges(); end
+
+  def line_ranges=(_); end
+
+  def start_line_number(); end
+
+  def start_line_number=(_); end
+end
+
+class RuboCop::CommentConfig::CopAnalysis
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+class RuboCop::CommentConfig
+end
+
+class RuboCop::Config
+  include ::RuboCop::PathUtil
+  include ::RuboCop::FileFinder
+  def [](*args, &block); end
+
+  def []=(*args, &block); end
+
+  def add_excludes_from_higher_level(highest_config); end
+
+  def allowed_camel_case_file?(file); end
+
+  def base_dir_for_path_parameters(); end
+
+  def bundler_lock_file_path(); end
+
+  def check(); end
+
+  def delete(*args, &block); end
+
+  def deprecation_check(); end
+
+  def each(*args, &block); end
+
+  def each_key(*args, &block); end
+
+  def file_to_exclude?(file); end
+
+  def file_to_include?(file); end
+
+  def for_all_cops(); end
+
+  def for_cop(cop); end
+
+  def for_department(department_name); end
+
+  def initialize(hash=T.unsafe(nil), loaded_path=T.unsafe(nil)); end
+
+  def internal?(); end
+
+  def key?(*args, &block); end
+
+  def keys(*args, &block); end
+
+  def loaded_path(); end
+
+  def make_excludes_absolute(); end
+
+  def map(*args, &block); end
+
+  def merge(*args, &block); end
+
+  def path_relative_to_config(path); end
+
+  def patterns_to_exclude(); end
+
+  def patterns_to_include(); end
+
+  def possibly_include_hidden?(); end
+
+  def signature(); end
+
+  def smart_loaded_path(); end
+
+  def target_rails_version(); end
+
+  def target_ruby_version(*args, &block); end
+
+  def to_h(*args, &block); end
+
+  def to_hash(*args, &block); end
+
+  def validate(*args, &block); end
+  DEFAULT_RAILS_VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Config
+  extend ::Forwardable
+  def self.create(hash, path); end
+end
+
+class RuboCop::ConfigLoader
+  AUTO_GENERATED_FILE = ::T.let(nil, ::T.untyped)
+  DEFAULT_FILE = ::T.let(nil, ::T.untyped)
+  DOTFILE = ::T.let(nil, ::T.untyped)
+  RUBOCOP_HOME = ::T.let(nil, ::T.untyped)
+  XDG_CONFIG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::ConfigLoader
+  extend ::RuboCop::FileFinder
+  def self.add_excludes_from_files(config, config_file); end
+
+  def self.add_inheritance_from_auto_generated_file(); end
+
+  def self.add_missing_namespaces(path, hash); end
+
+  def self.auto_gen_config(); end
+
+  def self.auto_gen_config=(auto_gen_config); end
+
+  def self.auto_gen_config?(); end
+
+  def self.clear_options(); end
+
+  def self.configuration_file_for(target_dir); end
+
+  def self.configuration_from_file(config_file); end
+
+  def self.debug(); end
+
+  def self.debug=(debug); end
+
+  def self.debug?(); end
+
+  def self.default_configuration(); end
+
+  def self.default_configuration=(default_configuration); end
+
+  def self.ignore_parent_exclusion(); end
+
+  def self.ignore_parent_exclusion=(ignore_parent_exclusion); end
+
+  def self.ignore_parent_exclusion?(); end
+
+  def self.load_file(file); end
+
+  def self.merge(base_hash, derived_hash); end
+
+  def self.merge_with_default(config, config_file, unset_nil: T.unsafe(nil)); end
+
+  def self.options_config(); end
+
+  def self.options_config=(options_config); end
+
+  def self.warn_on_pending_cops(config); end
+end
+
+class RuboCop::ConfigLoaderResolver
+  def merge(base_hash, derived_hash, **opts); end
+
+  def merge_with_default(config, config_file, unset_nil:); end
+
+  def resolve_inheritance(path, hash, file, debug); end
+
+  def resolve_inheritance_from_gems(hash); end
+
+  def resolve_requires(path, hash); end
+end
+
+class RuboCop::ConfigLoaderResolver
+end
+
+class RuboCop::ConfigNotFoundError
+end
+
+class RuboCop::ConfigNotFoundError
+end
+
+class RuboCop::ConfigObsoletion
+  def initialize(config); end
+
+  def reject_obsolete_cops_and_parameters(); end
+  MOVED_COPS = ::T.let(nil, ::T.untyped)
+  OBSOLETE_COPS = ::T.let(nil, ::T.untyped)
+  OBSOLETE_ENFORCED_STYLES = ::T.let(nil, ::T.untyped)
+  OBSOLETE_PARAMETERS = ::T.let(nil, ::T.untyped)
+  REMOVED_COPS = ::T.let(nil, ::T.untyped)
+  REMOVED_COPS_WITH_REASON = ::T.let(nil, ::T.untyped)
+  RENAMED_COPS = ::T.let(nil, ::T.untyped)
+  SPLIT_COPS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::ConfigObsoletion
+end
+
+class RuboCop::ConfigStore
+  def for(file_or_dir); end
+
+  def force_default_config!(); end
+
+  def options_config=(options_config); end
+end
+
+class RuboCop::ConfigStore
+end
+
+class RuboCop::ConfigValidator
+  def for_all_cops(*args, &block); end
+
+  def initialize(config); end
+
+  def smart_loaded_path(*args, &block); end
+
+  def target_ruby_version(); end
+
+  def validate(); end
+
+  def validate_section_presence(name); end
+  COMMON_PARAMS = ::T.let(nil, ::T.untyped)
+  INTERNAL_PARAMS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::ConfigValidator
+  extend ::Forwardable
+end
+
+module RuboCop::Cop
+end
+
+module RuboCop::Cop::Alignment
+  SPACE = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::Cop::Alignment
+end
+
+class RuboCop::Cop::AlignmentCorrector
+end
+
+class RuboCop::Cop::AlignmentCorrector
+  extend ::RuboCop::Cop::RangeHelp
+  extend ::RuboCop::Cop::Alignment
+  def self.align_end(processed_source, node, align_to); end
+
+  def self.correct(processed_source, node, column_delta); end
+
+  def self.processed_source(); end
+end
+
+class RuboCop::Cop::AmbiguousCopName
+  def initialize(name, origin, badges); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::AmbiguousCopName
+end
+
+module RuboCop::Cop::ArrayMinSize
+end
+
+module RuboCop::Cop::ArrayMinSize
+end
+
+module RuboCop::Cop::ArraySyntax
+end
+
+module RuboCop::Cop::ArraySyntax
+end
+
+module RuboCop::Cop::AutocorrectLogic
+  def autocorrect?(); end
+
+  def autocorrect_enabled?(); end
+
+  def autocorrect_requested?(); end
+
+  def correctable?(); end
+
+  def disable_offense(node); end
+
+  def disable_uncorrectable?(); end
+
+  def safe_autocorrect?(); end
+
+  def support_autocorrect?(); end
+end
+
+module RuboCop::Cop::AutocorrectLogic
+end
+
+class RuboCop::Cop::Badge
+  def ==(other); end
+
+  def cop_name(); end
+
+  def department(); end
+
+  def eql?(other); end
+
+  def initialize(department, cop_name); end
+
+  def match?(other); end
+
+  def qualified?(); end
+
+  def with_department(department); end
+end
+
+class RuboCop::Cop::Badge::InvalidBadge
+  def initialize(token); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Badge::InvalidBadge
+end
+
+class RuboCop::Cop::Badge
+  def self.for(class_name); end
+
+  def self.parse(identifier); end
+end
+
+module RuboCop::Cop::Bundler
+end
+
+class RuboCop::Cop::Bundler::DuplicatedGem
+  include ::RuboCop::Cop::RangeHelp
+  def gem_declarations(node0); end
+
+  def investigate(processed_source); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Bundler::DuplicatedGem
+end
+
+class RuboCop::Cop::Bundler::GemComment
+  include ::RuboCop::Cop::DefNode
+  def gem_declaration?(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Bundler::GemComment
+end
+
+class RuboCop::Cop::Bundler::InsecureProtocolSource
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def insecure_protocol_source?(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Bundler::InsecureProtocolSource
+end
+
+class RuboCop::Cop::Bundler::OrderedGems
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::OrderedGemNode
+  def autocorrect(node); end
+
+  def gem_declarations(node0); end
+
+  def investigate(processed_source); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Bundler::OrderedGems
+end
+
+module RuboCop::Cop::Bundler
+end
+
+module RuboCop::Cop::CheckAssignment
+  def on_and_asgn(node); end
+
+  def on_casgn(node); end
+
+  def on_cvasgn(node); end
+
+  def on_gvasgn(node); end
+
+  def on_ivasgn(node); end
+
+  def on_lvasgn(node); end
+
+  def on_masgn(node); end
+
+  def on_op_asgn(node); end
+
+  def on_or_asgn(node); end
+
+  def on_send(node); end
+end
+
+module RuboCop::Cop::CheckAssignment
+  def self.extract_rhs(node); end
+end
+
+module RuboCop::Cop::CheckLineBreakable
+  def extract_breakable_node(node, max); end
+end
+
+module RuboCop::Cop::CheckLineBreakable
+end
+
+module RuboCop::Cop::ClassishLength
+  include ::RuboCop::Cop::CodeLength
+  include ::RuboCop::Cop::ConfigurableMax
+end
+
+module RuboCop::Cop::ClassishLength
+end
+
+module RuboCop::Cop::CodeLength
+  include ::RuboCop::Cop::ConfigurableMax
+end
+
+module RuboCop::Cop::CodeLength
+end
+
+class RuboCop::Cop::Commissioner
+  include ::RuboCop::AST::Traversal
+  def errors(); end
+
+  def initialize(cops, forces=T.unsafe(nil), options=T.unsafe(nil)); end
+
+  def investigate(processed_source); end
+end
+
+class RuboCop::Cop::Commissioner
+end
+
+class RuboCop::Cop::ConditionCorrector
+end
+
+class RuboCop::Cop::ConditionCorrector
+  def self.correct_negative_condition(node); end
+end
+
+module RuboCop::Cop::ConfigurableEnforcedStyle
+  def alternative_style(); end
+
+  def alternative_styles(); end
+
+  def ambiguous_style_detected(*possibilities); end
+
+  def conflicting_styles_detected(); end
+
+  def correct_style_detected(); end
+
+  def detected_style(); end
+
+  def detected_style=(style); end
+
+  def no_acceptable_style!(); end
+
+  def no_acceptable_style?(); end
+
+  def opposite_style_detected(); end
+
+  def style(); end
+
+  def style_configured?(); end
+
+  def style_detected(detected); end
+
+  def style_parameter_name(); end
+
+  def supported_styles(); end
+
+  def unexpected_style_detected(unexpected); end
+
+  def unrecognized_style_detected(); end
+end
+
+module RuboCop::Cop::ConfigurableEnforcedStyle
+end
+
+module RuboCop::Cop::ConfigurableFormatting
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def check_name(node, name, name_range); end
+
+  def class_emitter_method?(node, name); end
+
+  def report_opposing_styles(node, name); end
+
+  def valid_name?(node, name, given_style=T.unsafe(nil)); end
+end
+
+module RuboCop::Cop::ConfigurableFormatting
+end
+
+module RuboCop::Cop::ConfigurableMax
+end
+
+module RuboCop::Cop::ConfigurableMax
+end
+
+module RuboCop::Cop::ConfigurableNaming
+  include ::RuboCop::Cop::ConfigurableFormatting
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  FORMATS = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::Cop::ConfigurableNaming
+end
+
+module RuboCop::Cop::ConfigurableNumbering
+  include ::RuboCop::Cop::ConfigurableFormatting
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  FORMATS = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::Cop::ConfigurableNumbering
+end
+
+class RuboCop::Cop::Cop
+  include ::RuboCop::AST::Sexp
+  include ::RuboCop::Cop::Util
+  include ::RuboCop::PathUtil
+  include ::RuboCop::Cop::IgnoredNode
+  include ::RuboCop::Cop::AutocorrectLogic
+  def add_offense(node, location: T.unsafe(nil), message: T.unsafe(nil), severity: T.unsafe(nil)); end
+
+  def config(); end
+
+  def config_to_allow_offenses(); end
+
+  def config_to_allow_offenses=(hash); end
+
+  def cop_config(); end
+
+  def cop_name(); end
+
+  def correct(node); end
+
+  def corrections(); end
+
+  def disable_uncorrectable(node); end
+
+  def duplicate_location?(location); end
+
+  def excluded_file?(file); end
+
+  def external_dependency_checksum(); end
+
+  def find_location(node, loc); end
+
+  def initialize(config=T.unsafe(nil), options=T.unsafe(nil)); end
+
+  def join_force?(_force_class); end
+
+  def message(_node=T.unsafe(nil)); end
+
+  def name(); end
+
+  def offenses(); end
+
+  def parse(source, path=T.unsafe(nil)); end
+
+  def processed_source(); end
+
+  def processed_source=(processed_source); end
+
+  def reason_to_not_correct(node); end
+
+  def relevant_file?(file); end
+
+  def target_rails_version(); end
+
+  def target_ruby_version(); end
+end
+
+class RuboCop::Cop::Cop::Correction
+  def call(corrector); end
+
+  def cop(); end
+
+  def cop=(_); end
+
+  def lambda=(_); end
+
+  def node(); end
+
+  def node=(_); end
+end
+
+class RuboCop::Cop::Cop::Correction
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+class RuboCop::Cop::Cop
+  extend ::RuboCop::AST::Sexp
+  extend ::RuboCop::NodePattern::Macros
+  def self.all(); end
+
+  def self.autocorrect_incompatible_with(); end
+
+  def self.badge(); end
+
+  def self.cop_name(); end
+
+  def self.department(); end
+
+  def self.inherited(subclass); end
+
+  def self.lint?(); end
+
+  def self.match?(given_names); end
+
+  def self.qualified_cop_name(name, origin); end
+
+  def self.registry(); end
+end
+
+class RuboCop::Cop::Corrector
+  def corrections(); end
+
+  def diagnostics(); end
+
+  def initialize(source_buffer, corrections=T.unsafe(nil)); end
+
+  def insert_after(range, content); end
+
+  def insert_before(range, content); end
+
+  def remove(range); end
+
+  def remove_leading(range, size); end
+
+  def remove_preceding(range, size); end
+
+  def remove_trailing(range, size); end
+
+  def replace(range, content); end
+
+  def rewrite(); end
+end
+
+class RuboCop::Cop::Corrector
+end
+
+module RuboCop::Cop::DefNode
+  def non_public_modifier?(node=T.unsafe(nil)); end
+  NON_PUBLIC_MODIFIERS = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::Cop::DefNode
+  extend ::RuboCop::NodePattern::Macros
+end
+
+module RuboCop::Cop::DocumentationComment
+  include ::RuboCop::Cop::Style::AnnotationComment
+end
+
+module RuboCop::Cop::DocumentationComment
+  extend ::RuboCop::NodePattern::Macros
+end
+
+module RuboCop::Cop::Duplication
+end
+
+module RuboCop::Cop::Duplication
+end
+
+class RuboCop::Cop::EachToForCorrector
+  def call(corrector); end
+
+  def initialize(block_node); end
+  CORRECTION_WITHOUT_ARGUMENTS = ::T.let(nil, ::T.untyped)
+  CORRECTION_WITH_ARGUMENTS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::EachToForCorrector
+  extend ::RuboCop::NodePattern::Macros
+end
+
+class RuboCop::Cop::EmptyLineCorrector
+end
+
+class RuboCop::Cop::EmptyLineCorrector
+  def self.correct(node); end
+
+  def self.insert_before(node); end
+end
+
+module RuboCop::Cop::EmptyParameter
+  def empty_arguments?(node=T.unsafe(nil)); end
+end
+
+module RuboCop::Cop::EmptyParameter
+  extend ::RuboCop::NodePattern::Macros
+end
+
+module RuboCop::Cop::EndKeywordAlignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::Cop::EndKeywordAlignment
+end
+
+module RuboCop::Cop::EnforceSuperclass
+  def on_class(node); end
+
+  def on_send(node); end
+end
+
+module RuboCop::Cop::EnforceSuperclass
+  def self.included(base); end
+end
+
+module RuboCop::Cop::FirstElementLineBreak
+end
+
+module RuboCop::Cop::FirstElementLineBreak
+end
+
+class RuboCop::Cop::ForToEachCorrector
+  def call(corrector); end
+
+  def initialize(for_node); end
+  CORRECTION = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::ForToEachCorrector
+  extend ::RuboCop::NodePattern::Macros
+end
+
+class RuboCop::Cop::Force
+  def cops(); end
+
+  def initialize(cops); end
+
+  def investigate(_processed_source); end
+
+  def name(); end
+
+  def run_hook(method_name, *args); end
+end
+
+class RuboCop::Cop::Force
+  def self.all(); end
+
+  def self.force_name(); end
+
+  def self.inherited(subclass); end
+end
+
+module RuboCop::Cop::FrozenStringLiteral
+  FROZEN_STRING_LITERAL = ::T.let(nil, ::T.untyped)
+  FROZEN_STRING_LITERAL_ENABLED = ::T.let(nil, ::T.untyped)
+  FROZEN_STRING_LITERAL_TYPES = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::Cop::FrozenStringLiteral
+  def self.frozen_string_literal_comment_exists?(); end
+end
+
+module RuboCop::Cop::Gemspec
+end
+
+class RuboCop::Cop::Gemspec::DuplicatedAssignment
+  include ::RuboCop::Cop::RangeHelp
+  def assignment_method_declarations(node0); end
+
+  def gem_specification(node0); end
+
+  def investigate(processed_source); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Gemspec::DuplicatedAssignment
+end
+
+class RuboCop::Cop::Gemspec::OrderedDependencies
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::OrderedGemNode
+  def autocorrect(node); end
+
+  def dependency_declarations(node0); end
+
+  def investigate(processed_source); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Gemspec::OrderedDependencies
+end
+
+class RuboCop::Cop::Gemspec::RequiredRubyVersion
+  def investigate(processed_source); end
+
+  def required_ruby_version(node0); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Gemspec::RequiredRubyVersion
+end
+
+class RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage
+  def gem_specification?(node0); end
+
+  def on_const(node); end
+
+  def ruby_version?(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage
+end
+
+module RuboCop::Cop::Gemspec
+end
+
+class RuboCop::Cop::Generator
+  def initialize(name, github_user, output: T.unsafe(nil)); end
+
+  def inject_config(config_file_path: T.unsafe(nil)); end
+
+  def inject_require(root_file_path: T.unsafe(nil)); end
+
+  def todo(); end
+
+  def write_source(); end
+
+  def write_spec(); end
+  CONFIGURATION_ADDED_MESSAGE = ::T.let(nil, ::T.untyped)
+  SOURCE_TEMPLATE = ::T.let(nil, ::T.untyped)
+  SPEC_TEMPLATE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Generator::ConfigurationInjector
+  def initialize(configuration_file_path:, badge:, version_added:); end
+
+  def inject(); end
+  TEMPLATE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Generator::ConfigurationInjector
+end
+
+class RuboCop::Cop::Generator::RequireFileInjector
+  def initialize(source_path:, root_file_path:, output: T.unsafe(nil)); end
+
+  def inject(); end
+  REQUIRE_PATH = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Generator::RequireFileInjector
+end
+
+class RuboCop::Cop::Generator
+end
+
+module RuboCop::Cop::HashAlignmentStyles
+end
+
+class RuboCop::Cop::HashAlignmentStyles::KeyAlignment
+  def checkable_layout?(_node); end
+
+  def deltas(first_pair, current_pair); end
+
+  def deltas_for_first_pair(first_pair, _node); end
+end
+
+class RuboCop::Cop::HashAlignmentStyles::KeyAlignment
+end
+
+class RuboCop::Cop::HashAlignmentStyles::SeparatorAlignment
+  include ::RuboCop::Cop::HashAlignmentStyles::ValueAlignment
+  def deltas_for_first_pair(*_nodes); end
+end
+
+class RuboCop::Cop::HashAlignmentStyles::SeparatorAlignment
+end
+
+class RuboCop::Cop::HashAlignmentStyles::TableAlignment
+  include ::RuboCop::Cop::HashAlignmentStyles::ValueAlignment
+  def deltas_for_first_pair(first_pair, node); end
+end
+
+class RuboCop::Cop::HashAlignmentStyles::TableAlignment
+end
+
+module RuboCop::Cop::HashAlignmentStyles::ValueAlignment
+  def checkable_layout?(node); end
+
+  def deltas(first_pair, current_pair); end
+end
+
+module RuboCop::Cop::HashAlignmentStyles::ValueAlignment
+end
+
+module RuboCop::Cop::HashAlignmentStyles
+end
+
+module RuboCop::Cop::HashTransformMethod
+  def autocorrect(node); end
+
+  def on_block(node); end
+
+  def on_csend(node); end
+
+  def on_send(node); end
+end
+
+class RuboCop::Cop::HashTransformMethod::Autocorrection
+  def block_node(); end
+
+  def block_node=(_); end
+
+  def leading(); end
+
+  def leading=(_); end
+
+  def match(); end
+
+  def match=(_); end
+
+  def set_new_arg_name(transformed_argname, corrector); end
+
+  def set_new_body_expression(transforming_body_expr, corrector); end
+
+  def set_new_method_name(new_method_name, corrector); end
+
+  def strip_prefix_and_suffix(node, corrector); end
+
+  def trailing(); end
+
+  def trailing=(_); end
+end
+
+class RuboCop::Cop::HashTransformMethod::Autocorrection
+  def self.[](*_); end
+
+  def self.from_each_with_object(node, match); end
+
+  def self.from_hash_brackets_map(node, match); end
+
+  def self.from_map_to_h(node, match); end
+
+  def self.members(); end
+end
+
+class RuboCop::Cop::HashTransformMethod::Captures
+  def noop_transformation?(); end
+
+  def transformation_uses_both_args?(); end
+
+  def transformed_argname(); end
+
+  def transformed_argname=(_); end
+
+  def transforming_body_expr(); end
+
+  def transforming_body_expr=(_); end
+
+  def unchanged_body_expr(); end
+
+  def unchanged_body_expr=(_); end
+end
+
+class RuboCop::Cop::HashTransformMethod::Captures
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+module RuboCop::Cop::HashTransformMethod
+end
+
+module RuboCop::Cop::Heredoc
+  def on_dstr(node); end
+
+  def on_heredoc(_node); end
+
+  def on_str(node); end
+
+  def on_xstr(node); end
+  OPENING_DELIMITER = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::Cop::Heredoc
+end
+
+module RuboCop::Cop::IgnoredMethods
+end
+
+module RuboCop::Cop::IgnoredMethods
+end
+
+module RuboCop::Cop::IgnoredNode
+  def ignore_node(node); end
+
+  def ignored_node?(node); end
+
+  def part_of_ignored_node?(node); end
+end
+
+module RuboCop::Cop::IgnoredNode
+end
+
+module RuboCop::Cop::IgnoredPattern
+end
+
+module RuboCop::Cop::IgnoredPattern
+end
+
+module RuboCop::Cop::IntegerNode
+end
+
+module RuboCop::Cop::IntegerNode
+end
+
+module RuboCop::Cop::Interpolation
+  def on_dstr(node); end
+
+  def on_dsym(node); end
+
+  def on_node_with_interpolations(node); end
+
+  def on_regexp(node); end
+
+  def on_xstr(node); end
+end
+
+module RuboCop::Cop::Interpolation
+end
+
+class RuboCop::Cop::LambdaLiteralToMethodCorrector
+  def call(corrector); end
+
+  def initialize(block_node); end
+end
+
+class RuboCop::Cop::LambdaLiteralToMethodCorrector
+end
+
+module RuboCop::Cop::Layout
+end
+
+class RuboCop::Cop::Layout::AccessModifierIndentation
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_block(node); end
+
+  def on_class(node); end
+
+  def on_module(node); end
+
+  def on_sclass(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::AccessModifierIndentation
+end
+
+class RuboCop::Cop::Layout::ArgumentAlignment
+  include ::RuboCop::Cop::Alignment
+  def autocorrect(node); end
+
+  def on_csend(node); end
+
+  def on_send(node); end
+  ALIGN_PARAMS_MSG = ::T.let(nil, ::T.untyped)
+  FIXED_INDENT_MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::ArgumentAlignment
+end
+
+class RuboCop::Cop::Layout::ArrayAlignment
+  include ::RuboCop::Cop::Alignment
+  def autocorrect(node); end
+
+  def on_array(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::ArrayAlignment
+end
+
+class RuboCop::Cop::Layout::AssignmentIndentation
+  include ::RuboCop::Cop::CheckAssignment
+  include ::RuboCop::Cop::Alignment
+  def autocorrect(node); end
+
+  def check_assignment(node, rhs); end
+
+  def leftmost_multiple_assignment(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::AssignmentIndentation
+end
+
+class RuboCop::Cop::Layout::BlockAlignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def block_end_align_target?(node=T.unsafe(nil), param1); end
+
+  def on_block(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::BlockAlignment
+end
+
+class RuboCop::Cop::Layout::BlockEndNewline
+  include ::RuboCop::Cop::Alignment
+  def autocorrect(node); end
+
+  def on_block(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::BlockEndNewline
+end
+
+class RuboCop::Cop::Layout::CaseIndentation
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_case(case_node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::CaseIndentation
+end
+
+class RuboCop::Cop::Layout::ClassStructure
+  def autocorrect(node); end
+
+  def on_class(class_node); end
+
+  def visibility_block?(node=T.unsafe(nil)); end
+  HUMANIZED_NODE_TYPE = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+  VISIBILITY_SCOPES = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::ClassStructure
+end
+
+class RuboCop::Cop::Layout::ClosingHeredocIndentation
+  include ::RuboCop::Cop::Heredoc
+  def autocorrect(node); end
+
+  def on_heredoc(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+  MSG_ARG = ::T.let(nil, ::T.untyped)
+  SIMPLE_HEREDOC = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::ClosingHeredocIndentation
+end
+
+class RuboCop::Cop::Layout::ClosingParenthesisIndentation
+  include ::RuboCop::Cop::Alignment
+  def autocorrect(node); end
+
+  def on_begin(node); end
+
+  def on_csend(node); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+
+  def on_send(node); end
+  MSG_ALIGN = ::T.let(nil, ::T.untyped)
+  MSG_INDENT = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::ClosingParenthesisIndentation
+end
+
+class RuboCop::Cop::Layout::CommentIndentation
+  include ::RuboCop::Cop::Alignment
+  def autocorrect(comment); end
+
+  def investigate(processed_source); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::CommentIndentation
+end
+
+class RuboCop::Cop::Layout::ConditionPosition
+  def on_if(node); end
+
+  def on_until(node); end
+
+  def on_while(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::ConditionPosition
+end
+
+class RuboCop::Cop::Layout::DefEndAlignment
+  include ::RuboCop::Cop::EndKeywordAlignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::DefEndAlignment
+end
+
+class RuboCop::Cop::Layout::DotPosition
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def on_csend(node); end
+
+  def on_send(node); end
+end
+
+class RuboCop::Cop::Layout::DotPosition
+end
+
+class RuboCop::Cop::Layout::ElseAlignment
+  include ::RuboCop::Cop::EndKeywordAlignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::CheckAssignment
+  def autocorrect(node); end
+
+  def on_case(node); end
+
+  def on_if(node, base=T.unsafe(nil)); end
+
+  def on_rescue(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::ElseAlignment
+end
+
+class RuboCop::Cop::Layout::EmptyComment
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def investigate(processed_source); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::EmptyComment
+end
+
+class RuboCop::Cop::Layout::EmptyLineAfterGuardClause
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_if(node); end
+  END_OF_HEREDOC_LINE = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::EmptyLineAfterGuardClause
+end
+
+class RuboCop::Cop::Layout::EmptyLineAfterMagicComment
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(token); end
+
+  def investigate(source); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::EmptyLineAfterMagicComment
+end
+
+class RuboCop::Cop::Layout::EmptyLineBetweenDefs
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def check_defs(nodes); end
+
+  def on_begin(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::EmptyLineBetweenDefs
+end
+
+class RuboCop::Cop::Layout::EmptyLines
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(range); end
+
+  def investigate(processed_source); end
+  LINE_OFFSET = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::EmptyLines
+end
+
+class RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_block(node); end
+
+  def on_class(node); end
+
+  def on_module(node); end
+
+  def on_sclass(node); end
+
+  def on_send(node); end
+  MSG_AFTER = ::T.let(nil, ::T.untyped)
+  MSG_AFTER_FOR_ONLY_BEFORE = ::T.let(nil, ::T.untyped)
+  MSG_BEFORE_AND_AFTER = ::T.let(nil, ::T.untyped)
+  MSG_BEFORE_FOR_ONLY_BEFORE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier
+end
+
+class RuboCop::Cop::Layout::EmptyLinesAroundArguments
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_csend(node); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::EmptyLinesAroundArguments
+end
+
+class RuboCop::Cop::Layout::EmptyLinesAroundBeginBody
+  include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_kwbegin(node); end
+  KIND = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::EmptyLinesAroundBeginBody
+end
+
+class RuboCop::Cop::Layout::EmptyLinesAroundBlockBody
+  include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_block(node); end
+  KIND = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::EmptyLinesAroundBlockBody
+end
+
+module RuboCop::Cop::Layout::EmptyLinesAroundBody
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def constant_definition?(node=T.unsafe(nil)); end
+
+  def empty_line_required?(node=T.unsafe(nil)); end
+  MSG_DEFERRED = ::T.let(nil, ::T.untyped)
+  MSG_EXTRA = ::T.let(nil, ::T.untyped)
+  MSG_MISSING = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::Cop::Layout::EmptyLinesAroundBody
+  extend ::RuboCop::NodePattern::Macros
+end
+
+class RuboCop::Cop::Layout::EmptyLinesAroundClassBody
+  include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_class(node); end
+
+  def on_sclass(node); end
+  KIND = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::EmptyLinesAroundClassBody
+end
+
+class RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords
+  include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+
+  def on_kwbegin(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords
+end
+
+class RuboCop::Cop::Layout::EmptyLinesAroundMethodBody
+  include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+  KIND = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::EmptyLinesAroundMethodBody
+end
+
+class RuboCop::Cop::Layout::EmptyLinesAroundModuleBody
+  include ::RuboCop::Cop::Layout::EmptyLinesAroundBody
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_module(node); end
+  KIND = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::EmptyLinesAroundModuleBody
+end
+
+class RuboCop::Cop::Layout::EndAlignment
+  include ::RuboCop::Cop::CheckAssignment
+  include ::RuboCop::Cop::EndKeywordAlignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_case(node); end
+
+  def on_class(node); end
+
+  def on_if(node); end
+
+  def on_module(node); end
+
+  def on_until(node); end
+
+  def on_while(node); end
+end
+
+class RuboCop::Cop::Layout::EndAlignment
+end
+
+class RuboCop::Cop::Layout::EndOfLine
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def investigate(processed_source); end
+
+  def offense_message(line); end
+
+  def unimportant_missing_cr?(index, last_line, line); end
+  MSG_DETECTED = ::T.let(nil, ::T.untyped)
+  MSG_MISSING = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::EndOfLine
+end
+
+class RuboCop::Cop::Layout::ExtraSpacing
+  include ::RuboCop::Cop::PrecedingFollowingAlignment
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(range); end
+
+  def investigate(processed_source); end
+  MSG_UNALIGNED_ASGN = ::T.let(nil, ::T.untyped)
+  MSG_UNNECESSARY = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::ExtraSpacing
+end
+
+class RuboCop::Cop::Layout::FirstArgumentIndentation
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def eligible_method_call?(node=T.unsafe(nil)); end
+
+  def on_csend(node); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::FirstArgumentIndentation
+end
+
+class RuboCop::Cop::Layout::FirstArrayElementIndentation
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::MultilineElementIndentation
+  def autocorrect(node); end
+
+  def on_array(node); end
+
+  def on_csend(node); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::FirstArrayElementIndentation
+end
+
+class RuboCop::Cop::Layout::FirstArrayElementLineBreak
+  include ::RuboCop::Cop::FirstElementLineBreak
+  def autocorrect(node); end
+
+  def on_array(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::FirstArrayElementLineBreak
+end
+
+class RuboCop::Cop::Layout::FirstHashElementIndentation
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::MultilineElementIndentation
+  def autocorrect(node); end
+
+  def on_csend(node); end
+
+  def on_hash(node); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::FirstHashElementIndentation
+end
+
+class RuboCop::Cop::Layout::FirstHashElementLineBreak
+  include ::RuboCop::Cop::FirstElementLineBreak
+  def autocorrect(node); end
+
+  def on_hash(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::FirstHashElementLineBreak
+end
+
+class RuboCop::Cop::Layout::FirstMethodArgumentLineBreak
+  include ::RuboCop::Cop::FirstElementLineBreak
+  def autocorrect(node); end
+
+  def on_csend(node); end
+
+  def on_send(node); end
+
+  def on_super(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::FirstMethodArgumentLineBreak
+end
+
+class RuboCop::Cop::Layout::FirstMethodParameterLineBreak
+  include ::RuboCop::Cop::FirstElementLineBreak
+  def autocorrect(node); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::FirstMethodParameterLineBreak
+end
+
+class RuboCop::Cop::Layout::FirstParameterIndentation
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::MultilineElementIndentation
+  def autocorrect(node); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::FirstParameterIndentation
+end
+
+class RuboCop::Cop::Layout::HashAlignment
+  include ::RuboCop::Cop::HashAlignmentStyles
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def column_deltas(); end
+
+  def column_deltas=(column_deltas); end
+
+  def offences_by(); end
+
+  def offences_by=(offences_by); end
+
+  def on_hash(node); end
+
+  def on_send(node); end
+
+  def on_super(node); end
+
+  def on_yield(node); end
+  MESSAGES = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::HashAlignment
+end
+
+class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis
+end
+
+class RuboCop::Cop::Layout::HeredocIndentation
+  include ::RuboCop::Cop::Heredoc
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def on_heredoc(node); end
+  LIBRARY_MSG = ::T.let(nil, ::T.untyped)
+  RUBY23_TYPE_MSG = ::T.let(nil, ::T.untyped)
+  RUBY23_WIDTH_MSG = ::T.let(nil, ::T.untyped)
+  STRIP_METHODS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::HeredocIndentation
+end
+
+class RuboCop::Cop::Layout::IndentationConsistency
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def on_begin(node); end
+
+  def on_kwbegin(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::IndentationConsistency
+end
+
+class RuboCop::Cop::Layout::IndentationWidth
+  include ::RuboCop::Cop::EndKeywordAlignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::CheckAssignment
+  include ::RuboCop::Cop::IgnoredPattern
+  def access_modifier?(node=T.unsafe(nil)); end
+
+  def autocorrect(node); end
+
+  def on_block(node); end
+
+  def on_case(case_node); end
+
+  def on_class(node); end
+
+  def on_csend(node); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+
+  def on_ensure(node); end
+
+  def on_for(node); end
+
+  def on_if(node, base=T.unsafe(nil)); end
+
+  def on_kwbegin(node); end
+
+  def on_module(node); end
+
+  def on_resbody(node); end
+
+  def on_rescue(node); end
+
+  def on_sclass(node); end
+
+  def on_until(node, base=T.unsafe(nil)); end
+
+  def on_while(node, base=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::IndentationWidth
+end
+
+class RuboCop::Cop::Layout::InitialIndentation
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(range); end
+
+  def investigate(_processed_source); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::InitialIndentation
+end
+
+class RuboCop::Cop::Layout::LeadingCommentSpace
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(comment); end
+
+  def investigate(processed_source); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::LeadingCommentSpace
+end
+
+class RuboCop::Cop::Layout::LeadingEmptyLines
+  def autocorrect(node); end
+
+  def investigate(processed_source); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::LeadingEmptyLines
+end
+
+class RuboCop::Cop::Layout::LineLength
+  include ::RuboCop::Cop::CheckLineBreakable
+  include ::RuboCop::Cop::ConfigurableMax
+  include ::RuboCop::Cop::IgnoredPattern
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::LineLengthHelp
+  def autocorrect(range); end
+
+  def investigate(processed_source); end
+
+  def investigate_post_walk(processed_source); end
+
+  def on_array(node); end
+
+  def on_block(node); end
+
+  def on_hash(node); end
+
+  def on_potential_breakable_node(node); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::LineLength
+end
+
+class RuboCop::Cop::Layout::MultilineArrayBraceLayout
+  include ::RuboCop::Cop::MultilineLiteralBraceLayout
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def on_array(node); end
+  ALWAYS_NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
+  ALWAYS_SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
+  NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
+  SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::MultilineArrayBraceLayout
+end
+
+class RuboCop::Cop::Layout::MultilineArrayLineBreaks
+  include ::RuboCop::Cop::MultilineElementLineBreaks
+  def autocorrect(node); end
+
+  def on_array(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::MultilineArrayLineBreaks
+end
+
+class RuboCop::Cop::Layout::MultilineAssignmentLayout
+  include ::RuboCop::Cop::CheckAssignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def check_assignment(node, rhs); end
+
+  def check_by_enforced_style(node, rhs); end
+
+  def check_new_line_offense(node, rhs); end
+
+  def check_same_line_offense(node, rhs); end
+  NEW_LINE_OFFENSE = ::T.let(nil, ::T.untyped)
+  SAME_LINE_OFFENSE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::MultilineAssignmentLayout
+end
+
+class RuboCop::Cop::Layout::MultilineBlockLayout
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_block(node); end
+  ARG_MSG = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+  PIPE_SIZE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::MultilineBlockLayout
+end
+
+class RuboCop::Cop::Layout::MultilineHashBraceLayout
+  include ::RuboCop::Cop::MultilineLiteralBraceLayout
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def on_hash(node); end
+  ALWAYS_NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
+  ALWAYS_SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
+  NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
+  SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::MultilineHashBraceLayout
+end
+
+class RuboCop::Cop::Layout::MultilineHashKeyLineBreaks
+  include ::RuboCop::Cop::MultilineElementLineBreaks
+  def autocorrect(node); end
+
+  def on_hash(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::MultilineHashKeyLineBreaks
+end
+
+class RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks
+  include ::RuboCop::Cop::MultilineElementLineBreaks
+  def autocorrect(node); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks
+end
+
+class RuboCop::Cop::Layout::MultilineMethodCallBraceLayout
+  include ::RuboCop::Cop::MultilineLiteralBraceLayout
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def on_send(node); end
+  ALWAYS_NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
+  ALWAYS_SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
+  NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
+  SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::MultilineMethodCallBraceLayout
+end
+
+class RuboCop::Cop::Layout::MultilineMethodCallIndentation
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::MultilineExpressionIndentation
+  def autocorrect(node); end
+
+  def validate_config(); end
+end
+
+class RuboCop::Cop::Layout::MultilineMethodCallIndentation
+end
+
+class RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout
+  include ::RuboCop::Cop::MultilineLiteralBraceLayout
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+  ALWAYS_NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
+  ALWAYS_SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
+  NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
+  SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout
+end
+
+class RuboCop::Cop::Layout::MultilineOperationIndentation
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::MultilineExpressionIndentation
+  def autocorrect(node); end
+
+  def on_and(node); end
+
+  def on_or(node); end
+
+  def validate_config(); end
+end
+
+class RuboCop::Cop::Layout::MultilineOperationIndentation
+end
+
+class RuboCop::Cop::Layout::ParameterAlignment
+  include ::RuboCop::Cop::Alignment
+  def autocorrect(node); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+  ALIGN_PARAMS_MSG = ::T.let(nil, ::T.untyped)
+  FIXED_INDENT_MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::ParameterAlignment
+end
+
+class RuboCop::Cop::Layout::RescueEnsureAlignment
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def investigate(processed_source); end
+
+  def on_ensure(node); end
+
+  def on_resbody(node); end
+  ALTERNATIVE_ACCESS_MODIFIERS = ::T.let(nil, ::T.untyped)
+  ANCESTOR_TYPES = ::T.let(nil, ::T.untyped)
+  ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+  RUBY_2_5_ANCESTOR_TYPES = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::RescueEnsureAlignment
+end
+
+class RuboCop::Cop::Layout::SpaceAfterColon
+  def autocorrect(range); end
+
+  def on_kwoptarg(node); end
+
+  def on_pair(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::SpaceAfterColon
+end
+
+class RuboCop::Cop::Layout::SpaceAfterComma
+  include ::RuboCop::Cop::SpaceAfterPunctuation
+  def autocorrect(comma); end
+
+  def kind(token); end
+
+  def space_style_before_rcurly(); end
+end
+
+class RuboCop::Cop::Layout::SpaceAfterComma
+end
+
+class RuboCop::Cop::Layout::SpaceAfterMethodName
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(pos_before_left_paren); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::SpaceAfterMethodName
+end
+
+class RuboCop::Cop::Layout::SpaceAfterNot
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_send(node); end
+
+  def whitespace_after_operator?(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::SpaceAfterNot
+end
+
+class RuboCop::Cop::Layout::SpaceAfterSemicolon
+  include ::RuboCop::Cop::SpaceAfterPunctuation
+  def autocorrect(semicolon); end
+
+  def kind(token); end
+
+  def space_style_before_rcurly(); end
+end
+
+class RuboCop::Cop::Layout::SpaceAfterSemicolon
+end
+
+class RuboCop::Cop::Layout::SpaceAroundBlockParameters
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(target); end
+
+  def on_block(node); end
+end
+
+class RuboCop::Cop::Layout::SpaceAroundBlockParameters
+end
+
+class RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault
+  include ::RuboCop::Cop::SurroundingSpace
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(range); end
+
+  def on_optarg(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault
+end
+
+class RuboCop::Cop::Layout::SpaceAroundKeyword
+  def autocorrect(range); end
+
+  def on_and(node); end
+
+  def on_block(node); end
+
+  def on_break(node); end
+
+  def on_case(node); end
+
+  def on_defined?(node); end
+
+  def on_ensure(node); end
+
+  def on_for(node); end
+
+  def on_if(node); end
+
+  def on_kwbegin(node); end
+
+  def on_next(node); end
+
+  def on_or(node); end
+
+  def on_postexe(node); end
+
+  def on_preexe(node); end
+
+  def on_resbody(node); end
+
+  def on_rescue(node); end
+
+  def on_return(node); end
+
+  def on_send(node); end
+
+  def on_super(node); end
+
+  def on_until(node); end
+
+  def on_when(node); end
+
+  def on_while(node); end
+
+  def on_yield(node); end
+
+  def on_zsuper(node); end
+  ACCEPT_LEFT_PAREN = ::T.let(nil, ::T.untyped)
+  ACCEPT_LEFT_SQUARE_BRACKET = ::T.let(nil, ::T.untyped)
+  ACCEPT_NAMESPACE_OPERATOR = ::T.let(nil, ::T.untyped)
+  DO = ::T.let(nil, ::T.untyped)
+  MSG_AFTER = ::T.let(nil, ::T.untyped)
+  MSG_BEFORE = ::T.let(nil, ::T.untyped)
+  NAMESPACE_OPERATOR = ::T.let(nil, ::T.untyped)
+  SAFE_NAVIGATION = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::SpaceAroundKeyword
+end
+
+class RuboCop::Cop::Layout::SpaceAroundOperators
+  include ::RuboCop::Cop::PrecedingFollowingAlignment
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::RationalLiteral
+  def autocorrect(range); end
+
+  def on_and(node); end
+
+  def on_and_asgn(node); end
+
+  def on_assignment(node); end
+
+  def on_binary(node); end
+
+  def on_casgn(node); end
+
+  def on_class(node); end
+
+  def on_cvasgn(node); end
+
+  def on_gvasgn(node); end
+
+  def on_if(node); end
+
+  def on_ivasgn(node); end
+
+  def on_lvasgn(node); end
+
+  def on_masgn(node); end
+
+  def on_op_asgn(node); end
+
+  def on_or(node); end
+
+  def on_or_asgn(node); end
+
+  def on_pair(node); end
+
+  def on_resbody(node); end
+
+  def on_send(node); end
+
+  def on_special_asgn(node); end
+  EXCESSIVE_SPACE = ::T.let(nil, ::T.untyped)
+  IRREGULAR_METHODS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::SpaceAroundOperators
+end
+
+class RuboCop::Cop::Layout::SpaceBeforeBlockBraces
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(range); end
+
+  def on_block(node); end
+  DETECTED_MSG = ::T.let(nil, ::T.untyped)
+  MISSING_MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::SpaceBeforeBlockBraces
+end
+
+class RuboCop::Cop::Layout::SpaceBeforeComma
+  include ::RuboCop::Cop::SpaceBeforePunctuation
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(space); end
+
+  def kind(token); end
+end
+
+class RuboCop::Cop::Layout::SpaceBeforeComma
+end
+
+class RuboCop::Cop::Layout::SpaceBeforeComment
+  def autocorrect(range); end
+
+  def investigate(processed_source); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::SpaceBeforeComment
+end
+
+class RuboCop::Cop::Layout::SpaceBeforeFirstArg
+  include ::RuboCop::Cop::PrecedingFollowingAlignment
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(range); end
+
+  def on_csend(node); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::SpaceBeforeFirstArg
+end
+
+class RuboCop::Cop::Layout::SpaceBeforeSemicolon
+  include ::RuboCop::Cop::SpaceBeforePunctuation
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(space); end
+
+  def kind(token); end
+end
+
+class RuboCop::Cop::Layout::SpaceBeforeSemicolon
+end
+
+class RuboCop::Cop::Layout::SpaceInLambdaLiteral
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(lambda_node); end
+
+  def on_send(node); end
+  MSG_REQUIRE_NO_SPACE = ::T.let(nil, ::T.untyped)
+  MSG_REQUIRE_SPACE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::SpaceInLambdaLiteral
+end
+
+class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets
+  include ::RuboCop::Cop::SurroundingSpace
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def on_array(node); end
+  EMPTY_MSG = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets
+end
+
+class RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral
+  include ::RuboCop::Cop::MatchRange
+  include ::RuboCop::Cop::PercentLiteral
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_array(node); end
+
+  def on_percent_literal(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+  MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral
+end
+
+class RuboCop::Cop::Layout::SpaceInsideBlockBraces
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::SurroundingSpace
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(range); end
+
+  def on_block(node); end
+end
+
+class RuboCop::Cop::Layout::SpaceInsideBlockBraces
+end
+
+class RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces
+  include ::RuboCop::Cop::SurroundingSpace
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(range); end
+
+  def on_hash(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces
+end
+
+class RuboCop::Cop::Layout::SpaceInsideParens
+  include ::RuboCop::Cop::SurroundingSpace
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(range); end
+
+  def investigate(processed_source); end
+  MSG = ::T.let(nil, ::T.untyped)
+  MSG_SPACE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::SpaceInsideParens
+end
+
+class RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters
+  include ::RuboCop::Cop::MatchRange
+  include ::RuboCop::Cop::PercentLiteral
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_array(node); end
+
+  def on_percent_literal(node); end
+
+  def on_xstr(node); end
+  BEGIN_REGEX = ::T.let(nil, ::T.untyped)
+  END_REGEX = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters
+end
+
+class RuboCop::Cop::Layout::SpaceInsideRangeLiteral
+  def autocorrect(node); end
+
+  def on_erange(node); end
+
+  def on_irange(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::SpaceInsideRangeLiteral
+end
+
+class RuboCop::Cop::Layout::SpaceInsideReferenceBrackets
+  include ::RuboCop::Cop::SurroundingSpace
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def on_send(node); end
+  BRACKET_METHODS = ::T.let(nil, ::T.untyped)
+  EMPTY_MSG = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::SpaceInsideReferenceBrackets
+end
+
+class RuboCop::Cop::Layout::SpaceInsideStringInterpolation
+  include ::RuboCop::Cop::Interpolation
+  include ::RuboCop::Cop::SurroundingSpace
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(begin_node); end
+
+  def on_interpolation(begin_node); end
+  NO_SPACE_MSG = ::T.let(nil, ::T.untyped)
+  SPACE_MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::SpaceInsideStringInterpolation
+end
+
+class RuboCop::Cop::Layout::Tab
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(range); end
+
+  def investigate(processed_source); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::Tab
+end
+
+class RuboCop::Cop::Layout::TrailingEmptyLines
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(range); end
+
+  def investigate(processed_source); end
+end
+
+class RuboCop::Cop::Layout::TrailingEmptyLines
+end
+
+class RuboCop::Cop::Layout::TrailingWhitespace
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(range); end
+
+  def investigate(processed_source); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Layout::TrailingWhitespace
+end
+
+module RuboCop::Cop::Layout
+end
+
+class RuboCop::Cop::LineBreakCorrector
+end
+
+class RuboCop::Cop::LineBreakCorrector
+  extend ::RuboCop::Cop::Alignment
+  extend ::RuboCop::Cop::TrailingBody
+  extend ::RuboCop::Cop::Util
+  extend ::RuboCop::PathUtil
+  def self.break_line_before(range:, node:, corrector:, configured_width:, indent_steps: T.unsafe(nil)); end
+
+  def self.correct_trailing_body(configured_width:, corrector:, node:, processed_source:); end
+
+  def self.move_comment(eol_comment:, node:, corrector:); end
+
+  def self.processed_source(); end
+end
+
+module RuboCop::Cop::LineLengthHelp
+end
+
+module RuboCop::Cop::LineLengthHelp
+end
+
+module RuboCop::Cop::Lint
+end
+
+class RuboCop::Cop::Lint::AmbiguousBlockAssociation
+  def on_csend(node); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::AmbiguousBlockAssociation
+end
+
+class RuboCop::Cop::Lint::AmbiguousOperator
+  include ::RuboCop::Cop::ParserDiagnostic
+  AMBIGUITIES = ::T.let(nil, ::T.untyped)
+  MSG_FORMAT = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::AmbiguousOperator
+end
+
+class RuboCop::Cop::Lint::AmbiguousRegexpLiteral
+  include ::RuboCop::Cop::ParserDiagnostic
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::AmbiguousRegexpLiteral
+end
+
+class RuboCop::Cop::Lint::AssignmentInCondition
+  include ::RuboCop::Cop::SafeAssignment
+  def on_if(node); end
+
+  def on_until(node); end
+
+  def on_while(node); end
+  ASGN_TYPES = ::T.let(nil, ::T.untyped)
+  MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED = ::T.let(nil, ::T.untyped)
+  MSG_WITH_SAFE_ASSIGNMENT_ALLOWED = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::AssignmentInCondition
+end
+
+class RuboCop::Cop::Lint::BigDecimalNew
+  def autocorrect(node); end
+
+  def big_decimal_new(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::BigDecimalNew
+end
+
+class RuboCop::Cop::Lint::BooleanSymbol
+  def boolean_symbol?(node=T.unsafe(nil)); end
+
+  def on_sym(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::BooleanSymbol
+end
+
+class RuboCop::Cop::Lint::CircularArgumentReference
+  def on_kwoptarg(node); end
+
+  def on_optarg(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::CircularArgumentReference
+end
+
+class RuboCop::Cop::Lint::Debugger
+  def binding_irb_call?(node=T.unsafe(nil)); end
+
+  def debugger_call?(node=T.unsafe(nil)); end
+
+  def kernel?(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::Debugger
+end
+
+class RuboCop::Cop::Lint::DeprecatedClassMethods
+  def autocorrect(node); end
+
+  def on_send(node); end
+  DEPRECATED_METHODS_OBJECT = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::DeprecatedClassMethods::DeprecatedClassMethod
+  include ::RuboCop::AST::Sexp
+  def class_constant(); end
+
+  def class_nodes(); end
+
+  def deprecated_method(); end
+
+  def initialize(deprecated:, replacement:, class_constant: T.unsafe(nil)); end
+
+  def replacement_method(); end
+end
+
+class RuboCop::Cop::Lint::DeprecatedClassMethods::DeprecatedClassMethod
+end
+
+class RuboCop::Cop::Lint::DeprecatedClassMethods
+end
+
+class RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor
+  def on_def(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor
+end
+
+class RuboCop::Cop::Lint::DuplicateCaseCondition
+  def on_case(case_node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::DuplicateCaseCondition
+end
+
+class RuboCop::Cop::Lint::DuplicateHashKey
+  include ::RuboCop::Cop::Duplication
+  def on_hash(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::DuplicateHashKey
+end
+
+class RuboCop::Cop::Lint::DuplicateMethods
+  def alias_method?(node=T.unsafe(nil)); end
+
+  def attr?(node=T.unsafe(nil)); end
+
+  def method_alias?(node=T.unsafe(nil)); end
+
+  def on_alias(node); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+
+  def on_send(node); end
+
+  def sym_name(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::DuplicateMethods
+end
+
+class RuboCop::Cop::Lint::EachWithObjectArgument
+  def each_with_object?(node=T.unsafe(nil)); end
+
+  def on_csend(node); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::EachWithObjectArgument
+end
+
+class RuboCop::Cop::Lint::ElseLayout
+  def on_if(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::ElseLayout
+end
+
+class RuboCop::Cop::Lint::EmptyEnsure
+  def autocorrect(node); end
+
+  def on_ensure(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::EmptyEnsure
+end
+
+class RuboCop::Cop::Lint::EmptyExpression
+  def on_begin(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::EmptyExpression
+end
+
+class RuboCop::Cop::Lint::EmptyInterpolation
+  include ::RuboCop::Cop::Interpolation
+  def autocorrect(node); end
+
+  def on_interpolation(begin_node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::EmptyInterpolation
+end
+
+class RuboCop::Cop::Lint::EmptyWhen
+  def on_case(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::EmptyWhen
+end
+
+class RuboCop::Cop::Lint::EndInMethod
+  def on_postexe(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::EndInMethod
+end
+
+class RuboCop::Cop::Lint::EnsureReturn
+  def on_ensure(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::EnsureReturn
+end
+
+class RuboCop::Cop::Lint::ErbNewArguments
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def erb_new_with_non_keyword_arguments(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+  MESSAGES = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::ErbNewArguments
+  extend ::RuboCop::Cop::TargetRubyVersion
+end
+
+class RuboCop::Cop::Lint::FlipFlop
+  def on_eflipflop(node); end
+
+  def on_iflipflop(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::FlipFlop
+end
+
+class RuboCop::Cop::Lint::FloatOutOfRange
+  def on_float(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::FloatOutOfRange
+end
+
+class RuboCop::Cop::Lint::FormatParameterMismatch
+  def called_on_string?(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+  KERNEL = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+  SHOVEL = ::T.let(nil, ::T.untyped)
+  STRING_TYPES = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::FormatParameterMismatch
+end
+
+class RuboCop::Cop::Lint::HeredocMethodCallPosition
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_csend(node); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::HeredocMethodCallPosition
+end
+
+class RuboCop::Cop::Lint::ImplicitStringConcatenation
+  def on_dstr(node); end
+  FOR_ARRAY = ::T.let(nil, ::T.untyped)
+  FOR_METHOD = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::ImplicitStringConcatenation
+end
+
+class RuboCop::Cop::Lint::IneffectiveAccessModifier
+  def on_class(node); end
+
+  def on_module(node); end
+
+  def private_class_methods(node0); end
+  ALTERNATIVE_PRIVATE = ::T.let(nil, ::T.untyped)
+  ALTERNATIVE_PROTECTED = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::IneffectiveAccessModifier
+end
+
+class RuboCop::Cop::Lint::InheritException
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def class_new_call?(node=T.unsafe(nil)); end
+
+  def on_class(node); end
+
+  def on_send(node); end
+  ILLEGAL_CLASSES = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+  PREFERRED_BASE_CLASS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::InheritException
+end
+
+class RuboCop::Cop::Lint::InterpolationCheck
+  def heredoc?(node); end
+
+  def on_str(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::InterpolationCheck
+end
+
+class RuboCop::Cop::Lint::LiteralAsCondition
+  def message(node); end
+
+  def on_case(case_node); end
+
+  def on_if(node); end
+
+  def on_send(node); end
+
+  def on_until(node); end
+
+  def on_until_post(node); end
+
+  def on_while(node); end
+
+  def on_while_post(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::LiteralAsCondition
+end
+
+class RuboCop::Cop::Lint::LiteralInInterpolation
+  include ::RuboCop::Cop::Interpolation
+  include ::RuboCop::Cop::PercentLiteral
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_interpolation(begin_node); end
+  COMPOSITE = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::LiteralInInterpolation
+end
+
+class RuboCop::Cop::Lint::Loop
+  def on_until_post(node); end
+
+  def on_while_post(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::Loop
+end
+
+class RuboCop::Cop::Lint::MissingCopEnableDirective
+  include ::RuboCop::Cop::RangeHelp
+  def investigate(processed_source); end
+  MSG = ::T.let(nil, ::T.untyped)
+  MSG_BOUND = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::MissingCopEnableDirective
+end
+
+class RuboCop::Cop::Lint::MultipleComparison
+  def autocorrect(node); end
+
+  def multiple_compare?(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::MultipleComparison
+end
+
+class RuboCop::Cop::Lint::NestedMethodDefinition
+  def class_or_module_or_struct_new_call?(node=T.unsafe(nil)); end
+
+  def eval_call?(node=T.unsafe(nil)); end
+
+  def exec_call?(node=T.unsafe(nil)); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::NestedMethodDefinition
+end
+
+class RuboCop::Cop::Lint::NestedPercentLiteral
+  include ::RuboCop::Cop::PercentLiteral
+  include ::RuboCop::Cop::RangeHelp
+  def on_array(node); end
+
+  def on_percent_literal(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+  PERCENT_LITERAL_TYPES = ::T.let(nil, ::T.untyped)
+  REGEXES = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::NestedPercentLiteral
+end
+
+class RuboCop::Cop::Lint::NextWithoutAccumulator
+  def on_block(node); end
+
+  def on_body_of_reduce(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::NextWithoutAccumulator
+end
+
+class RuboCop::Cop::Lint::NonDeterministicRequireOrder
+  def autocorrect(node); end
+
+  def loop_variable(node=T.unsafe(nil)); end
+
+  def on_block(node); end
+
+  def unsorted_dir_block?(node=T.unsafe(nil)); end
+
+  def unsorted_dir_each?(node=T.unsafe(nil)); end
+
+  def var_is_required?(node0, param1); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::NonDeterministicRequireOrder
+end
+
+class RuboCop::Cop::Lint::NonLocalExitFromIterator
+  def chained_send?(node=T.unsafe(nil)); end
+
+  def define_method?(node=T.unsafe(nil)); end
+
+  def on_return(return_node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::NonLocalExitFromIterator
+end
+
+class RuboCop::Cop::Lint::NumberConversion
+  def autocorrect(node); end
+
+  def datetime?(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+
+  def to_method(node=T.unsafe(nil)); end
+  CONVERSION_METHOD_CLASS_MAPPING = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::NumberConversion
+end
+
+class RuboCop::Cop::Lint::OrderedMagicComments
+  include ::RuboCop::Cop::FrozenStringLiteral
+  def autocorrect(_node); end
+
+  def investigate(processed_source); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::OrderedMagicComments
+end
+
+class RuboCop::Cop::Lint::ParenthesesAsGroupedExpression
+  include ::RuboCop::Cop::RangeHelp
+  def on_csend(node); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::ParenthesesAsGroupedExpression
+end
+
+class RuboCop::Cop::Lint::PercentStringArray
+  include ::RuboCop::Cop::PercentLiteral
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_array(node); end
+
+  def on_percent_literal(node); end
+  LEADING_QUOTE = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+  QUOTES_AND_COMMAS = ::T.let(nil, ::T.untyped)
+  TRAILING_QUOTE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::PercentStringArray
+end
+
+class RuboCop::Cop::Lint::PercentSymbolArray
+  include ::RuboCop::Cop::PercentLiteral
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_array(node); end
+
+  def on_percent_literal(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::PercentSymbolArray
+end
+
+class RuboCop::Cop::Lint::RandOne
+  def on_send(node); end
+
+  def rand_one?(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::RandOne
+end
+
+class RuboCop::Cop::Lint::RedundantCopDisableDirective
+  include ::RuboCop::NameSimilarity
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(args); end
+
+  def check(offenses, cop_disabled_line_ranges, comments); end
+  COP_NAME = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::RedundantCopDisableDirective
+end
+
+class RuboCop::Cop::Lint::RedundantCopEnableDirective
+  include ::RuboCop::Cop::SurroundingSpace
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(comment_and_name); end
+
+  def investigate(processed_source); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::RedundantCopEnableDirective
+end
+
+class RuboCop::Cop::Lint::RedundantRequireStatement
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_send(node); end
+
+  def unnecessary_require_statement?(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::RedundantRequireStatement
+end
+
+class RuboCop::Cop::Lint::RedundantSplatExpansion
+  def array_new?(node=T.unsafe(nil)); end
+
+  def autocorrect(node); end
+
+  def literal_expansion(node=T.unsafe(nil)); end
+
+  def on_splat(node); end
+  ARRAY_PARAM_MSG = ::T.let(nil, ::T.untyped)
+  ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+  PERCENT_CAPITAL_I = ::T.let(nil, ::T.untyped)
+  PERCENT_CAPITAL_W = ::T.let(nil, ::T.untyped)
+  PERCENT_I = ::T.let(nil, ::T.untyped)
+  PERCENT_W = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::RedundantSplatExpansion
+end
+
+class RuboCop::Cop::Lint::RedundantStringCoercion
+  include ::RuboCop::Cop::Interpolation
+  def autocorrect(node); end
+
+  def on_interpolation(begin_node); end
+
+  def to_s_without_args?(node=T.unsafe(nil)); end
+  MSG_DEFAULT = ::T.let(nil, ::T.untyped)
+  MSG_SELF = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::RedundantStringCoercion
+end
+
+class RuboCop::Cop::Lint::RedundantWithIndex
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_block(node); end
+
+  def redundant_with_index?(node=T.unsafe(nil)); end
+  MSG_EACH_WITH_INDEX = ::T.let(nil, ::T.untyped)
+  MSG_WITH_INDEX = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::RedundantWithIndex
+end
+
+class RuboCop::Cop::Lint::RedundantWithObject
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_block(node); end
+
+  def redundant_with_object?(node=T.unsafe(nil)); end
+  MSG_EACH_WITH_OBJECT = ::T.let(nil, ::T.untyped)
+  MSG_WITH_OBJECT = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::RedundantWithObject
+end
+
+class RuboCop::Cop::Lint::RegexpAsCondition
+  def on_match_current_line(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::RegexpAsCondition
+end
+
+class RuboCop::Cop::Lint::RequireParentheses
+  include ::RuboCop::Cop::RangeHelp
+  def on_csend(node); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::RequireParentheses
+end
+
+class RuboCop::Cop::Lint::RescueException
+  def on_resbody(node); end
+
+  def targets_exception?(rescue_arg_node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::RescueException
+end
+
+class RuboCop::Cop::Lint::RescueType
+  include ::RuboCop::Cop::RescueNode
+  def autocorrect(node); end
+
+  def on_resbody(node); end
+  INVALID_TYPES = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::RescueType
+end
+
+class RuboCop::Cop::Lint::ReturnInVoidContext
+  def on_return(return_node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::ReturnInVoidContext
+end
+
+class RuboCop::Cop::Lint::SafeNavigationChain
+  include ::RuboCop::Cop::NilMethods
+  def bad_method?(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::SafeNavigationChain
+end
+
+class RuboCop::Cop::Lint::SafeNavigationConsistency
+  include ::RuboCop::Cop::NilMethods
+  def autocorrect(node); end
+
+  def check(node); end
+
+  def on_csend(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::SafeNavigationConsistency
+end
+
+class RuboCop::Cop::Lint::SafeNavigationWithEmpty
+  def on_if(node); end
+
+  def safe_navigation_empty_in_conditional?(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::SafeNavigationWithEmpty
+end
+
+class RuboCop::Cop::Lint::ScriptPermission
+  def autocorrect(node); end
+
+  def investigate(processed_source); end
+  MSG = ::T.let(nil, ::T.untyped)
+  SHEBANG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::ScriptPermission
+end
+
+class RuboCop::Cop::Lint::SendWithMixinArgument
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_send(node); end
+
+  def send_with_mixin_argument?(node=T.unsafe(nil)); end
+  MIXIN_METHODS = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::SendWithMixinArgument
+end
+
+class RuboCop::Cop::Lint::ShadowedArgument
+  def after_leaving_scope(scope, _variable_table); end
+
+  def join_force?(force_class); end
+
+  def uses_var?(node0, param1); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::ShadowedArgument
+end
+
+class RuboCop::Cop::Lint::ShadowedException
+  include ::RuboCop::Cop::RescueNode
+  include ::RuboCop::Cop::RangeHelp
+  def on_rescue(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::ShadowedException
+end
+
+class RuboCop::Cop::Lint::ShadowingOuterLocalVariable
+  def before_declaring_variable(variable, variable_table); end
+
+  def join_force?(force_class); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::ShadowingOuterLocalVariable
+end
+
+class RuboCop::Cop::Lint::SuppressedException
+  def on_resbody(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::SuppressedException
+end
+
+class RuboCop::Cop::Lint::Syntax
+  def add_offense_from_diagnostic(diagnostic, ruby_version); end
+
+  def add_offense_from_error(error); end
+  ERROR_SOURCE_RANGE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::Syntax::PseudoSourceRange
+  def begin_pos(); end
+
+  def begin_pos=(_); end
+
+  def column(); end
+
+  def column=(_); end
+
+  def end_pos(); end
+
+  def end_pos=(_); end
+
+  def line(); end
+
+  def line=(_); end
+
+  def source_line(); end
+
+  def source_line=(_); end
+end
+
+class RuboCop::Cop::Lint::Syntax::PseudoSourceRange
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+class RuboCop::Cop::Lint::Syntax
+  def self.offenses_from_processed_source(processed_source, config, options); end
+end
+
+class RuboCop::Cop::Lint::ToJSON
+  def autocorrect(node); end
+
+  def on_def(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::ToJSON
+end
+
+class RuboCop::Cop::Lint::UnderscorePrefixedVariableName
+  def after_leaving_scope(scope, _variable_table); end
+
+  def check_variable(variable); end
+
+  def join_force?(force_class); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::UnderscorePrefixedVariableName
+end
+
+class RuboCop::Cop::Lint::UnifiedInteger
+  def autocorrect(node); end
+
+  def fixnum_or_bignum_const(node=T.unsafe(nil)); end
+
+  def on_const(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::UnifiedInteger
+end
+
+class RuboCop::Cop::Lint::UnreachableCode
+  def flow_command?(node=T.unsafe(nil)); end
+
+  def on_begin(node); end
+
+  def on_kwbegin(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::UnreachableCode
+end
+
+module RuboCop::Cop::Lint::UnusedArgument
+  def after_leaving_scope(scope, _variable_table); end
+
+  def join_force?(force_class); end
+end
+
+module RuboCop::Cop::Lint::UnusedArgument
+  extend ::RuboCop::NodePattern::Macros
+end
+
+class RuboCop::Cop::Lint::UnusedBlockArgument
+  include ::RuboCop::Cop::Lint::UnusedArgument
+  def autocorrect(node); end
+end
+
+class RuboCop::Cop::Lint::UnusedBlockArgument
+end
+
+class RuboCop::Cop::Lint::UnusedMethodArgument
+  include ::RuboCop::Cop::Lint::UnusedArgument
+  def autocorrect(node); end
+end
+
+class RuboCop::Cop::Lint::UnusedMethodArgument
+end
+
+class RuboCop::Cop::Lint::UriEscapeUnescape
+  def on_send(node); end
+
+  def uri_escape_unescape?(node=T.unsafe(nil)); end
+  ALTERNATE_METHODS_OF_URI_ESCAPE = ::T.let(nil, ::T.untyped)
+  ALTERNATE_METHODS_OF_URI_UNESCAPE = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::UriEscapeUnescape
+end
+
+class RuboCop::Cop::Lint::UriRegexp
+  def autocorrect(node); end
+
+  def on_send(node); end
+
+  def uri_regexp_with_argument?(node=T.unsafe(nil)); end
+
+  def uri_regexp_without_argument?(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::UriRegexp
+end
+
+class RuboCop::Cop::Lint::UselessAccessModifier
+  def class_or_instance_eval?(node=T.unsafe(nil)); end
+
+  def class_or_module_or_struct_new_call?(node=T.unsafe(nil)); end
+
+  def dynamic_method_definition?(node=T.unsafe(nil)); end
+
+  def on_block(node); end
+
+  def on_class(node); end
+
+  def on_module(node); end
+
+  def on_sclass(node); end
+
+  def static_method_definition?(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::UselessAccessModifier
+end
+
+class RuboCop::Cop::Lint::UselessAssignment
+  include ::RuboCop::NameSimilarity
+  def after_leaving_scope(scope, _variable_table); end
+
+  def check_for_unused_assignments(variable); end
+
+  def collect_variable_like_names(scope); end
+
+  def join_force?(force_class); end
+
+  def message_for_useless_assignment(assignment); end
+
+  def message_specification(assignment, variable); end
+
+  def multiple_assignment_message(variable_name); end
+
+  def operator_assignment_message(scope, assignment); end
+
+  def return_value_node_of_scope(scope); end
+
+  def similar_name_message(variable); end
+
+  def variable_like_method_invocation?(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::UselessAssignment
+end
+
+class RuboCop::Cop::Lint::UselessComparison
+  def on_send(node); end
+
+  def useless_comparison?(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+  OPS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::UselessComparison
+end
+
+class RuboCop::Cop::Lint::UselessElseWithoutRescue
+  include ::RuboCop::Cop::ParserDiagnostic
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::UselessElseWithoutRescue
+end
+
+class RuboCop::Cop::Lint::UselessSetterCall
+  def on_def(node); end
+
+  def on_defs(node); end
+
+  def setter_call_to_local_variable?(node=T.unsafe(nil)); end
+  ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::UselessSetterCall::MethodVariableTracker
+  def constructor?(node); end
+
+  def contain_local_object?(variable_name); end
+
+  def initialize(body_node); end
+
+  def process_assignment(asgn_node, rhs_node); end
+
+  def process_assignment_node(node); end
+
+  def process_binary_operator_assignment(op_asgn_node); end
+
+  def process_logical_operator_assignment(asgn_node); end
+
+  def process_multiple_assignment(masgn_node); end
+
+  def scan(node, &block); end
+end
+
+class RuboCop::Cop::Lint::UselessSetterCall::MethodVariableTracker
+end
+
+class RuboCop::Cop::Lint::UselessSetterCall
+end
+
+class RuboCop::Cop::Lint::Void
+  def on_begin(node); end
+
+  def on_block(node); end
+
+  def on_kwbegin(node); end
+  BINARY_OPERATORS = ::T.let(nil, ::T.untyped)
+  DEFINED_MSG = ::T.let(nil, ::T.untyped)
+  LIT_MSG = ::T.let(nil, ::T.untyped)
+  NONMUTATING_METHODS = ::T.let(nil, ::T.untyped)
+  NONMUTATING_MSG = ::T.let(nil, ::T.untyped)
+  OPERATORS = ::T.let(nil, ::T.untyped)
+  OP_MSG = ::T.let(nil, ::T.untyped)
+  SELF_MSG = ::T.let(nil, ::T.untyped)
+  UNARY_OPERATORS = ::T.let(nil, ::T.untyped)
+  VAR_MSG = ::T.let(nil, ::T.untyped)
+  VOID_CONTEXT_TYPES = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Lint::Void
+end
+
+module RuboCop::Cop::Lint
+end
+
+module RuboCop::Cop::MatchRange
+  include ::RuboCop::Cop::RangeHelp
+end
+
+module RuboCop::Cop::MatchRange
+end
+
+class RuboCop::Cop::MessageAnnotator
+  def annotate(message); end
+
+  def config(); end
+
+  def cop_config(); end
+
+  def cop_name(); end
+
+  def initialize(config, cop_name, cop_config, options); end
+
+  def options(); end
+
+  def urls(); end
+end
+
+class RuboCop::Cop::MessageAnnotator
+  def self.style_guide_urls(); end
+end
+
+module RuboCop::Cop::MethodComplexity
+  include ::RuboCop::Cop::ConfigurableMax
+  def define_method?(node=T.unsafe(nil)); end
+
+  def on_block(node); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+end
+
+module RuboCop::Cop::MethodComplexity
+  extend ::RuboCop::NodePattern::Macros
+end
+
+module RuboCop::Cop::MethodPreference
+end
+
+module RuboCop::Cop::MethodPreference
+end
+
+module RuboCop::Cop::Metrics
+end
+
+class RuboCop::Cop::Metrics::AbcSize
+  include ::RuboCop::Cop::MethodComplexity
+  include ::RuboCop::Cop::ConfigurableMax
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Metrics::AbcSize
+end
+
+class RuboCop::Cop::Metrics::BlockLength
+  include ::RuboCop::Cop::TooManyLines
+  include ::RuboCop::Cop::CodeLength
+  include ::RuboCop::Cop::ConfigurableMax
+  def on_block(node); end
+  LABEL = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Metrics::BlockLength
+end
+
+class RuboCop::Cop::Metrics::BlockNesting
+  include ::RuboCop::Cop::ConfigurableMax
+  def investigate(processed_source); end
+  NESTING_BLOCKS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Metrics::BlockNesting
+end
+
+class RuboCop::Cop::Metrics::ClassLength
+  include ::RuboCop::Cop::ClassishLength
+  include ::RuboCop::Cop::CodeLength
+  include ::RuboCop::Cop::ConfigurableMax
+  def class_definition?(node=T.unsafe(nil)); end
+
+  def on_casgn(node); end
+
+  def on_class(node); end
+end
+
+class RuboCop::Cop::Metrics::ClassLength
+end
+
+class RuboCop::Cop::Metrics::CyclomaticComplexity
+  include ::RuboCop::Cop::MethodComplexity
+  include ::RuboCop::Cop::ConfigurableMax
+  COUNTED_NODES = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Metrics::CyclomaticComplexity
+end
+
+class RuboCop::Cop::Metrics::MethodLength
+  include ::RuboCop::Cop::TooManyLines
+  include ::RuboCop::Cop::CodeLength
+  include ::RuboCop::Cop::ConfigurableMax
+  def on_block(node); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+  LABEL = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Metrics::MethodLength
+end
+
+class RuboCop::Cop::Metrics::ModuleLength
+  include ::RuboCop::Cop::ClassishLength
+  include ::RuboCop::Cop::CodeLength
+  include ::RuboCop::Cop::ConfigurableMax
+  def module_definition?(node=T.unsafe(nil)); end
+
+  def on_casgn(node); end
+
+  def on_module(node); end
+end
+
+class RuboCop::Cop::Metrics::ModuleLength
+end
+
+class RuboCop::Cop::Metrics::ParameterLists
+  include ::RuboCop::Cop::ConfigurableMax
+  def argument_to_lambda_or_proc?(node=T.unsafe(nil)); end
+
+  def on_args(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Metrics::ParameterLists
+end
+
+class RuboCop::Cop::Metrics::PerceivedComplexity
+  include ::RuboCop::Cop::MethodComplexity
+  include ::RuboCop::Cop::ConfigurableMax
+  COUNTED_NODES = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Metrics::PerceivedComplexity
+end
+
+module RuboCop::Cop::Metrics::Utils
+end
+
+class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator
+  def calculate(); end
+
+  def else_branch?(node); end
+
+  def evaluate_branch_nodes(node); end
+
+  def evaluate_condition_node(node); end
+
+  def initialize(node); end
+  BRANCH_NODES = ::T.let(nil, ::T.untyped)
+  CONDITION_NODES = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator
+  def self.calculate(node); end
+end
+
+module RuboCop::Cop::Metrics::Utils
+end
+
+module RuboCop::Cop::Metrics
+end
+
+module RuboCop::Cop::Migration
+end
+
+class RuboCop::Cop::Migration::DepartmentName
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(range); end
+
+  def investigate(processed_source); end
+  DISABLE_COMMENT_FORMAT = ::T.let(nil, ::T.untyped)
+  DISABLING_COPS_CONTENT_TOKEN = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Migration::DepartmentName
+end
+
+module RuboCop::Cop::Migration
+end
+
+module RuboCop::Cop::MinBodyLength
+end
+
+module RuboCop::Cop::MinBodyLength
+end
+
+module RuboCop::Cop::MultilineElementIndentation
+end
+
+module RuboCop::Cop::MultilineElementIndentation
+end
+
+module RuboCop::Cop::MultilineElementLineBreaks
+end
+
+module RuboCop::Cop::MultilineElementLineBreaks
+end
+
+module RuboCop::Cop::MultilineExpressionIndentation
+  def on_send(node); end
+  ASSIGNMENT_MESSAGE_TAIL = ::T.let(nil, ::T.untyped)
+  DEFAULT_MESSAGE_TAIL = ::T.let(nil, ::T.untyped)
+  KEYWORD_ANCESTOR_TYPES = ::T.let(nil, ::T.untyped)
+  KEYWORD_MESSAGE_TAIL = ::T.let(nil, ::T.untyped)
+  UNALIGNED_RHS_TYPES = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::Cop::MultilineExpressionIndentation
+end
+
+class RuboCop::Cop::MultilineLiteralBraceCorrector
+  include ::RuboCop::Cop::MultilineLiteralBraceLayout
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def call(corrector); end
+
+  def initialize(node, processed_source); end
+end
+
+class RuboCop::Cop::MultilineLiteralBraceCorrector
+end
+
+module RuboCop::Cop::MultilineLiteralBraceLayout
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+end
+
+module RuboCop::Cop::MultilineLiteralBraceLayout
+end
+
+module RuboCop::Cop::Naming
+end
+
+class RuboCop::Cop::Naming::AccessorMethodName
+  def on_def(node); end
+
+  def on_defs(node); end
+  MSG_READER = ::T.let(nil, ::T.untyped)
+  MSG_WRITER = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Naming::AccessorMethodName
+end
+
+class RuboCop::Cop::Naming::AsciiIdentifiers
+  include ::RuboCop::Cop::RangeHelp
+  def investigate(processed_source); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Naming::AsciiIdentifiers
+end
+
+class RuboCop::Cop::Naming::BinaryOperatorParameterName
+  def on_def(node); end
+
+  def op_method_candidate?(node=T.unsafe(nil)); end
+  BLACKLISTED = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+  OP_LIKE_METHODS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Naming::BinaryOperatorParameterName
+end
+
+class RuboCop::Cop::Naming::BlockParameterName
+  include ::RuboCop::Cop::UncommunicativeName
+  def on_block(node); end
+end
+
+class RuboCop::Cop::Naming::BlockParameterName
+end
+
+class RuboCop::Cop::Naming::ClassAndModuleCamelCase
+  def on_class(node); end
+
+  def on_module(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Naming::ClassAndModuleCamelCase
+end
+
+class RuboCop::Cop::Naming::ConstantName
+  def class_or_struct_return_method?(node=T.unsafe(nil)); end
+
+  def literal_receiver?(node=T.unsafe(nil)); end
+
+  def on_casgn(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+  SNAKE_CASE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Naming::ConstantName
+end
+
+class RuboCop::Cop::Naming::FileName
+  include ::RuboCop::Cop::RangeHelp
+  def investigate(processed_source); end
+  MSG_NO_DEFINITION = ::T.let(nil, ::T.untyped)
+  MSG_REGEX = ::T.let(nil, ::T.untyped)
+  MSG_SNAKE_CASE = ::T.let(nil, ::T.untyped)
+  SNAKE_CASE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Naming::FileName
+end
+
+class RuboCop::Cop::Naming::HeredocDelimiterCase
+  include ::RuboCop::Cop::Heredoc
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def on_heredoc(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Naming::HeredocDelimiterCase
+end
+
+class RuboCop::Cop::Naming::HeredocDelimiterNaming
+  include ::RuboCop::Cop::Heredoc
+  def on_heredoc(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Naming::HeredocDelimiterNaming
+end
+
+class RuboCop::Cop::Naming::MemoizedInstanceVariableName
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def memoized?(node=T.unsafe(nil)); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+  UNDERSCORE_REQUIRED = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Naming::MemoizedInstanceVariableName
+end
+
+class RuboCop::Cop::Naming::MethodName
+  include ::RuboCop::Cop::ConfigurableNaming
+  include ::RuboCop::Cop::ConfigurableFormatting
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::IgnoredPattern
+  def on_def(node); end
+
+  def on_defs(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Naming::MethodName
+end
+
+class RuboCop::Cop::Naming::MethodParameterName
+  include ::RuboCop::Cop::UncommunicativeName
+  def on_def(node); end
+
+  def on_defs(node); end
+end
+
+class RuboCop::Cop::Naming::MethodParameterName
+end
+
+class RuboCop::Cop::Naming::PredicateName
+  def dynamic_method_define(node=T.unsafe(nil)); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+
+  def on_send(node); end
+end
+
+class RuboCop::Cop::Naming::PredicateName
+end
+
+class RuboCop::Cop::Naming::RescuedExceptionsVariableName
+  def autocorrect(node); end
+
+  def on_resbody(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Naming::RescuedExceptionsVariableName
+end
+
+class RuboCop::Cop::Naming::VariableName
+  include ::RuboCop::Cop::ConfigurableNaming
+  include ::RuboCop::Cop::ConfigurableFormatting
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def on_arg(node); end
+
+  def on_blockarg(node); end
+
+  def on_cvasgn(node); end
+
+  def on_ivasgn(node); end
+
+  def on_kwarg(node); end
+
+  def on_kwoptarg(node); end
+
+  def on_kwrestarg(node); end
+
+  def on_lvar(node); end
+
+  def on_lvasgn(node); end
+
+  def on_optarg(node); end
+
+  def on_restarg(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Naming::VariableName
+end
+
+class RuboCop::Cop::Naming::VariableNumber
+  include ::RuboCop::Cop::ConfigurableNumbering
+  include ::RuboCop::Cop::ConfigurableFormatting
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def on_arg(node); end
+
+  def on_cvasgn(node); end
+
+  def on_ivasgn(node); end
+
+  def on_lvasgn(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Naming::VariableNumber
+end
+
+module RuboCop::Cop::Naming
+end
+
+module RuboCop::Cop::NegativeConditional
+  def empty_condition?(node=T.unsafe(nil)); end
+
+  def single_negative?(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::Cop::NegativeConditional
+  extend ::RuboCop::NodePattern::Macros
+end
+
+module RuboCop::Cop::NilMethods
+end
+
+module RuboCop::Cop::NilMethods
+end
+
+class RuboCop::Cop::Offense
+  include ::Comparable
+  def ==(other); end
+
+  def column(); end
+
+  def column_length(); end
+
+  def column_range(); end
+
+  def cop_name(); end
+
+  def correctable?(); end
+
+  def corrected?(); end
+
+  def corrected_with_todo?(); end
+
+  def disabled?(); end
+
+  def eql?(other); end
+
+  def first_line(); end
+
+  def highlighted_area(); end
+
+  def initialize(severity, location, message, cop_name, status=T.unsafe(nil)); end
+
+  def last_column(); end
+
+  def last_line(); end
+
+  def line(); end
+
+  def location(); end
+
+  def message(); end
+
+  def real_column(); end
+
+  def severity(); end
+
+  def source_line(); end
+
+  def status(); end
+  COMPARISON_ATTRIBUTES = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Offense
+end
+
+module RuboCop::Cop::OnNormalIfUnless
+  def on_if(node); end
+end
+
+module RuboCop::Cop::OnNormalIfUnless
+end
+
+class RuboCop::Cop::OrderedGemCorrector
+end
+
+class RuboCop::Cop::OrderedGemCorrector
+  extend ::RuboCop::Cop::OrderedGemNode
+  def self.comments_as_separators(); end
+
+  def self.correct(processed_source, node, previous_declaration, comments_as_separators); end
+
+  def self.processed_source(); end
+end
+
+module RuboCop::Cop::OrderedGemNode
+end
+
+module RuboCop::Cop::OrderedGemNode
+end
+
+module RuboCop::Cop::Parentheses
+end
+
+module RuboCop::Cop::Parentheses
+end
+
+class RuboCop::Cop::ParenthesesCorrector
+end
+
+class RuboCop::Cop::ParenthesesCorrector
+  def self.correct(node); end
+end
+
+module RuboCop::Cop::ParserDiagnostic
+  def investigate(processed_source); end
+end
+
+module RuboCop::Cop::ParserDiagnostic
+end
+
+module RuboCop::Cop::PercentArray
+end
+
+module RuboCop::Cop::PercentArray
+end
+
+module RuboCop::Cop::PercentLiteral
+  include ::RuboCop::Cop::RangeHelp
+end
+
+module RuboCop::Cop::PercentLiteral
+end
+
+class RuboCop::Cop::PercentLiteralCorrector
+  include ::RuboCop::Cop::Util
+  include ::RuboCop::PathUtil
+  def config(); end
+
+  def correct(node, char); end
+
+  def initialize(config, preferred_delimiters); end
+
+  def preferred_delimiters(); end
+end
+
+class RuboCop::Cop::PercentLiteralCorrector
+end
+
+module RuboCop::Cop::PrecedingFollowingAlignment
+end
+
+module RuboCop::Cop::PrecedingFollowingAlignment
+end
+
+class RuboCop::Cop::PreferredDelimiters
+  def config(); end
+
+  def delimiters(); end
+
+  def initialize(type, config, preferred_delimiters); end
+
+  def type(); end
+  PERCENT_LITERAL_TYPES = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::PreferredDelimiters
+end
+
+class RuboCop::Cop::PunctuationCorrector
+end
+
+class RuboCop::Cop::PunctuationCorrector
+  def self.add_space(token); end
+
+  def self.remove_space(space_before); end
+
+  def self.swap_comma(range); end
+end
+
+module RuboCop::Cop::RangeHelp
+  BYTE_ORDER_MARK = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::Cop::RangeHelp
+end
+
+module RuboCop::Cop::RationalLiteral
+  def rational_literal?(node=T.unsafe(nil)); end
+end
+
+module RuboCop::Cop::RationalLiteral
+  extend ::RuboCop::NodePattern::Macros
+end
+
+class RuboCop::Cop::Registry
+  def ==(other); end
+
+  def contains_cop_matching?(names); end
+
+  def cops(); end
+
+  def department_missing?(badge, name); end
+
+  def departments(); end
+
+  def each(&block); end
+
+  def enabled(config, only, only_safe=T.unsafe(nil)); end
+
+  def enabled?(cop, config, only_safe); end
+
+  def enlist(cop); end
+
+  def find_by_cop_name(cop_name); end
+
+  def initialize(cops=T.unsafe(nil)); end
+
+  def length(); end
+
+  def names(); end
+
+  def print_warning(name, path); end
+
+  def qualified_cop_name(name, path, shall_warn=T.unsafe(nil)); end
+
+  def select(&block); end
+
+  def sort!(); end
+
+  def to_h(); end
+
+  def unqualified_cop_names(); end
+
+  def with_department(department); end
+
+  def without_department(department); end
+end
+
+class RuboCop::Cop::Registry
+end
+
+module RuboCop::Cop::RescueNode
+  def investigate(processed_source); end
+end
+
+module RuboCop::Cop::RescueNode
+end
+
+module RuboCop::Cop::SafeAssignment
+  def empty_condition?(node=T.unsafe(nil)); end
+
+  def safe_assignment?(node=T.unsafe(nil)); end
+
+  def setter_method?(node=T.unsafe(nil)); end
+end
+
+module RuboCop::Cop::SafeAssignment
+  extend ::RuboCop::NodePattern::Macros
+end
+
+module RuboCop::Cop::Security
+end
+
+class RuboCop::Cop::Security::Eval
+  def eval?(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Security::Eval
+end
+
+class RuboCop::Cop::Security::JSONLoad
+  def autocorrect(node); end
+
+  def json_load(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Security::JSONLoad
+end
+
+class RuboCop::Cop::Security::MarshalLoad
+  def marshal_load(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Security::MarshalLoad
+end
+
+class RuboCop::Cop::Security::Open
+  def on_send(node); end
+
+  def open?(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Security::Open
+end
+
+class RuboCop::Cop::Security::YAMLLoad
+  def autocorrect(node); end
+
+  def on_send(node); end
+
+  def yaml_load(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Security::YAMLLoad
+end
+
+module RuboCop::Cop::Security
+end
+
+class RuboCop::Cop::Severity
+  include ::Comparable
+  def ==(other); end
+
+  def code(); end
+
+  def initialize(name_or_code); end
+
+  def level(); end
+
+  def name(); end
+  CODE_TABLE = ::T.let(nil, ::T.untyped)
+  NAMES = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Severity
+  def self.name_from_code(code); end
+end
+
+module RuboCop::Cop::SpaceAfterPunctuation
+  def investigate(processed_source); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::Cop::SpaceAfterPunctuation
+end
+
+module RuboCop::Cop::SpaceBeforePunctuation
+  include ::RuboCop::Cop::RangeHelp
+  def investigate(processed_source); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::Cop::SpaceBeforePunctuation
+end
+
+class RuboCop::Cop::SpaceCorrector
+end
+
+class RuboCop::Cop::SpaceCorrector
+  extend ::RuboCop::Cop::SurroundingSpace
+  extend ::RuboCop::Cop::RangeHelp
+  def self.add_space(processed_source, corrector, left_token, right_token); end
+
+  def self.empty_corrections(processed_source, corrector, empty_config, left_token, right_token); end
+
+  def self.processed_source(); end
+
+  def self.remove_space(processed_source, corrector, left_token, right_token); end
+end
+
+module RuboCop::Cop::StatementModifier
+end
+
+module RuboCop::Cop::StatementModifier
+end
+
+module RuboCop::Cop::StringHelp
+  def on_regexp(node); end
+
+  def on_str(node); end
+end
+
+module RuboCop::Cop::StringHelp
+end
+
+class RuboCop::Cop::StringLiteralCorrector
+end
+
+class RuboCop::Cop::StringLiteralCorrector
+  extend ::RuboCop::Cop::Util
+  extend ::RuboCop::PathUtil
+  def self.correct(node, style); end
+end
+
+module RuboCop::Cop::StringLiteralsHelp
+  include ::RuboCop::Cop::StringHelp
+end
+
+module RuboCop::Cop::StringLiteralsHelp
+end
+
+module RuboCop::Cop::Style
+end
+
+class RuboCop::Cop::Style::AccessModifierDeclarations
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def on_send(node); end
+  GROUP_STYLE_MESSAGE = ::T.let(nil, ::T.untyped)
+  INLINE_STYLE_MESSAGE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::AccessModifierDeclarations
+end
+
+class RuboCop::Cop::Style::Alias
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def identifier(node=T.unsafe(nil)); end
+
+  def on_alias(node); end
+
+  def on_send(node); end
+  MSG_ALIAS = ::T.let(nil, ::T.untyped)
+  MSG_ALIAS_METHOD = ::T.let(nil, ::T.untyped)
+  MSG_SYMBOL_ARGS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::Alias
+end
+
+class RuboCop::Cop::Style::AndOr
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_and(node); end
+
+  def on_if(node); end
+
+  def on_or(node); end
+
+  def on_until(node); end
+
+  def on_until_post(node); end
+
+  def on_while(node); end
+
+  def on_while_post(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::AndOr
+end
+
+module RuboCop::Cop::Style::AnnotationComment
+end
+
+module RuboCop::Cop::Style::AnnotationComment
+end
+
+class RuboCop::Cop::Style::ArrayJoin
+  def autocorrect(node); end
+
+  def join_candidate?(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::ArrayJoin
+end
+
+class RuboCop::Cop::Style::AsciiComments
+  include ::RuboCop::Cop::RangeHelp
+  def investigate(processed_source); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::AsciiComments
+end
+
+class RuboCop::Cop::Style::Attr
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def class_eval?(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::Attr
+end
+
+class RuboCop::Cop::Style::AutoResourceCleanup
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+  TARGET_METHODS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::AutoResourceCleanup
+end
+
+class RuboCop::Cop::Style::BarePercentLiterals
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def on_dstr(node); end
+
+  def on_str(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::BarePercentLiterals
+end
+
+class RuboCop::Cop::Style::BeginBlock
+  def on_preexe(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::BeginBlock
+end
+
+class RuboCop::Cop::Style::BlockComments
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(comment); end
+
+  def investigate(processed_source); end
+  BEGIN_LENGTH = ::T.let(nil, ::T.untyped)
+  END_LENGTH = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::BlockComments
+end
+
+class RuboCop::Cop::Style::BlockDelimiters
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::IgnoredMethods
+  def autocorrect(node); end
+
+  def on_block(node); end
+
+  def on_send(node); end
+  ALWAYS_BRACES_MESSAGE = ::T.let(nil, ::T.untyped)
+  BRACES_REQUIRED_MESSAGE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::BlockDelimiters
+end
+
+class RuboCop::Cop::Style::CaseCorrector
+end
+
+class RuboCop::Cop::Style::CaseCorrector
+  extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper
+  extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper
+  def self.correct(cop, node); end
+
+  def self.move_assignment_inside_condition(node); end
+end
+
+class RuboCop::Cop::Style::CaseEquality
+  def case_equality?(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::CaseEquality
+end
+
+class RuboCop::Cop::Style::CharacterLiteral
+  include ::RuboCop::Cop::StringHelp
+  def autocorrect(node); end
+
+  def correct_style_detected(); end
+
+  def offense?(node); end
+
+  def opposite_style_detected(); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::CharacterLiteral
+end
+
+class RuboCop::Cop::Style::ClassAndModuleChildren
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_class(node); end
+
+  def on_module(node); end
+  COMPACT_MSG = ::T.let(nil, ::T.untyped)
+  NESTED_MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::ClassAndModuleChildren
+end
+
+class RuboCop::Cop::Style::ClassCheck
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def class_check?(node=T.unsafe(nil)); end
+
+  def message(node); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::ClassCheck
+end
+
+class RuboCop::Cop::Style::ClassMethods
+  def autocorrect(node); end
+
+  def on_class(node); end
+
+  def on_module(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::ClassMethods
+end
+
+class RuboCop::Cop::Style::ClassVars
+  def message(node); end
+
+  def on_cvasgn(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::ClassVars
+end
+
+class RuboCop::Cop::Style::CollectionMethods
+  include ::RuboCop::Cop::MethodPreference
+  def autocorrect(node); end
+
+  def on_block(node); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::CollectionMethods
+end
+
+class RuboCop::Cop::Style::ColonMethodCall
+  def autocorrect(node); end
+
+  def java_type_node?(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::ColonMethodCall
+end
+
+class RuboCop::Cop::Style::ColonMethodDefinition
+  def autocorrect(node); end
+
+  def on_defs(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::ColonMethodDefinition
+end
+
+class RuboCop::Cop::Style::CommandLiteral
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def on_xstr(node); end
+  MSG_USE_BACKTICKS = ::T.let(nil, ::T.untyped)
+  MSG_USE_PERCENT_X = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::CommandLiteral
+end
+
+class RuboCop::Cop::Style::CommentAnnotation
+  include ::RuboCop::Cop::Style::AnnotationComment
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(comment); end
+
+  def investigate(processed_source); end
+  MISSING_NOTE = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::CommentAnnotation
+end
+
+class RuboCop::Cop::Style::CommentedKeyword
+  def investigate(processed_source); end
+  ALLOWED_COMMENTS = ::T.let(nil, ::T.untyped)
+  KEYWORDS = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::CommentedKeyword
+end
+
+class RuboCop::Cop::Style::ConditionalAssignment
+  include ::RuboCop::Cop::Style::ConditionalAssignmentHelper
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def assignment_type?(node=T.unsafe(nil)); end
+
+  def autocorrect(node); end
+
+  def candidate_condition?(node=T.unsafe(nil)); end
+
+  def on_and_asgn(node); end
+
+  def on_case(node); end
+
+  def on_casgn(node); end
+
+  def on_cvasgn(node); end
+
+  def on_gvasgn(node); end
+
+  def on_if(node); end
+
+  def on_ivasgn(node); end
+
+  def on_lvasgn(node); end
+
+  def on_masgn(node); end
+
+  def on_op_asgn(node); end
+
+  def on_or_asgn(node); end
+
+  def on_send(node); end
+  ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped)
+  ASSIGN_TO_CONDITION_MSG = ::T.let(nil, ::T.untyped)
+  ENABLED = ::T.let(nil, ::T.untyped)
+  INDENTATION_WIDTH = ::T.let(nil, ::T.untyped)
+  LINE_LENGTH = ::T.let(nil, ::T.untyped)
+  MAX = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+  SINGLE_LINE_CONDITIONS_ONLY = ::T.let(nil, ::T.untyped)
+  VARIABLE_ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped)
+  WIDTH = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::ConditionalAssignment
+end
+
+module RuboCop::Cop::Style::ConditionalAssignmentHelper
+  def end_with_eq?(sym); end
+
+  def expand_elses(branch); end
+
+  def expand_when_branches(when_branches); end
+
+  def indent(cop, source); end
+
+  def lhs(node); end
+
+  def tail(branch); end
+  ALIGN_WITH = ::T.let(nil, ::T.untyped)
+  END_ALIGNMENT = ::T.let(nil, ::T.untyped)
+  EQUAL = ::T.let(nil, ::T.untyped)
+  KEYWORD = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::Cop::Style::ConditionalAssignmentHelper
+  extend ::RuboCop::NodePattern::Macros
+end
+
+module RuboCop::Cop::Style::ConditionalCorrectorHelper
+  def assignment(node); end
+
+  def correct_branches(corrector, branches); end
+
+  def correct_if_branches(corrector, cop, node); end
+
+  def remove_whitespace_in_branches(corrector, branch, condition, column); end
+
+  def replace_branch_assignment(corrector, branch); end
+
+  def white_space_range(node, column); end
+end
+
+module RuboCop::Cop::Style::ConditionalCorrectorHelper
+end
+
+class RuboCop::Cop::Style::ConstantVisibility
+  def on_casgn(node); end
+
+  def visibility_declaration_for?(node=T.unsafe(nil), param1); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::ConstantVisibility
+end
+
+class RuboCop::Cop::Style::Copyright
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(token); end
+
+  def investigate(processed_source); end
+  AUTOCORRECT_EMPTY_WARNING = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::Copyright
+end
+
+class RuboCop::Cop::Style::DateTime
+  def date_time?(node=T.unsafe(nil)); end
+
+  def historic_date?(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+
+  def to_datetime?(node=T.unsafe(nil)); end
+  CLASS_MSG = ::T.let(nil, ::T.untyped)
+  COERCION_MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::DateTime
+end
+
+class RuboCop::Cop::Style::DefWithParentheses
+  def autocorrect(node); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::DefWithParentheses
+end
+
+class RuboCop::Cop::Style::Dir
+  def autocorrect(node); end
+
+  def dir_replacement?(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::Dir
+end
+
+class RuboCop::Cop::Style::Documentation
+  include ::RuboCop::Cop::DocumentationComment
+  include ::RuboCop::Cop::Style::AnnotationComment
+  def constant_definition?(node=T.unsafe(nil)); end
+
+  def on_class(node); end
+
+  def on_module(node); end
+
+  def outer_module(node0); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::Documentation
+end
+
+class RuboCop::Cop::Style::DocumentationMethod
+  include ::RuboCop::Cop::DocumentationComment
+  include ::RuboCop::Cop::Style::AnnotationComment
+  include ::RuboCop::Cop::DefNode
+  def module_function_node?(node=T.unsafe(nil)); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::DocumentationMethod
+end
+
+class RuboCop::Cop::Style::DoubleCopDisableDirective
+  def autocorrect(comment); end
+
+  def investigate(processed_source); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::DoubleCopDisableDirective
+end
+
+class RuboCop::Cop::Style::DoubleNegation
+  def double_negative?(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::DoubleNegation
+end
+
+class RuboCop::Cop::Style::EachForSimpleLoop
+  def autocorrect(node); end
+
+  def offending_each_range(node=T.unsafe(nil)); end
+
+  def on_block(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::EachForSimpleLoop
+end
+
+class RuboCop::Cop::Style::EachWithObject
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def each_with_object_candidate?(node=T.unsafe(nil)); end
+
+  def on_block(node); end
+  METHODS = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::EachWithObject
+end
+
+class RuboCop::Cop::Style::EmptyBlockParameter
+  include ::RuboCop::Cop::EmptyParameter
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_block(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::EmptyBlockParameter
+end
+
+class RuboCop::Cop::Style::EmptyCaseCondition
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(case_node); end
+
+  def on_case(case_node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::EmptyCaseCondition
+end
+
+class RuboCop::Cop::Style::EmptyElse
+  include ::RuboCop::Cop::OnNormalIfUnless
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_case(node); end
+
+  def on_normal_if_unless(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::EmptyElse
+end
+
+class RuboCop::Cop::Style::EmptyLambdaParameter
+  include ::RuboCop::Cop::EmptyParameter
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_block(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::EmptyLambdaParameter
+end
+
+class RuboCop::Cop::Style::EmptyLiteral
+  include ::RuboCop::Cop::FrozenStringLiteral
+  include ::RuboCop::Cop::RangeHelp
+  def array_node(node=T.unsafe(nil)); end
+
+  def array_with_block(node=T.unsafe(nil)); end
+
+  def autocorrect(node); end
+
+  def hash_node(node=T.unsafe(nil)); end
+
+  def hash_with_block(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+
+  def str_node(node=T.unsafe(nil)); end
+  ARR_MSG = ::T.let(nil, ::T.untyped)
+  HASH_MSG = ::T.let(nil, ::T.untyped)
+  STR_MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::EmptyLiteral
+end
+
+class RuboCop::Cop::Style::EmptyMethod
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+  MSG_COMPACT = ::T.let(nil, ::T.untyped)
+  MSG_EXPANDED = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::EmptyMethod
+end
+
+class RuboCop::Cop::Style::Encoding
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(range); end
+
+  def investigate(processed_source); end
+  ENCODING_PATTERN = ::T.let(nil, ::T.untyped)
+  MSG_UNNECESSARY = ::T.let(nil, ::T.untyped)
+  SHEBANG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::Encoding
+end
+
+class RuboCop::Cop::Style::EndBlock
+  def on_postexe(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::EndBlock
+end
+
+class RuboCop::Cop::Style::EvalWithLocation
+  def eval_without_location?(node=T.unsafe(nil)); end
+
+  def line_with_offset?(node=T.unsafe(nil), param1, param2); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+  MSG_INCORRECT_LINE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::EvalWithLocation
+end
+
+class RuboCop::Cop::Style::EvenOdd
+  def autocorrect(node); end
+
+  def even_odd_candidate?(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::EvenOdd
+end
+
+class RuboCop::Cop::Style::ExpandPathArguments
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def file_expand_path(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+
+  def pathname_new_parent_expand_path(node=T.unsafe(nil)); end
+
+  def pathname_parent_expand_path(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+  PATHNAME_MSG = ::T.let(nil, ::T.untyped)
+  PATHNAME_NEW_MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::ExpandPathArguments
+end
+
+class RuboCop::Cop::Style::FloatDivision
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def any_coerce?(node=T.unsafe(nil)); end
+
+  def both_coerce?(node=T.unsafe(nil)); end
+
+  def left_coerce?(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+
+  def right_coerce?(node=T.unsafe(nil)); end
+end
+
+class RuboCop::Cop::Style::FloatDivision
+end
+
+class RuboCop::Cop::Style::For
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_block(node); end
+
+  def on_for(node); end
+  EACH_LENGTH = ::T.let(nil, ::T.untyped)
+  PREFER_EACH = ::T.let(nil, ::T.untyped)
+  PREFER_FOR = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::For
+end
+
+class RuboCop::Cop::Style::FormatString
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def formatter(node=T.unsafe(nil)); end
+
+  def message(detected_style); end
+
+  def method_name(style_name); end
+
+  def on_send(node); end
+
+  def variable_argument?(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::FormatString
+end
+
+class RuboCop::Cop::Style::FormatStringToken
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def format_string_in_typical_context?(node=T.unsafe(nil)); end
+
+  def on_str(node); end
+end
+
+class RuboCop::Cop::Style::FormatStringToken
+end
+
+class RuboCop::Cop::Style::FrozenStringLiteralComment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::FrozenStringLiteral
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def investigate(processed_source); end
+  MSG_DISABLED = ::T.let(nil, ::T.untyped)
+  MSG_MISSING = ::T.let(nil, ::T.untyped)
+  MSG_MISSING_TRUE = ::T.let(nil, ::T.untyped)
+  MSG_UNNECESSARY = ::T.let(nil, ::T.untyped)
+  SHEBANG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::FrozenStringLiteralComment
+end
+
+class RuboCop::Cop::Style::GlobalVars
+  def allowed_var?(global_var); end
+
+  def check(node); end
+
+  def on_gvar(node); end
+
+  def on_gvasgn(node); end
+
+  def user_vars(); end
+  BUILT_IN_VARS = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::GlobalVars
+end
+
+class RuboCop::Cop::Style::GuardClause
+  include ::RuboCop::Cop::MinBodyLength
+  include ::RuboCop::Cop::StatementModifier
+  def on_def(node); end
+
+  def on_defs(node); end
+
+  def on_if(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::GuardClause
+end
+
+class RuboCop::Cop::Style::HashEachMethods
+  include ::RuboCop::Cop::Lint::UnusedArgument
+  def autocorrect(node); end
+
+  def kv_each(node=T.unsafe(nil)); end
+
+  def on_block(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::HashEachMethods
+end
+
+class RuboCop::Cop::Style::HashSyntax
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def hash_rockets_check(pairs); end
+
+  def no_mixed_keys_check(pairs); end
+
+  def on_hash(node); end
+
+  def ruby19_check(pairs); end
+
+  def ruby19_no_mixed_keys_check(pairs); end
+  MSG_19 = ::T.let(nil, ::T.untyped)
+  MSG_HASH_ROCKETS = ::T.let(nil, ::T.untyped)
+  MSG_NO_MIXED_KEYS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::HashSyntax
+end
+
+class RuboCop::Cop::Style::HashTransformKeys
+  include ::RuboCop::Cop::HashTransformMethod
+  def on_bad_each_with_object(node=T.unsafe(nil)); end
+
+  def on_bad_hash_brackets_map(node=T.unsafe(nil)); end
+
+  def on_bad_map_to_h(node=T.unsafe(nil)); end
+end
+
+class RuboCop::Cop::Style::HashTransformKeys
+  extend ::RuboCop::Cop::TargetRubyVersion
+end
+
+class RuboCop::Cop::Style::HashTransformValues
+  include ::RuboCop::Cop::HashTransformMethod
+  def on_bad_each_with_object(node=T.unsafe(nil)); end
+
+  def on_bad_hash_brackets_map(node=T.unsafe(nil)); end
+
+  def on_bad_map_to_h(node=T.unsafe(nil)); end
+end
+
+class RuboCop::Cop::Style::HashTransformValues
+  extend ::RuboCop::Cop::TargetRubyVersion
+end
+
+class RuboCop::Cop::Style::IdenticalConditionalBranches
+  def on_case(node); end
+
+  def on_if(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::IdenticalConditionalBranches
+end
+
+class RuboCop::Cop::Style::IfCorrector
+end
+
+class RuboCop::Cop::Style::IfCorrector
+  extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper
+  extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper
+  def self.correct(cop, node); end
+
+  def self.move_assignment_inside_condition(node); end
+end
+
+class RuboCop::Cop::Style::IfInsideElse
+  def on_if(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::IfInsideElse
+end
+
+class RuboCop::Cop::Style::IfUnlessModifier
+  include ::RuboCop::Cop::StatementModifier
+  include ::RuboCop::Cop::LineLengthHelp
+  include ::RuboCop::Cop::IgnoredPattern
+  def autocorrect(node); end
+
+  def on_if(node); end
+  ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped)
+  MSG_USE_MODIFIER = ::T.let(nil, ::T.untyped)
+  MSG_USE_NORMAL = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::IfUnlessModifier
+end
+
+class RuboCop::Cop::Style::IfUnlessModifierOfIfUnless
+  include ::RuboCop::Cop::StatementModifier
+  def on_if(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::IfUnlessModifierOfIfUnless
+end
+
+class RuboCop::Cop::Style::IfWithSemicolon
+  include ::RuboCop::Cop::OnNormalIfUnless
+  def on_normal_if_unless(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::IfWithSemicolon
+end
+
+class RuboCop::Cop::Style::ImplicitRuntimeError
+  def implicit_runtime_error_raise_or_fail(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::ImplicitRuntimeError
+end
+
+class RuboCop::Cop::Style::InfiniteLoop
+  def after_leaving_scope(scope, _variable_table); end
+
+  def autocorrect(node); end
+
+  def join_force?(force_class); end
+
+  def on_until(node); end
+
+  def on_until_post(node); end
+
+  def on_while(node); end
+
+  def on_while_post(node); end
+  LEADING_SPACE = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::InfiniteLoop
+end
+
+class RuboCop::Cop::Style::InlineComment
+  def investigate(processed_source); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::InlineComment
+end
+
+class RuboCop::Cop::Style::InverseMethods
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def correct_inverse_block(node); end
+
+  def correct_inverse_method(node); end
+
+  def correct_inverse_selector(block, corrector); end
+
+  def inverse_block?(node=T.unsafe(nil)); end
+
+  def inverse_candidate?(node=T.unsafe(nil)); end
+
+  def on_block(node); end
+
+  def on_send(node); end
+  CAMEL_CASE = ::T.let(nil, ::T.untyped)
+  CLASS_COMPARISON_METHODS = ::T.let(nil, ::T.untyped)
+  EQUALITY_METHODS = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+  NEGATED_EQUALITY_METHODS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::InverseMethods
+end
+
+class RuboCop::Cop::Style::IpAddresses
+  include ::RuboCop::Cop::StringHelp
+  def correct_style_detected(); end
+
+  def offense?(node); end
+
+  def opposite_style_detected(); end
+  IPV6_MAX_SIZE = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::IpAddresses
+end
+
+class RuboCop::Cop::Style::Lambda
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def on_block(node); end
+  LITERAL_MESSAGE = ::T.let(nil, ::T.untyped)
+  METHOD_MESSAGE = ::T.let(nil, ::T.untyped)
+  OFFENDING_SELECTORS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::Lambda
+end
+
+class RuboCop::Cop::Style::LambdaCall
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def on_send(node); end
+end
+
+class RuboCop::Cop::Style::LambdaCall
+end
+
+class RuboCop::Cop::Style::LineEndConcatenation
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(operator_range); end
+
+  def investigate(processed_source); end
+  COMPLEX_STRING_BEGIN_TOKEN = ::T.let(nil, ::T.untyped)
+  COMPLEX_STRING_END_TOKEN = ::T.let(nil, ::T.untyped)
+  CONCAT_TOKEN_TYPES = ::T.let(nil, ::T.untyped)
+  HIGH_PRECEDENCE_OP_TOKEN_TYPES = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+  QUOTE_DELIMITERS = ::T.let(nil, ::T.untyped)
+  SIMPLE_STRING_TOKEN_TYPE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::LineEndConcatenation
+end
+
+class RuboCop::Cop::Style::MethodCallWithArgsParentheses
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::IgnoredMethods
+  include ::RuboCop::Cop::IgnoredPattern
+  def autocorrect(_node); end
+
+  def initialize(*_); end
+end
+
+module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses
+  def autocorrect(node); end
+
+  def message(_node=T.unsafe(nil)); end
+
+  def on_csend(node); end
+
+  def on_send(node); end
+
+  def on_super(node); end
+
+  def on_yield(node); end
+  TRAILING_WHITESPACE_REGEX = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses
+end
+
+module RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses
+  def autocorrect(node); end
+
+  def message(_node=T.unsafe(nil)); end
+
+  def on_csend(node); end
+
+  def on_send(node); end
+
+  def on_super(node); end
+
+  def on_yield(node); end
+end
+
+module RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses
+end
+
+class RuboCop::Cop::Style::MethodCallWithArgsParentheses
+end
+
+class RuboCop::Cop::Style::MethodCallWithoutArgsParentheses
+  include ::RuboCop::Cop::IgnoredMethods
+  def autocorrect(node); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::MethodCallWithoutArgsParentheses
+end
+
+class RuboCop::Cop::Style::MethodCalledOnDoEndBlock
+  include ::RuboCop::Cop::RangeHelp
+  def on_block(node); end
+
+  def on_csend(node); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::MethodCalledOnDoEndBlock
+end
+
+class RuboCop::Cop::Style::MethodDefParentheses
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+  MSG_MISSING = ::T.let(nil, ::T.untyped)
+  MSG_PRESENT = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::MethodDefParentheses
+end
+
+class RuboCop::Cop::Style::MethodMissingSuper
+  def on_def(node); end
+
+  def on_defs(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::MethodMissingSuper
+end
+
+class RuboCop::Cop::Style::MinMax
+  def autocorrect(node); end
+
+  def min_max_candidate(node=T.unsafe(nil)); end
+
+  def on_array(node); end
+
+  def on_return(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::MinMax
+end
+
+class RuboCop::Cop::Style::MissingElse
+  include ::RuboCop::Cop::OnNormalIfUnless
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def on_case(node); end
+
+  def on_normal_if_unless(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+  MSG_EMPTY = ::T.let(nil, ::T.untyped)
+  MSG_NIL = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::MissingElse
+end
+
+class RuboCop::Cop::Style::MissingRespondToMissing
+  def on_def(node); end
+
+  def on_defs(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::MissingRespondToMissing
+end
+
+class RuboCop::Cop::Style::MixinGrouping
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def on_class(node); end
+
+  def on_module(node); end
+  MIXIN_METHODS = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::MixinGrouping
+end
+
+class RuboCop::Cop::Style::MixinUsage
+  def include_statement(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+
+  def wrapped_macro_scope?(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::MixinUsage
+end
+
+class RuboCop::Cop::Style::ModuleFunction
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def extend_self_node?(node=T.unsafe(nil)); end
+
+  def module_function_node?(node=T.unsafe(nil)); end
+
+  def on_module(node); end
+
+  def private_directive?(node=T.unsafe(nil)); end
+  EXTEND_SELF_MSG = ::T.let(nil, ::T.untyped)
+  MODULE_FUNCTION_MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::ModuleFunction
+end
+
+class RuboCop::Cop::Style::MultilineBlockChain
+  include ::RuboCop::Cop::RangeHelp
+  def on_block(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::MultilineBlockChain
+end
+
+class RuboCop::Cop::Style::MultilineIfModifier
+  include ::RuboCop::Cop::StatementModifier
+  include ::RuboCop::Cop::Alignment
+  def autocorrect(node); end
+
+  def on_if(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::MultilineIfModifier
+end
+
+class RuboCop::Cop::Style::MultilineIfThen
+  include ::RuboCop::Cop::OnNormalIfUnless
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_normal_if_unless(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+  NON_MODIFIER_THEN = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::MultilineIfThen
+end
+
+class RuboCop::Cop::Style::MultilineMemoization
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def on_or_asgn(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::MultilineMemoization
+end
+
+class RuboCop::Cop::Style::MultilineMethodSignature
+  def on_def(node); end
+
+  def on_defs(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::MultilineMethodSignature
+end
+
+class RuboCop::Cop::Style::MultilineTernaryOperator
+  def on_if(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::MultilineTernaryOperator
+end
+
+class RuboCop::Cop::Style::MultilineWhenThen
+  include ::RuboCop::Cop::RangeHelp
+  def accept_node_type?(node); end
+
+  def autocorrect(node); end
+
+  def on_when(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::MultilineWhenThen
+end
+
+class RuboCop::Cop::Style::MultipleComparison
+  def on_or(node); end
+
+  def simple_comparison?(node=T.unsafe(nil)); end
+
+  def simple_double_comparison?(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::MultipleComparison
+end
+
+class RuboCop::Cop::Style::MutableConstant
+  include ::RuboCop::Cop::FrozenStringLiteral
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def on_casgn(node); end
+
+  def on_or_asgn(node); end
+
+  def operation_produces_immutable_object?(node=T.unsafe(nil)); end
+
+  def range_enclosed_in_parentheses?(node=T.unsafe(nil)); end
+
+  def splat_value(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::MutableConstant
+end
+
+class RuboCop::Cop::Style::NegatedIf
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::NegativeConditional
+  def autocorrect(node); end
+
+  def on_if(node); end
+end
+
+class RuboCop::Cop::Style::NegatedIf
+end
+
+class RuboCop::Cop::Style::NegatedUnless
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::NegativeConditional
+  def autocorrect(node); end
+
+  def on_if(node); end
+end
+
+class RuboCop::Cop::Style::NegatedUnless
+end
+
+class RuboCop::Cop::Style::NegatedWhile
+  include ::RuboCop::Cop::NegativeConditional
+  def autocorrect(node); end
+
+  def on_until(node); end
+
+  def on_while(node); end
+end
+
+class RuboCop::Cop::Style::NegatedWhile
+end
+
+class RuboCop::Cop::Style::NestedModifier
+  include ::RuboCop::Cop::RangeHelp
+  def add_parentheses_to_method_arguments(send_node); end
+
+  def autocorrect(node); end
+
+  def check(node); end
+
+  def left_hand_operand(node, operator); end
+
+  def modifier?(node); end
+
+  def new_expression(inner_node); end
+
+  def on_if(node); end
+
+  def on_until(node); end
+
+  def on_while(node); end
+
+  def replacement_operator(keyword); end
+
+  def requires_parens?(node); end
+
+  def right_hand_operand(node, left_hand_keyword); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::NestedModifier
+end
+
+class RuboCop::Cop::Style::NestedParenthesizedCalls
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(nested); end
+
+  def on_csend(node); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::NestedParenthesizedCalls
+end
+
+class RuboCop::Cop::Style::NestedTernaryOperator
+  def on_if(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::NestedTernaryOperator
+end
+
+class RuboCop::Cop::Style::Next
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::MinBodyLength
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def investigate(_processed_source); end
+
+  def on_block(node); end
+
+  def on_for(node); end
+
+  def on_until(node); end
+
+  def on_while(node); end
+  EXIT_TYPES = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::Next
+end
+
+class RuboCop::Cop::Style::NilComparison
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def nil_check?(node=T.unsafe(nil)); end
+
+  def nil_comparison?(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+  EXPLICIT_MSG = ::T.let(nil, ::T.untyped)
+  PREDICATE_MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::NilComparison
+end
+
+class RuboCop::Cop::Style::NonNilCheck
+  def autocorrect(node); end
+
+  def nil_check?(node=T.unsafe(nil)); end
+
+  def not_and_nil_check?(node=T.unsafe(nil)); end
+
+  def not_equal_to_nil?(node=T.unsafe(nil)); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+
+  def on_send(node); end
+
+  def unless_check?(node=T.unsafe(nil)); end
+end
+
+class RuboCop::Cop::Style::NonNilCheck
+end
+
+class RuboCop::Cop::Style::Not
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+  OPPOSITE_METHODS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::Not
+end
+
+class RuboCop::Cop::Style::NumericLiteralPrefix
+  include ::RuboCop::Cop::IntegerNode
+  def autocorrect(node); end
+
+  def on_int(node); end
+  BINARY_MSG = ::T.let(nil, ::T.untyped)
+  BINARY_REGEX = ::T.let(nil, ::T.untyped)
+  DECIMAL_MSG = ::T.let(nil, ::T.untyped)
+  DECIMAL_REGEX = ::T.let(nil, ::T.untyped)
+  HEX_MSG = ::T.let(nil, ::T.untyped)
+  HEX_REGEX = ::T.let(nil, ::T.untyped)
+  OCTAL_MSG = ::T.let(nil, ::T.untyped)
+  OCTAL_REGEX = ::T.let(nil, ::T.untyped)
+  OCTAL_ZERO_ONLY_MSG = ::T.let(nil, ::T.untyped)
+  OCTAL_ZERO_ONLY_REGEX = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::NumericLiteralPrefix
+end
+
+class RuboCop::Cop::Style::NumericLiterals
+  include ::RuboCop::Cop::ConfigurableMax
+  include ::RuboCop::Cop::IntegerNode
+  def autocorrect(node); end
+
+  def on_float(node); end
+
+  def on_int(node); end
+  DELIMITER_REGEXP = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::NumericLiterals
+end
+
+class RuboCop::Cop::Style::NumericPredicate
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::IgnoredMethods
+  def autocorrect(node); end
+
+  def comparison(node=T.unsafe(nil)); end
+
+  def inverted_comparison(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+
+  def predicate(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+  REPLACEMENTS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::NumericPredicate
+end
+
+class RuboCop::Cop::Style::OneLineConditional
+  include ::RuboCop::Cop::OnNormalIfUnless
+  def autocorrect(node); end
+
+  def on_normal_if_unless(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::OneLineConditional
+end
+
+class RuboCop::Cop::Style::OptionHash
+  def on_args(node); end
+
+  def option_hash(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::OptionHash
+end
+
+class RuboCop::Cop::Style::OptionalArguments
+  def on_def(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::OptionalArguments
+end
+
+class RuboCop::Cop::Style::OrAssignment
+  def autocorrect(node); end
+
+  def on_cvasgn(node); end
+
+  def on_gvasgn(node); end
+
+  def on_if(node); end
+
+  def on_ivasgn(node); end
+
+  def on_lvasgn(node); end
+
+  def ternary_assignment?(node=T.unsafe(nil)); end
+
+  def unless_assignment?(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::OrAssignment
+end
+
+class RuboCop::Cop::Style::ParallelAssignment
+  include ::RuboCop::Cop::RescueNode
+  def autocorrect(node); end
+
+  def implicit_self_getter?(node=T.unsafe(nil)); end
+
+  def on_masgn(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::ParallelAssignment::AssignmentSorter
+  include ::TSort
+  def accesses?(rhs, lhs); end
+
+  def dependency?(lhs, rhs); end
+
+  def initialize(assignments); end
+
+  def matching_calls(node0, param1, param2); end
+
+  def tsort_each_child(assignment); end
+
+  def uses_var?(node0, param1); end
+
+  def var_name(node=T.unsafe(nil)); end
+end
+
+class RuboCop::Cop::Style::ParallelAssignment::AssignmentSorter
+  extend ::RuboCop::NodePattern::Macros
+end
+
+class RuboCop::Cop::Style::ParallelAssignment::GenericCorrector
+  include ::RuboCop::Cop::Alignment
+  def assignment(); end
+
+  def config(); end
+
+  def correction(); end
+
+  def correction_range(); end
+
+  def initialize(node, config, new_elements); end
+
+  def node(); end
+end
+
+class RuboCop::Cop::Style::ParallelAssignment::GenericCorrector
+end
+
+class RuboCop::Cop::Style::ParallelAssignment::ModifierCorrector
+end
+
+class RuboCop::Cop::Style::ParallelAssignment::ModifierCorrector
+end
+
+class RuboCop::Cop::Style::ParallelAssignment::RescueCorrector
+end
+
+class RuboCop::Cop::Style::ParallelAssignment::RescueCorrector
+end
+
+class RuboCop::Cop::Style::ParallelAssignment
+end
+
+class RuboCop::Cop::Style::ParenthesesAroundCondition
+  include ::RuboCop::Cop::SafeAssignment
+  include ::RuboCop::Cop::Parentheses
+  def autocorrect(node); end
+
+  def control_op_condition(node=T.unsafe(nil)); end
+
+  def on_if(node); end
+
+  def on_until(node); end
+
+  def on_while(node); end
+end
+
+class RuboCop::Cop::Style::ParenthesesAroundCondition
+end
+
+class RuboCop::Cop::Style::PercentLiteralDelimiters
+  include ::RuboCop::Cop::PercentLiteral
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def message(node); end
+
+  def on_array(node); end
+
+  def on_dstr(node); end
+
+  def on_regexp(node); end
+
+  def on_str(node); end
+
+  def on_sym(node); end
+
+  def on_xstr(node); end
+end
+
+class RuboCop::Cop::Style::PercentLiteralDelimiters
+end
+
+class RuboCop::Cop::Style::PercentQLiterals
+  include ::RuboCop::Cop::PercentLiteral
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def on_str(node); end
+  LOWER_CASE_Q_MSG = ::T.let(nil, ::T.untyped)
+  UPPER_CASE_Q_MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::PercentQLiterals
+end
+
+class RuboCop::Cop::Style::PerlBackrefs
+  def autocorrect(node); end
+
+  def on_nth_ref(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::PerlBackrefs
+end
+
+class RuboCop::Cop::Style::PreferredHashMethods
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def on_csend(node); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+  OFFENDING_SELECTORS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::PreferredHashMethods
+end
+
+class RuboCop::Cop::Style::Proc
+  def autocorrect(node); end
+
+  def on_block(node); end
+
+  def proc_new?(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::Proc
+end
+
+class RuboCop::Cop::Style::RaiseArgs
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def on_send(node); end
+  COMPACT_MSG = ::T.let(nil, ::T.untyped)
+  EXPLODED_MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::RaiseArgs
+end
+
+class RuboCop::Cop::Style::RandomWithOffset
+  def autocorrect(node); end
+
+  def integer_op_rand?(node=T.unsafe(nil)); end
+
+  def namespace(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+
+  def rand_modified?(node=T.unsafe(nil)); end
+
+  def rand_op_integer?(node=T.unsafe(nil)); end
+
+  def random_call(node=T.unsafe(nil)); end
+
+  def to_int(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::RandomWithOffset
+end
+
+class RuboCop::Cop::Style::RedundantBegin
+  def autocorrect(node); end
+
+  def on_block(node); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::RedundantBegin
+end
+
+class RuboCop::Cop::Style::RedundantCapitalW
+  include ::RuboCop::Cop::PercentLiteral
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_array(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::RedundantCapitalW
+end
+
+class RuboCop::Cop::Style::RedundantCondition
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_if(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+  REDUNDANT_CONDITION = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::RedundantCondition
+end
+
+class RuboCop::Cop::Style::RedundantConditional
+  include ::RuboCop::Cop::Alignment
+  def autocorrect(node); end
+
+  def on_if(node); end
+
+  def redundant_condition?(node=T.unsafe(nil)); end
+
+  def redundant_condition_inverted?(node=T.unsafe(nil)); end
+  COMPARISON_OPERATORS = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::RedundantConditional
+end
+
+class RuboCop::Cop::Style::RedundantException
+  def autocorrect(node); end
+
+  def compact?(node=T.unsafe(nil)); end
+
+  def exploded?(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+  MSG_1 = ::T.let(nil, ::T.untyped)
+  MSG_2 = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::RedundantException
+end
+
+class RuboCop::Cop::Style::RedundantFreeze
+  include ::RuboCop::Cop::FrozenStringLiteral
+  def autocorrect(node); end
+
+  def on_send(node); end
+
+  def operation_produces_immutable_object?(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::RedundantFreeze
+end
+
+class RuboCop::Cop::Style::RedundantInterpolation
+  include ::RuboCop::Cop::PercentLiteral
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_dstr(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::RedundantInterpolation
+end
+
+class RuboCop::Cop::Style::RedundantParentheses
+  include ::RuboCop::Cop::Parentheses
+  def arg_in_call_with_block?(node=T.unsafe(nil)); end
+
+  def autocorrect(node); end
+
+  def first_send_argument?(node=T.unsafe(nil)); end
+
+  def first_super_argument?(node=T.unsafe(nil)); end
+
+  def method_node_and_args(node=T.unsafe(nil)); end
+
+  def on_begin(node); end
+
+  def range_end?(node=T.unsafe(nil)); end
+
+  def rescue?(node=T.unsafe(nil)); end
+
+  def square_brackets?(node=T.unsafe(nil)); end
+end
+
+class RuboCop::Cop::Style::RedundantParentheses
+end
+
+class RuboCop::Cop::Style::RedundantPercentQ
+  def autocorrect(node); end
+
+  def on_dstr(node); end
+
+  def on_str(node); end
+  DYNAMIC_MSG = ::T.let(nil, ::T.untyped)
+  EMPTY = ::T.let(nil, ::T.untyped)
+  ESCAPED_NON_BACKSLASH = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+  PERCENT_CAPITAL_Q = ::T.let(nil, ::T.untyped)
+  PERCENT_Q = ::T.let(nil, ::T.untyped)
+  QUOTE = ::T.let(nil, ::T.untyped)
+  SINGLE_QUOTE = ::T.let(nil, ::T.untyped)
+  STRING_INTERPOLATION_REGEXP = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::RedundantPercentQ
+end
+
+class RuboCop::Cop::Style::RedundantReturn
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+  MULTI_RETURN_MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::RedundantReturn
+end
+
+class RuboCop::Cop::Style::RedundantSelf
+  def autocorrect(node); end
+
+  def on_and_asgn(node); end
+
+  def on_args(node); end
+
+  def on_block(node); end
+
+  def on_blockarg(node); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+
+  def on_lvasgn(node); end
+
+  def on_masgn(node); end
+
+  def on_op_asgn(node); end
+
+  def on_or_asgn(node); end
+
+  def on_send(node); end
+  KERNEL_METHODS = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::RedundantSelf
+end
+
+class RuboCop::Cop::Style::RedundantSort
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_send(node); end
+
+  def redundant_sort?(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::RedundantSort
+end
+
+class RuboCop::Cop::Style::RedundantSortBy
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_block(node); end
+
+  def redundant_sort_by(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::RedundantSortBy
+end
+
+class RuboCop::Cop::Style::RegexpLiteral
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_regexp(node); end
+  MSG_USE_PERCENT_R = ::T.let(nil, ::T.untyped)
+  MSG_USE_SLASHES = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::RegexpLiteral
+end
+
+class RuboCop::Cop::Style::RescueModifier
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::RescueNode
+  def autocorrect(node); end
+
+  def on_resbody(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::RescueModifier
+end
+
+class RuboCop::Cop::Style::RescueStandardError
+  include ::RuboCop::Cop::RescueNode
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_resbody(node); end
+
+  def rescue_standard_error?(node=T.unsafe(nil)); end
+
+  def rescue_without_error_class?(node=T.unsafe(nil)); end
+  MSG_EXPLICIT = ::T.let(nil, ::T.untyped)
+  MSG_IMPLICIT = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::RescueStandardError
+end
+
+class RuboCop::Cop::Style::ReturnNil
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def chained_send?(node=T.unsafe(nil)); end
+
+  def define_method?(node=T.unsafe(nil)); end
+
+  def on_return(node); end
+
+  def return_nil_node?(node=T.unsafe(nil)); end
+
+  def return_node?(node=T.unsafe(nil)); end
+  RETURN_MSG = ::T.let(nil, ::T.untyped)
+  RETURN_NIL_MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::ReturnNil
+end
+
+class RuboCop::Cop::Style::SafeNavigation
+  include ::RuboCop::Cop::NilMethods
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def check_node(node); end
+
+  def modifier_if_safe_navigation_candidate(node=T.unsafe(nil)); end
+
+  def not_nil_check?(node=T.unsafe(nil)); end
+
+  def on_and(node); end
+
+  def on_if(node); end
+
+  def use_var_only_in_unless_modifier?(node, variable); end
+  LOGIC_JUMP_KEYWORDS = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::SafeNavigation
+end
+
+class RuboCop::Cop::Style::Sample
+  def autocorrect(node); end
+
+  def on_send(node); end
+
+  def sample_candidate?(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::Sample
+end
+
+class RuboCop::Cop::Style::SelfAssignment
+  def autocorrect(node); end
+
+  def on_cvasgn(node); end
+
+  def on_ivasgn(node); end
+
+  def on_lvasgn(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+  OPS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::SelfAssignment
+end
+
+class RuboCop::Cop::Style::Semicolon
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(range); end
+
+  def investigate(processed_source); end
+
+  def on_begin(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::Semicolon
+end
+
+class RuboCop::Cop::Style::Send
+  def on_csend(node); end
+
+  def on_send(node); end
+
+  def sending?(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::Send
+end
+
+class RuboCop::Cop::Style::SignalException
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def custom_fail_methods(node0); end
+
+  def investigate(processed_source); end
+
+  def kernel_call?(node=T.unsafe(nil), param1); end
+
+  def on_rescue(node); end
+
+  def on_send(node); end
+  FAIL_MSG = ::T.let(nil, ::T.untyped)
+  RAISE_MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::SignalException
+end
+
+class RuboCop::Cop::Style::SingleLineBlockParams
+  def on_block(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::SingleLineBlockParams
+end
+
+class RuboCop::Cop::Style::SingleLineMethods
+  include ::RuboCop::Cop::Alignment
+  def autocorrect(node); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::SingleLineMethods
+end
+
+class RuboCop::Cop::Style::SpecialGlobalVars
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def message(node); end
+
+  def on_gvar(node); end
+  ENGLISH_VARS = ::T.let(nil, ::T.untyped)
+  MSG_BOTH = ::T.let(nil, ::T.untyped)
+  MSG_ENGLISH = ::T.let(nil, ::T.untyped)
+  MSG_REGULAR = ::T.let(nil, ::T.untyped)
+  NON_ENGLISH_VARS = ::T.let(nil, ::T.untyped)
+  PERL_VARS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::SpecialGlobalVars
+end
+
+class RuboCop::Cop::Style::StabbyLambdaParentheses
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  def autocorrect(node); end
+
+  def on_send(node); end
+  MSG_NO_REQUIRE = ::T.let(nil, ::T.untyped)
+  MSG_REQUIRE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::StabbyLambdaParentheses
+end
+
+class RuboCop::Cop::Style::StderrPuts
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_send(node); end
+
+  def stderr_puts?(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::StderrPuts
+end
+
+class RuboCop::Cop::Style::StringHashKeys
+  def autocorrect(node); end
+
+  def on_pair(node); end
+
+  def receive_environments_method?(node=T.unsafe(nil)); end
+
+  def string_hash_key?(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::StringHashKeys
+end
+
+class RuboCop::Cop::Style::StringLiterals
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::StringLiteralsHelp
+  include ::RuboCop::Cop::StringHelp
+  def autocorrect(node); end
+
+  def on_dstr(node); end
+  MSG_INCONSISTENT = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::StringLiterals
+end
+
+class RuboCop::Cop::Style::StringLiteralsInInterpolation
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::StringLiteralsHelp
+  include ::RuboCop::Cop::StringHelp
+  def autocorrect(node); end
+end
+
+class RuboCop::Cop::Style::StringLiteralsInInterpolation
+end
+
+class RuboCop::Cop::Style::StringMethods
+  include ::RuboCop::Cop::MethodPreference
+  def autocorrect(node); end
+
+  def on_csend(node); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::StringMethods
+end
+
+class RuboCop::Cop::Style::Strip
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def lstrip_rstrip(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::Strip
+end
+
+class RuboCop::Cop::Style::StructInheritance
+  def on_class(node); end
+
+  def struct_constructor?(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::StructInheritance
+end
+
+class RuboCop::Cop::Style::SymbolArray
+  include ::RuboCop::Cop::ArrayMinSize
+  include ::RuboCop::Cop::ArraySyntax
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::PercentArray
+  def autocorrect(node); end
+
+  def on_array(node); end
+  ARRAY_MSG = ::T.let(nil, ::T.untyped)
+  PERCENT_MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::SymbolArray
+  def self.largest_brackets(); end
+
+  def self.largest_brackets=(largest_brackets); end
+end
+
+class RuboCop::Cop::Style::SymbolLiteral
+  def autocorrect(node); end
+
+  def on_sym(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::SymbolLiteral
+end
+
+class RuboCop::Cop::Style::SymbolProc
+  include ::RuboCop::Cop::RangeHelp
+  include ::RuboCop::Cop::IgnoredMethods
+  def autocorrect(node); end
+
+  def destructuring_block_argument?(argument_node); end
+
+  def on_block(node); end
+
+  def proc_node?(node=T.unsafe(nil)); end
+
+  def symbol_proc?(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+  SUPER_TYPES = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::SymbolProc
+end
+
+class RuboCop::Cop::Style::TernaryCorrector
+end
+
+class RuboCop::Cop::Style::TernaryCorrector
+  extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper
+  extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper
+  def self.correct(node); end
+
+  def self.move_assignment_inside_condition(node); end
+end
+
+class RuboCop::Cop::Style::TernaryParentheses
+  include ::RuboCop::Cop::SafeAssignment
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::SurroundingSpace
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def method_name(node=T.unsafe(nil)); end
+
+  def on_if(node); end
+
+  def only_closing_parenthesis_is_last_line?(condition); end
+  MSG = ::T.let(nil, ::T.untyped)
+  MSG_COMPLEX = ::T.let(nil, ::T.untyped)
+  NON_COMPLEX_TYPES = ::T.let(nil, ::T.untyped)
+  VARIABLE_TYPES = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::TernaryParentheses
+end
+
+class RuboCop::Cop::Style::TrailingBodyOnClass
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::TrailingBody
+  def autocorrect(node); end
+
+  def on_class(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::TrailingBodyOnClass
+end
+
+class RuboCop::Cop::Style::TrailingBodyOnMethodDefinition
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::TrailingBody
+  def autocorrect(node); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::TrailingBodyOnMethodDefinition
+end
+
+class RuboCop::Cop::Style::TrailingBodyOnModule
+  include ::RuboCop::Cop::Alignment
+  include ::RuboCop::Cop::TrailingBody
+  def autocorrect(node); end
+
+  def on_module(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::TrailingBodyOnModule
+end
+
+class RuboCop::Cop::Style::TrailingCommaInArguments
+  include ::RuboCop::Cop::TrailingComma
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(range); end
+
+  def on_csend(node); end
+
+  def on_send(node); end
+end
+
+class RuboCop::Cop::Style::TrailingCommaInArguments
+end
+
+class RuboCop::Cop::Style::TrailingCommaInArrayLiteral
+  include ::RuboCop::Cop::TrailingComma
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(range); end
+
+  def on_array(node); end
+end
+
+class RuboCop::Cop::Style::TrailingCommaInArrayLiteral
+end
+
+class RuboCop::Cop::Style::TrailingCommaInHashLiteral
+  include ::RuboCop::Cop::TrailingComma
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(range); end
+
+  def on_hash(node); end
+end
+
+class RuboCop::Cop::Style::TrailingCommaInHashLiteral
+end
+
+class RuboCop::Cop::Style::TrailingMethodEndStatement
+  include ::RuboCop::Cop::Alignment
+  def autocorrect(node); end
+
+  def on_def(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::TrailingMethodEndStatement
+end
+
+class RuboCop::Cop::Style::TrailingUnderscoreVariable
+  include ::RuboCop::Cop::SurroundingSpace
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_masgn(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+  UNDERSCORE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::TrailingUnderscoreVariable
+end
+
+class RuboCop::Cop::Style::TrivialAccessors
+  def autocorrect(node); end
+
+  def looks_like_trivial_writer?(node=T.unsafe(nil)); end
+
+  def on_def(node); end
+
+  def on_defs(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::TrivialAccessors
+end
+
+class RuboCop::Cop::Style::UnlessElse
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def on_if(node); end
+
+  def range_between_condition_and_else(node, condition); end
+
+  def range_between_else_and_end(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::UnlessElse
+end
+
+class RuboCop::Cop::Style::UnpackFirst
+  def autocorrect(node); end
+
+  def on_send(node); end
+
+  def unpack_and_first_element?(node=T.unsafe(nil)); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::UnpackFirst
+  extend ::RuboCop::Cop::TargetRubyVersion
+end
+
+class RuboCop::Cop::Style::VariableInterpolation
+  include ::RuboCop::Cop::Interpolation
+  def autocorrect(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::VariableInterpolation
+end
+
+class RuboCop::Cop::Style::WhenThen
+  def autocorrect(node); end
+
+  def on_when(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::WhenThen
+end
+
+class RuboCop::Cop::Style::WhileUntilDo
+  def autocorrect(node); end
+
+  def handle(node); end
+
+  def on_until(node); end
+
+  def on_while(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::WhileUntilDo
+end
+
+class RuboCop::Cop::Style::WhileUntilModifier
+  include ::RuboCop::Cop::StatementModifier
+  def autocorrect(node); end
+
+  def on_until(node); end
+
+  def on_while(node); end
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::WhileUntilModifier
+end
+
+class RuboCop::Cop::Style::WordArray
+  include ::RuboCop::Cop::ArrayMinSize
+  include ::RuboCop::Cop::ArraySyntax
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::PercentArray
+  def autocorrect(node); end
+
+  def on_array(node); end
+  ARRAY_MSG = ::T.let(nil, ::T.untyped)
+  PERCENT_MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::WordArray
+  def self.largest_brackets(); end
+
+  def self.largest_brackets=(largest_brackets); end
+end
+
+class RuboCop::Cop::Style::YodaCondition
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  def autocorrect(node); end
+
+  def file_constant_equal_program_name?(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+  EQUALITY_OPERATORS = ::T.let(nil, ::T.untyped)
+  MSG = ::T.let(nil, ::T.untyped)
+  NONCOMMUTATIVE_OPERATORS = ::T.let(nil, ::T.untyped)
+  PROGRAM_NAMES = ::T.let(nil, ::T.untyped)
+  REVERSE_COMPARISON = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::YodaCondition
+end
+
+class RuboCop::Cop::Style::ZeroLengthPredicate
+  def autocorrect(node); end
+
+  def non_polymorphic_collection?(node=T.unsafe(nil)); end
+
+  def nonzero_length_predicate(node=T.unsafe(nil)); end
+
+  def on_send(node); end
+
+  def other_receiver(node=T.unsafe(nil)); end
+
+  def zero_length_predicate(node=T.unsafe(nil)); end
+
+  def zero_length_receiver(node=T.unsafe(nil)); end
+  NONZERO_MSG = ::T.let(nil, ::T.untyped)
+  ZERO_MSG = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Style::ZeroLengthPredicate
+end
+
+module RuboCop::Cop::Style
+end
+
+module RuboCop::Cop::SurroundingSpace
+  include ::RuboCop::Cop::RangeHelp
+  NO_SPACE_COMMAND = ::T.let(nil, ::T.untyped)
+  SINGLE_SPACE_REGEXP = ::T.let(nil, ::T.untyped)
+  SPACE_COMMAND = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::Cop::SurroundingSpace
+end
+
+module RuboCop::Cop::TargetRubyVersion
+  def minimum_target_ruby_version(version); end
+
+  def support_target_ruby_version?(version); end
+end
+
+module RuboCop::Cop::TargetRubyVersion
+end
+
+class RuboCop::Cop::Team
+  def autocorrect(buffer, cops); end
+
+  def autocorrect?(); end
+
+  def cops(); end
+
+  def debug?(); end
+
+  def errors(); end
+
+  def external_dependency_checksum(); end
+
+  def forces(); end
+
+  def forces_for(cops); end
+
+  def initialize(cop_classes, config, options=T.unsafe(nil)); end
+
+  def inspect_file(processed_source); end
+
+  def updated_source_file(); end
+
+  def updated_source_file?(); end
+
+  def warnings(); end
+  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Team::Investigation
+  def errors(); end
+
+  def errors=(_); end
+
+  def offenses(); end
+
+  def offenses=(_); end
+end
+
+class RuboCop::Cop::Team::Investigation
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+class RuboCop::Cop::Team
+end
+
+module RuboCop::Cop::TooManyLines
+  include ::RuboCop::Cop::CodeLength
+  include ::RuboCop::Cop::ConfigurableMax
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::Cop::TooManyLines
+end
+
+module RuboCop::Cop::TrailingBody
+  def body_on_first_line?(node, body); end
+
+  def first_part_of(body); end
+
+  def trailing_body?(node); end
+end
+
+module RuboCop::Cop::TrailingBody
+end
+
+module RuboCop::Cop::TrailingComma
+  include ::RuboCop::Cop::ConfigurableEnforcedStyle
+  include ::RuboCop::Cop::RangeHelp
+  MSG = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::Cop::TrailingComma
+end
+
+module RuboCop::Cop::UncommunicativeName
+  def check(node, args); end
+  CASE_MSG = ::T.let(nil, ::T.untyped)
+  FORBIDDEN_MSG = ::T.let(nil, ::T.untyped)
+  LENGTH_MSG = ::T.let(nil, ::T.untyped)
+  NUM_MSG = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::Cop::UncommunicativeName
+end
+
+class RuboCop::Cop::UnusedArgCorrector
+end
+
+class RuboCop::Cop::UnusedArgCorrector
+  extend ::RuboCop::Cop::RangeHelp
+  def self.correct(processed_source, node); end
+
+  def self.correct_for_blockarg_type(node); end
+
+  def self.processed_source(); end
+end
+
+module RuboCop::Cop::Util
+  include ::RuboCop::PathUtil
+  LITERAL_REGEX = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::Cop::Util
+  def self.begins_its_line?(range); end
+
+  def self.comment_line?(line_source); end
+
+  def self.double_quotes_required?(string); end
+
+  def self.escape_string(string); end
+
+  def self.first_part_of_call_chain(node); end
+
+  def self.interpret_string_escapes(string); end
+
+  def self.line_range(node); end
+
+  def self.needs_escaping?(string); end
+
+  def self.on_node(syms, sexp, excludes=T.unsafe(nil), &block); end
+
+  def self.parentheses?(node); end
+
+  def self.same_line?(node1, node2); end
+
+  def self.to_string_literal(string); end
+
+  def self.to_supported_styles(enforced_style); end
+
+  def self.tokens(node); end
+
+  def self.trim_string_interporation_escape_character(str); end
+end
+
+module RuboCop::Cop::Utils
+end
+
+class RuboCop::Cop::Utils::FormatString
+  def format_sequences(); end
+
+  def initialize(string); end
+
+  def max_digit_dollar_num(); end
+
+  def named_interpolation?(); end
+  DIGIT_DOLLAR = ::T.let(nil, ::T.untyped)
+  FLAG = ::T.let(nil, ::T.untyped)
+  NAME = ::T.let(nil, ::T.untyped)
+  NUMBER = ::T.let(nil, ::T.untyped)
+  NUMBER_ARG = ::T.let(nil, ::T.untyped)
+  PRECISION = ::T.let(nil, ::T.untyped)
+  SEQUENCE = ::T.let(nil, ::T.untyped)
+  TEMPLATE_NAME = ::T.let(nil, ::T.untyped)
+  TYPE = ::T.let(nil, ::T.untyped)
+  WIDTH = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::Utils::FormatString::FormatSequence
+  def annotated?(); end
+
+  def arity(); end
+
+  def begin_pos(); end
+
+  def end_pos(); end
+
+  def flags(); end
+
+  def initialize(match); end
+
+  def max_digit_dollar_num(); end
+
+  def name(); end
+
+  def percent?(); end
+
+  def precision(); end
+
+  def style(); end
+
+  def template?(); end
+
+  def type(); end
+
+  def width(); end
+end
+
+class RuboCop::Cop::Utils::FormatString::FormatSequence
+end
+
+class RuboCop::Cop::Utils::FormatString
+end
+
+module RuboCop::Cop::Utils
+end
+
+class RuboCop::Cop::VariableForce
+  def investigate(processed_source); end
+
+  def process_node(node); end
+
+  def variable_table(); end
+  ARGUMENT_DECLARATION_TYPES = ::T.let(nil, ::T.untyped)
+  LOGICAL_OPERATOR_ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped)
+  LOOP_TYPES = ::T.let(nil, ::T.untyped)
+  MULTIPLE_ASSIGNMENT_TYPE = ::T.let(nil, ::T.untyped)
+  OPERATOR_ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped)
+  POST_CONDITION_LOOP_TYPES = ::T.let(nil, ::T.untyped)
+  REGEXP_NAMED_CAPTURE_TYPE = ::T.let(nil, ::T.untyped)
+  RESCUE_TYPE = ::T.let(nil, ::T.untyped)
+  SCOPE_TYPES = ::T.let(nil, ::T.untyped)
+  SEND_TYPE = ::T.let(nil, ::T.untyped)
+  TWISTED_SCOPE_TYPES = ::T.let(nil, ::T.untyped)
+  VARIABLE_ASSIGNMENT_TYPE = ::T.let(nil, ::T.untyped)
+  VARIABLE_ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped)
+  VARIABLE_REFERENCE_TYPE = ::T.let(nil, ::T.untyped)
+  ZERO_ARITY_SUPER_TYPE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::VariableForce::Assignment
+  include ::RuboCop::Cop::VariableForce::Branchable
+  def initialize(node, variable); end
+
+  def meta_assignment_node(); end
+
+  def multiple_assignment?(); end
+
+  def name(); end
+
+  def node(); end
+
+  def operator(); end
+
+  def operator_assignment?(); end
+
+  def reference!(node); end
+
+  def referenced(); end
+
+  def referenced?(); end
+
+  def references(); end
+
+  def regexp_named_capture?(); end
+
+  def scope(); end
+
+  def used?(); end
+
+  def variable(); end
+  MULTIPLE_LEFT_HAND_SIDE_TYPE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::VariableForce::Assignment
+end
+
+class RuboCop::Cop::VariableForce::AssignmentReference
+  def assignment?(); end
+
+  def node(); end
+
+  def node=(_); end
+end
+
+class RuboCop::Cop::VariableForce::AssignmentReference
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+module RuboCop::Cop::VariableForce::Branch
+  CLASSES_BY_TYPE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::VariableForce::Branch::And
+  include ::RuboCop::Cop::VariableForce::Branch::LogicalOperator
+  def left_body?(); end
+
+  def right_body?(); end
+end
+
+class RuboCop::Cop::VariableForce::Branch::And
+end
+
+class RuboCop::Cop::VariableForce::Branch::Base
+  def ==(other); end
+
+  def always_run?(); end
+
+  def branched?(); end
+
+  def child_node(); end
+
+  def child_node=(_); end
+
+  def control_node(); end
+
+  def each_ancestor(include_self: T.unsafe(nil), &block); end
+
+  def eql?(other); end
+
+  def exclusive_with?(other); end
+
+  def may_jump_to_other_branch?(); end
+
+  def may_run_incompletely?(); end
+
+  def parent(); end
+
+  def scope(); end
+
+  def scope=(_); end
+end
+
+class RuboCop::Cop::VariableForce::Branch::Base
+  def self.[](*_); end
+
+  def self.classes(); end
+
+  def self.define_predicate(name, child_index: T.unsafe(nil)); end
+
+  def self.inherited(subclass); end
+
+  def self.members(); end
+
+  def self.type(); end
+end
+
+class RuboCop::Cop::VariableForce::Branch::Case
+  def else_body?(); end
+
+  def target?(); end
+
+  def when_clause?(); end
+end
+
+class RuboCop::Cop::VariableForce::Branch::Case
+end
+
+class RuboCop::Cop::VariableForce::Branch::Ensure
+  include ::RuboCop::Cop::VariableForce::Branch::ExceptionHandler
+  def ensure_body?(); end
+
+  def main_body?(); end
+end
+
+class RuboCop::Cop::VariableForce::Branch::Ensure
+end
+
+module RuboCop::Cop::VariableForce::Branch::ExceptionHandler
+  def may_jump_to_other_branch?(); end
+
+  def may_run_incompletely?(); end
+end
+
+module RuboCop::Cop::VariableForce::Branch::ExceptionHandler
+end
+
+class RuboCop::Cop::VariableForce::Branch::For
+  def collection?(); end
+
+  def element?(); end
+
+  def loop_body?(); end
+end
+
+class RuboCop::Cop::VariableForce::Branch::For
+end
+
+class RuboCop::Cop::VariableForce::Branch::If
+  include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional
+  def falsey_body?(); end
+
+  def truthy_body?(); end
+end
+
+class RuboCop::Cop::VariableForce::Branch::If
+end
+
+module RuboCop::Cop::VariableForce::Branch::LogicalOperator
+  def always_run?(); end
+end
+
+module RuboCop::Cop::VariableForce::Branch::LogicalOperator
+end
+
+class RuboCop::Cop::VariableForce::Branch::Or
+  include ::RuboCop::Cop::VariableForce::Branch::LogicalOperator
+  def left_body?(); end
+
+  def right_body?(); end
+end
+
+class RuboCop::Cop::VariableForce::Branch::Or
+end
+
+class RuboCop::Cop::VariableForce::Branch::Rescue
+  include ::RuboCop::Cop::VariableForce::Branch::ExceptionHandler
+  def else_body?(); end
+
+  def main_body?(); end
+
+  def rescue_clause?(); end
+end
+
+class RuboCop::Cop::VariableForce::Branch::Rescue
+end
+
+module RuboCop::Cop::VariableForce::Branch::SimpleConditional
+  def always_run?(); end
+
+  def conditional_clause?(); end
+end
+
+module RuboCop::Cop::VariableForce::Branch::SimpleConditional
+end
+
+class RuboCop::Cop::VariableForce::Branch::Until
+  include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional
+  def loop_body?(); end
+end
+
+class RuboCop::Cop::VariableForce::Branch::Until
+end
+
+class RuboCop::Cop::VariableForce::Branch::UntilPost
+  include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional
+  def loop_body?(); end
+end
+
+class RuboCop::Cop::VariableForce::Branch::UntilPost
+end
+
+class RuboCop::Cop::VariableForce::Branch::While
+  include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional
+  def loop_body?(); end
+end
+
+class RuboCop::Cop::VariableForce::Branch::While
+end
+
+class RuboCop::Cop::VariableForce::Branch::WhilePost
+  include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional
+  def loop_body?(); end
+end
+
+class RuboCop::Cop::VariableForce::Branch::WhilePost
+end
+
+module RuboCop::Cop::VariableForce::Branch
+  def self.of(target_node, scope: T.unsafe(nil)); end
+end
+
+module RuboCop::Cop::VariableForce::Branchable
+  def branch(); end
+
+  def run_exclusively_with?(other); end
+end
+
+module RuboCop::Cop::VariableForce::Branchable
+end
+
+class RuboCop::Cop::VariableForce::Reference
+  include ::RuboCop::Cop::VariableForce::Branchable
+  def explicit?(); end
+
+  def initialize(node, scope); end
+
+  def node(); end
+
+  def scope(); end
+  VARIABLE_REFERENCE_TYPES = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::VariableForce::Reference
+end
+
+class RuboCop::Cop::VariableForce::Scope
+  def ==(other); end
+
+  def body_node(); end
+
+  def each_node(&block); end
+
+  def include?(target_node); end
+
+  def initialize(node); end
+
+  def naked_top_level(); end
+
+  def naked_top_level?(); end
+
+  def name(); end
+
+  def node(); end
+
+  def variables(); end
+  OUTER_SCOPE_CHILD_INDICES = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::VariableForce::Scope
+end
+
+class RuboCop::Cop::VariableForce::Variable
+  def argument?(); end
+
+  def assign(node); end
+
+  def assignments(); end
+
+  def block_argument?(); end
+
+  def capture_with_block!(); end
+
+  def captured_by_block(); end
+
+  def captured_by_block?(); end
+
+  def declaration_node(); end
+
+  def explicit_block_local_variable?(); end
+
+  def in_modifier_if?(assignment); end
+
+  def initialize(name, declaration_node, scope); end
+
+  def keyword_argument?(); end
+
+  def method_argument?(); end
+
+  def name(); end
+
+  def reference!(node); end
+
+  def referenced?(); end
+
+  def references(); end
+
+  def scope(); end
+
+  def should_be_unused?(); end
+
+  def used?(); end
+  VARIABLE_DECLARATION_TYPES = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Cop::VariableForce::Variable
+end
+
+class RuboCop::Cop::VariableForce::VariableReference
+  def assignment?(); end
+
+  def name(); end
+
+  def name=(_); end
+end
+
+class RuboCop::Cop::VariableForce::VariableReference
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+class RuboCop::Cop::VariableForce::VariableTable
+  def accessible_variables(); end
+
+  def assign_to_variable(name, node); end
+
+  def current_scope(); end
+
+  def current_scope_level(); end
+
+  def declare_variable(name, node); end
+
+  def find_variable(name); end
+
+  def initialize(hook_receiver=T.unsafe(nil)); end
+
+  def invoke_hook(hook_name, *args); end
+
+  def pop_scope(); end
+
+  def push_scope(scope_node); end
+
+  def reference_variable(name, node); end
+
+  def scope_stack(); end
+
+  def variable_exist?(name); end
+end
+
+class RuboCop::Cop::VariableForce::VariableTable
+end
+
+class RuboCop::Cop::VariableForce
+end
+
+module RuboCop::Cop
+end
+
+class RuboCop::Error
+end
+
+class RuboCop::Error
+end
+
+class RuboCop::ErrorWithAnalyzedFileLocation
+  def column(); end
+
+  def cop(); end
+
+  def initialize(cause:, node:, cop:); end
+
+  def line(); end
+end
+
+class RuboCop::ErrorWithAnalyzedFileLocation
+end
+
+module RuboCop::FileFinder
+  def find_file_upwards(filename, start_dir); end
+
+  def find_files_upwards(filename, start_dir); end
+end
+
+module RuboCop::FileFinder
+  def self.root_level=(level); end
+
+  def self.root_level?(path); end
+end
+
+module RuboCop::Formatter
+end
+
+class RuboCop::Formatter::AutoGenConfigFormatter
+end
+
+class RuboCop::Formatter::AutoGenConfigFormatter
+end
+
+class RuboCop::Formatter::BaseFormatter
+  def file_finished(file, offenses); end
+
+  def file_started(file, options); end
+
+  def finished(inspected_files); end
+
+  def initialize(output, options=T.unsafe(nil)); end
+
+  def options(); end
+
+  def output(); end
+
+  def started(target_files); end
+end
+
+class RuboCop::Formatter::BaseFormatter
+end
+
+class RuboCop::Formatter::ClangStyleFormatter
+  ELLIPSES = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Formatter::ClangStyleFormatter
+end
+
+module RuboCop::Formatter::Colorizable
+  def black(string); end
+
+  def blue(string); end
+
+  def colorize(string, *args); end
+
+  def cyan(string); end
+
+  def green(string); end
+
+  def magenta(string); end
+
+  def rainbow(); end
+
+  def red(string); end
+
+  def white(string); end
+
+  def yellow(string); end
+end
+
+module RuboCop::Formatter::Colorizable
+end
+
+class RuboCop::Formatter::DisabledConfigFormatter
+  def file_started(_file, _file_info); end
+
+  def finished(_inspected_files); end
+  HEADING = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Formatter::DisabledConfigFormatter
+  def self.config_to_allow_offenses(); end
+
+  def self.config_to_allow_offenses=(config_to_allow_offenses); end
+
+  def self.detected_styles(); end
+
+  def self.detected_styles=(detected_styles); end
+end
+
+class RuboCop::Formatter::DisabledLinesFormatter
+  include ::RuboCop::PathUtil
+  include ::RuboCop::Formatter::Colorizable
+  def cop_disabled_line_ranges(); end
+
+  def finished(_inspected_files); end
+
+  def started(_target_files); end
+end
+
+class RuboCop::Formatter::DisabledLinesFormatter
+end
+
+class RuboCop::Formatter::EmacsStyleFormatter
+end
+
+class RuboCop::Formatter::EmacsStyleFormatter
+end
+
+class RuboCop::Formatter::FileListFormatter
+end
+
+class RuboCop::Formatter::FileListFormatter
+end
+
+class RuboCop::Formatter::FormatterSet
+  def add_formatter(formatter_type, output_path=T.unsafe(nil)); end
+
+  def close_output_files(); end
+
+  def file_finished(file, offenses); end
+
+  def file_started(file, options); end
+
+  def finished(*args); end
+
+  def initialize(options=T.unsafe(nil)); end
+
+  def started(*args); end
+  BUILTIN_FORMATTERS_FOR_KEYS = ::T.let(nil, ::T.untyped)
+  FORMATTER_APIS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Formatter::FormatterSet
+end
+
+class RuboCop::Formatter::FuubarStyleFormatter
+  def initialize(*output); end
+
+  def progressbar_color(); end
+
+  def started(target_files); end
+
+  def with_color(); end
+  RESET_SEQUENCE = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Formatter::FuubarStyleFormatter
+end
+
+class RuboCop::Formatter::HTMLFormatter
+  def files(); end
+
+  def render_html(); end
+
+  def summary(); end
+  ELLIPSES = ::T.let(nil, ::T.untyped)
+  TEMPLATE_PATH = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Formatter::HTMLFormatter::Color
+  def alpha(); end
+
+  def alpha=(_); end
+
+  def blue(); end
+
+  def blue=(_); end
+
+  def fade_out(amount); end
+
+  def green(); end
+
+  def green=(_); end
+
+  def red(); end
+
+  def red=(_); end
+end
+
+class RuboCop::Formatter::HTMLFormatter::Color
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+class RuboCop::Formatter::HTMLFormatter::ERBContext
+  include ::RuboCop::PathUtil
+  include ::RuboCop::Formatter::TextUtil
+  def base64_encoded_logo_image(); end
+
+  def decorated_message(offense); end
+
+  def escape(string); end
+
+  def files(); end
+
+  def highlighted_source_line(offense); end
+
+  def hightlight_source_tag(offense); end
+
+  def initialize(files, summary); end
+
+  def possible_ellipses(location); end
+
+  def source_after_highlight(offense); end
+
+  def source_before_highlight(offense); end
+
+  def summary(); end
+  LOGO_IMAGE_PATH = ::T.let(nil, ::T.untyped)
+  SEVERITY_COLORS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Formatter::HTMLFormatter::ERBContext
+end
+
+class RuboCop::Formatter::HTMLFormatter
+end
+
+class RuboCop::Formatter::JSONFormatter
+  include ::RuboCop::PathUtil
+  def hash_for_file(file, offenses); end
+
+  def hash_for_location(offense); end
+
+  def hash_for_offense(offense); end
+
+  def metadata_hash(); end
+
+  def output_hash(); end
+end
+
+class RuboCop::Formatter::JSONFormatter
+end
+
+class RuboCop::Formatter::JUnitFormatter
+  def finished(_inspected_files); end
+end
+
+class RuboCop::Formatter::JUnitFormatter
+end
+
+class RuboCop::Formatter::OffenseCountFormatter
+  def file_finished(_file, offenses); end
+
+  def finished(_inspected_files); end
+
+  def offense_counts(); end
+
+  def ordered_offense_counts(offense_counts); end
+
+  def report_summary(offense_counts); end
+
+  def total_offense_count(offense_counts); end
+end
+
+class RuboCop::Formatter::OffenseCountFormatter
+end
+
+class RuboCop::Formatter::PacmanFormatter
+  include ::RuboCop::Formatter::TextUtil
+  def cols(); end
+
+  def file_started(_file, _options); end
+
+  def next_step(offenses); end
+
+  def pacdots(number); end
+
+  def progress_line(); end
+
+  def progress_line=(progress_line); end
+
+  def started(target_files); end
+
+  def step(character); end
+
+  def update_progress_line(); end
+  FALLBACK_TERMINAL_WIDTH = ::T.let(nil, ::T.untyped)
+  GHOST = ::T.let(nil, ::T.untyped)
+  PACDOT = ::T.let(nil, ::T.untyped)
+  PACMAN = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Formatter::PacmanFormatter
+end
+
+class RuboCop::Formatter::ProgressFormatter
+  include ::RuboCop::Formatter::TextUtil
+  def report_file_as_mark(offenses); end
+
+  def started(target_files); end
+  DOT = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Formatter::ProgressFormatter
+end
+
+class RuboCop::Formatter::QuietFormatter
+end
+
+class RuboCop::Formatter::QuietFormatter
+end
+
+class RuboCop::Formatter::SimpleTextFormatter
+  include ::RuboCop::Formatter::Colorizable
+  include ::RuboCop::PathUtil
+  def report_file(file, offenses); end
+
+  def report_summary(file_count, offense_count, correction_count); end
+
+  def started(_target_files); end
+  COLOR_FOR_SEVERITY = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Formatter::SimpleTextFormatter::Report
+  include ::RuboCop::Formatter::Colorizable
+  include ::RuboCop::Formatter::TextUtil
+  def initialize(file_count, offense_count, correction_count, rainbow); end
+
+  def summary(); end
+end
+
+class RuboCop::Formatter::SimpleTextFormatter::Report
+end
+
+class RuboCop::Formatter::SimpleTextFormatter
+end
+
+class RuboCop::Formatter::TapFormatter
+  def started(target_files); end
+end
+
+class RuboCop::Formatter::TapFormatter
+end
+
+module RuboCop::Formatter::TextUtil
+end
+
+module RuboCop::Formatter::TextUtil
+  def self.pluralize(number, thing, options=T.unsafe(nil)); end
+end
+
+class RuboCop::Formatter::WorstOffendersFormatter
+  def finished(_inspected_files); end
+
+  def offense_counts(); end
+
+  def ordered_offense_counts(offense_counts); end
+
+  def report_summary(offense_counts); end
+
+  def total_offense_count(offense_counts); end
+end
+
+class RuboCop::Formatter::WorstOffendersFormatter
+end
+
+module RuboCop::Formatter
+end
+
+class RuboCop::IncorrectCopNameError
+end
+
+class RuboCop::IncorrectCopNameError
+end
+
+class RuboCop::MagicComment
+  def any?(); end
+
+  def encoding_specified?(); end
+
+  def frozen_string_literal(); end
+
+  def frozen_string_literal?(); end
+
+  def frozen_string_literal_specified?(); end
+
+  def initialize(comment); end
+
+  def valid_literal_value?(); end
+  TOKEN = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::MagicComment::EditorComment
+end
+
+class RuboCop::MagicComment::EditorComment
+end
+
+class RuboCop::MagicComment::EmacsComment
+  def encoding(); end
+  FORMAT = ::T.let(nil, ::T.untyped)
+  OPERATOR = ::T.let(nil, ::T.untyped)
+  SEPARATOR = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::MagicComment::EmacsComment
+end
+
+class RuboCop::MagicComment::SimpleComment
+  def encoding(); end
+end
+
+class RuboCop::MagicComment::SimpleComment
+end
+
+class RuboCop::MagicComment::VimComment
+  def encoding(); end
+  FORMAT = ::T.let(nil, ::T.untyped)
+  OPERATOR = ::T.let(nil, ::T.untyped)
+  SEPARATOR = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::MagicComment::VimComment
+end
+
+class RuboCop::MagicComment
+  def self.parse(comment); end
+end
+
+module RuboCop::NameSimilarity
+  def find_similar_name(target_name, scope); end
+  MINIMUM_SIMILARITY_TO_SUGGEST = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::NameSimilarity
+end
+
+class RuboCop::NodePattern
+  def ==(other); end
+
+  def eql?(other); end
+
+  def initialize(str); end
+
+  def marshal_dump(); end
+
+  def marshal_load(pattern); end
+
+  def match(*args); end
+
+  def pattern(); end
+end
+
+class RuboCop::NodePattern::Invalid
+end
+
+class RuboCop::NodePattern::Invalid
+end
+
+module RuboCop::NodePattern::Macros
+  def def_node_matcher(method_name, pattern_str); end
+
+  def def_node_search(method_name, pattern_str); end
+
+  def node_search(method_name, compiler, on_match, prelude, called_from); end
+
+  def node_search_all(method_name, compiler, called_from); end
+
+  def node_search_body(method_name, trailing_params, prelude, match_code, on_match); end
+
+  def node_search_first(method_name, compiler, called_from); end
+end
+
+module RuboCop::NodePattern::Macros
+end
+
+class RuboCop::NodePattern
+  def self.descend(element, &block); end
+end
+
+class RuboCop::OptionArgumentError
+end
+
+class RuboCop::OptionArgumentError
+end
+
+class RuboCop::Options
+  def parse(command_line_args); end
+  DEFAULT_MAXIMUM_EXCLUSION_ITEMS = ::T.let(nil, ::T.untyped)
+  EXITING_OPTIONS = ::T.let(nil, ::T.untyped)
+  E_STDIN_NO_PATH = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Options
+end
+
+module RuboCop::OptionsHelp
+  FORMATTER_OPTION_LIST = ::T.let(nil, ::T.untyped)
+  MAX_EXCL = ::T.let(nil, ::T.untyped)
+  TEXT = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::OptionsHelp
+end
+
+class RuboCop::OptionsValidator
+  def boolean_or_empty_cache?(); end
+
+  def display_only_fail_level_offenses_with_autocorrect?(); end
+
+  def except_syntax?(); end
+
+  def incompatible_options(); end
+
+  def initialize(options); end
+
+  def only_includes_redundant_disable?(); end
+
+  def validate_auto_correct(); end
+
+  def validate_auto_gen_config(); end
+
+  def validate_compatibility(); end
+
+  def validate_cop_options(); end
+
+  def validate_exclude_limit_option(); end
+
+  def validate_parallel(); end
+
+  def validate_parallel_with_combo_option(); end
+end
+
+class RuboCop::OptionsValidator
+  def self.validate_cop_list(names); end
+end
+
+module RuboCop::PathUtil
+end
+
+module RuboCop::PathUtil
+  def self.absolute?(path); end
+
+  def self.chdir(dir, &block); end
+
+  def self.hidden_dir?(path); end
+
+  def self.hidden_file_in_not_hidden_dir?(pattern, path); end
+
+  def self.match_path?(pattern, path); end
+
+  def self.pwd(); end
+
+  def self.relative_path(path, base_dir=T.unsafe(nil)); end
+
+  def self.reset_pwd(); end
+
+  def self.smart_path(path); end
+end
+
+module RuboCop::Platform
+end
+
+module RuboCop::Platform
+  def self.windows?(); end
+end
+
+class RuboCop::ProcessedSource
+  def [](*args); end
+
+  def ast(); end
+
+  def ast_with_comments(); end
+
+  def blank?(); end
+
+  def buffer(); end
+
+  def checksum(); end
+
+  def comment_config(); end
+
+  def commented?(source_range); end
+
+  def comments(); end
+
+  def comments_before_line(line); end
+
+  def current_line(token); end
+
+  def diagnostics(); end
+
+  def disabled_line_ranges(); end
+
+  def each_comment(); end
+
+  def each_token(); end
+
+  def file_path(); end
+
+  def find_comment(); end
+
+  def find_token(); end
+
+  def following_line(token); end
+
+  def initialize(source, ruby_version, path=T.unsafe(nil)); end
+
+  def line_indentation(line_number); end
+
+  def lines(); end
+
+  def parser_error(); end
+
+  def path(); end
+
+  def preceding_line(token); end
+
+  def raw_source(); end
+
+  def ruby_version(); end
+
+  def start_with?(string); end
+
+  def tokens(); end
+
+  def valid_syntax?(); end
+  STRING_SOURCE_NAME = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::ProcessedSource
+  def self.from_file(path, ruby_version); end
+end
+
+class RuboCop::RemoteConfig
+  def file(); end
+
+  def inherit_from_remote(file, path); end
+
+  def initialize(url, base_dir); end
+
+  def uri(); end
+  CACHE_LIFETIME = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::RemoteConfig
+end
+
+class RuboCop::ResultCache
+  def initialize(file, team, options, config_store, cache_root=T.unsafe(nil)); end
+
+  def load(); end
+
+  def save(offenses); end
+
+  def valid?(); end
+  NON_CHANGING = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::ResultCache
+  def self.allow_symlinks_in_cache_location?(config_store); end
+
+  def self.cache_root(config_store); end
+
+  def self.cleanup(config_store, verbose, cache_root=T.unsafe(nil)); end
+
+  def self.inhibit_cleanup(); end
+
+  def self.inhibit_cleanup=(inhibit_cleanup); end
+
+  def self.source_checksum(); end
+
+  def self.source_checksum=(source_checksum); end
+end
+
+class RuboCop::Runner
+  def aborting=(aborting); end
+
+  def aborting?(); end
+
+  def errors(); end
+
+  def initialize(options, config_store); end
+
+  def run(paths); end
+
+  def warnings(); end
+  MAX_ITERATIONS = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::Runner::InfiniteCorrectionLoop
+  def initialize(path, offenses); end
+
+  def offenses(); end
+end
+
+class RuboCop::Runner::InfiniteCorrectionLoop
+end
+
+class RuboCop::Runner
+end
+
+class RuboCop::StringInterpreter
+  STRING_ESCAPES = ::T.let(nil, ::T.untyped)
+  STRING_ESCAPE_REGEX = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::StringInterpreter
+  def self.interpret(string); end
+end
+
+module RuboCop::StringUtil
+end
+
+module RuboCop::StringUtil
+  def self.similarity(string_a, string_b); end
+end
+
+class RuboCop::TargetFinder
+  def all_cops_include(); end
+
+  def configured_include?(file); end
+
+  def debug?(); end
+
+  def excluded_dirs(base_dir); end
+
+  def fail_fast?(); end
+
+  def find(args); end
+
+  def find_files(base_dir, flags); end
+
+  def force_exclusion?(); end
+
+  def included_file?(file); end
+
+  def initialize(config_store, options=T.unsafe(nil)); end
+
+  def process_explicit_path(path); end
+
+  def ruby_executable?(file); end
+
+  def ruby_extension?(file); end
+
+  def ruby_extensions(); end
+
+  def ruby_file?(file); end
+
+  def ruby_filename?(file); end
+
+  def ruby_filenames(); end
+
+  def ruby_interpreters(file); end
+
+  def stdin?(); end
+
+  def target_files_in_dir(base_dir=T.unsafe(nil)); end
+
+  def to_inspect?(file, hidden_files, base_dir_config); end
+
+  def toplevel_dirs(base_dir, flags); end
+end
+
+class RuboCop::TargetFinder
+end
+
+class RuboCop::TargetRuby
+  def initialize(config); end
+
+  def rubocop_version_with_support(); end
+
+  def source(); end
+
+  def supported?(); end
+
+  def version(); end
+  DEFAULT_VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::TargetRuby::BundlerLockFile
+end
+
+class RuboCop::TargetRuby::BundlerLockFile
+end
+
+class RuboCop::TargetRuby::Default
+end
+
+class RuboCop::TargetRuby::Default
+end
+
+class RuboCop::TargetRuby::RuboCopConfig
+end
+
+class RuboCop::TargetRuby::RuboCopConfig
+end
+
+class RuboCop::TargetRuby::RubyVersionFile
+  FILENAME = ::T.let(nil, ::T.untyped)
+end
+
+class RuboCop::TargetRuby::RubyVersionFile
+end
+
+class RuboCop::TargetRuby::Source
+  def initialize(config); end
+
+  def name(); end
+
+  def version(); end
+end
+
+class RuboCop::TargetRuby::Source
+end
+
+class RuboCop::TargetRuby
+  def self.supported_versions(); end
+end
+
+class RuboCop::Token
+  def begin_pos(); end
+
+  def column(); end
+
+  def comma?(); end
+
+  def comment?(); end
+
+  def end?(); end
+
+  def end_pos(); end
+
+  def equal_sign?(); end
+
+  def initialize(pos, type, text); end
+
+  def left_array_bracket?(); end
+
+  def left_brace?(); end
+
+  def left_bracket?(); end
+
+  def left_curly_brace?(); end
+
+  def left_parens?(); end
+
+  def left_ref_bracket?(); end
+
+  def line(); end
+
+  def pos(); end
+
+  def rescue_modifier?(); end
+
+  def right_bracket?(); end
+
+  def right_curly_brace?(); end
+
+  def right_parens?(); end
+
+  def semicolon?(); end
+
+  def space_after?(); end
+
+  def space_before?(); end
+
+  def text(); end
+
+  def type(); end
+end
+
+class RuboCop::Token
+  def self.from_parser_token(parser_token); end
+end
+
+class RuboCop::ValidationError
+end
+
+class RuboCop::ValidationError
+end
+
+module RuboCop::Version
+  MSG = ::T.let(nil, ::T.untyped)
+  STRING = ::T.let(nil, ::T.untyped)
+end
+
+module RuboCop::Version
+  def self.version(debug=T.unsafe(nil)); end
+end
+
+class RuboCop::Warning
+end
+
+class RuboCop::Warning
+end
+
+module RuboCop::YAMLDuplicationChecker
+end
+
+module RuboCop::YAMLDuplicationChecker
+  def self.check(yaml_string, filename, &on_duplicated); end
+end
+
+module RuboCop
+end
+
+module RubyVM::AbstractSyntaxTree
+end
+
+class RubyVM::AbstractSyntaxTree::Node
+  def children(); end
+
+  def first_column(); end
+
+  def first_lineno(); end
+
+  def last_column(); end
+
+  def last_lineno(); end
+
+  def pretty_print_children(q, names=T.unsafe(nil)); end
+
+  def type(); end
+end
+
+class RubyVM::AbstractSyntaxTree::Node
+end
+
+module RubyVM::AbstractSyntaxTree
+  def self.of(_); end
+
+  def self.parse(_); end
+
+  def self.parse_file(_); end
+end
+
+class RubyVM::InstructionSequence
+  def absolute_path(); end
+
+  def base_label(); end
+
+  def disasm(); end
+
+  def disassemble(); end
+
+  def each_child(); end
+
+  def eval(); end
+
+  def first_lineno(); end
+
+  def label(); end
+
+  def path(); end
+
+  def to_a(); end
+
+  def to_binary(*_); end
+
+  def trace_points(); end
+end
+
+class RubyVM::InstructionSequence
+  def self.compile(*_); end
+
+  def self.compile_file(*_); end
+
+  def self.compile_option(); end
+
+  def self.compile_option=(compile_option); end
+
+  def self.disasm(_); end
+
+  def self.disassemble(_); end
+
+  def self.load_from_binary(_); end
+
+  def self.load_from_binary_extra_data(_); end
+
+  def self.of(_); end
+end
+
+module RubyVM::MJIT
+end
+
+module RubyVM::MJIT
+  def self.enabled?(); end
+
+  def self.pause(*_); end
+
+  def self.resume(); end
+end
+
+class RubyVM
+  def self.resolve_feature_path(_); end
+
+  def self.stat(*_); end
+end
+
+ScanError = StringScanner::Error
+
+module SecureRandom
+  def self.bytes(n); end
+end
+
+class Set
+  def ==(other); end
+
+  def ===(o); end
+
+  def compare_by_identity(); end
+
+  def compare_by_identity?(); end
+
+  def divide(&func); end
+
+  def eql?(o); end
+
+  def flatten_merge(set, seen=T.unsafe(nil)); end
+
+  def pretty_print(pp); end
+
+  def pretty_print_cycle(pp); end
+
+  def reset(); end
+  InspectKey = ::T.let(nil, ::T.untyped)
+end
+
+module Shellwords
+end
+
+module Shellwords
+  def self.escape(str); end
+
+  def self.join(array); end
+
+  def self.shellescape(str); end
+
+  def self.shelljoin(array); end
+
+  def self.shellsplit(line); end
+
+  def self.shellwords(line); end
+
+  def self.split(line); end
+end
+
+class SignalException
+  def signm(); end
+
+  def signo(); end
+end
+
+module SingleForwardable
+  def def_delegator(accessor, method, ali=T.unsafe(nil)); end
+
+  def def_delegators(accessor, *methods); end
+
+  def def_single_delegator(accessor, method, ali=T.unsafe(nil)); end
+
+  def def_single_delegators(accessor, *methods); end
+
+  def delegate(hash); end
+
+  def single_delegate(hash); end
+end
+
+module Singleton
+  def _dump(depth=T.unsafe(nil)); end
+
+  def clone(); end
+
+  def dup(); end
+end
+
+module Singleton::SingletonClassMethods
+  def _load(str); end
+
+  def clone(); end
+end
+
+module Singleton
+  def self.__init__(klass); end
+end
+
+class Socket
+  IPV6_DONTFRAG = ::T.let(nil, ::T.untyped)
+  IPV6_PATHMTU = ::T.let(nil, ::T.untyped)
+  IPV6_RECVPATHMTU = ::T.let(nil, ::T.untyped)
+  SO_BPF_EXTENSIONS = ::T.let(nil, ::T.untyped)
+end
+
+module Socket::Constants
+  IPV6_DONTFRAG = ::T.let(nil, ::T.untyped)
+  IPV6_PATHMTU = ::T.let(nil, ::T.untyped)
+  IPV6_RECVPATHMTU = ::T.let(nil, ::T.untyped)
+  SO_BPF_EXTENSIONS = ::T.let(nil, ::T.untyped)
+end
+
+class Sorbet::Private::ConstantLookupCache
+  def all_module_aliases(); end
+
+  def all_module_names(); end
+
+  def all_named_modules(); end
+
+  def class_by_name(name); end
+
+  def name_by_class(klass); end
+  DEPRECATED_CONSTANTS = ::T.let(nil, ::T.untyped)
+end
+
+class Sorbet::Private::ConstantLookupCache::ConstantEntry
+  def aliases(); end
+
+  def aliases=(_); end
+
+  def const(); end
+
+  def const=(_); end
+
+  def const_name(); end
+
+  def const_name=(_); end
+
+  def found_name(); end
+
+  def found_name=(_); end
+
+  def owner(); end
+
+  def owner=(_); end
+
+  def primary_name(); end
+
+  def primary_name=(_); end
+end
+
+class Sorbet::Private::ConstantLookupCache::ConstantEntry
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+class Sorbet::Private::ConstantLookupCache
+end
+
+class Sorbet::Private::CreateConfig
+  include ::Sorbet::Private::StepInterface
+  SORBET_CONFIG_FILE = ::T.let(nil, ::T.untyped)
+  SORBET_DIR = ::T.let(nil, ::T.untyped)
+end
+
+class Sorbet::Private::CreateConfig
+  def self.main(); end
+
+  def self.output_file(); end
+end
+
+class Sorbet::Private::FetchRBIs
+  include ::Sorbet::Private::StepInterface
+  HEADER = ::T.let(nil, ::T.untyped)
+  RBI_CACHE_DIR = ::T.let(nil, ::T.untyped)
+  SORBET_CONFIG_FILE = ::T.let(nil, ::T.untyped)
+  SORBET_DIR = ::T.let(nil, ::T.untyped)
+  SORBET_RBI_LIST = ::T.let(nil, ::T.untyped)
+  SORBET_RBI_SORBET_TYPED = ::T.let(nil, ::T.untyped)
+  SORBET_TYPED_REPO = ::T.let(nil, ::T.untyped)
+  SORBET_TYPED_REVISION = ::T.let(nil, ::T.untyped)
+  XDG_CACHE_HOME = ::T.let(nil, ::T.untyped)
+end
+
+class Sorbet::Private::FetchRBIs
+  def self.fetch_sorbet_typed(); end
+
+  def self.main(); end
+
+  def self.matching_version_directories(root, version); end
+
+  def self.output_file(); end
+
+  def self.paths_for_gem_version(gemspec); end
+
+  def self.paths_for_ruby_version(ruby_version); end
+
+  def self.vendor_rbis_within_paths(vendor_paths); end
+end
+
+class Sorbet::Private::FindGemRBIs
+  include ::Sorbet::Private::StepInterface
+  GEM_DIR = ::T.let(nil, ::T.untyped)
+  HEADER = ::T.let(nil, ::T.untyped)
+  RBI_CACHE_DIR = ::T.let(nil, ::T.untyped)
+  XDG_CACHE_HOME = ::T.let(nil, ::T.untyped)
+end
+
+class Sorbet::Private::FindGemRBIs
+  def self.main(); end
+
+  def self.output_file(); end
+
+  def self.paths_within_gem_sources(gemspec); end
+end
+
+module Sorbet::Private::GemGeneratorTracepoint
+  include ::Sorbet::Private::StepInterface
+  OUTPUT = ::T.let(nil, ::T.untyped)
+end
+
+class Sorbet::Private::GemGeneratorTracepoint::ClassDefinition
+  def defs(); end
+
+  def defs=(_); end
+
+  def id(); end
+
+  def id=(_); end
+
+  def klass(); end
+
+  def klass=(_); end
+end
+
+class Sorbet::Private::GemGeneratorTracepoint::ClassDefinition
+  def self.[](*_); end
+
+  def self.members(); end
+end
+
+class Sorbet::Private::GemGeneratorTracepoint::TracepointSerializer
+  def initialize(files:, delegate_classes:); end
+
+  def serialize(output_dir); end
+  BAD_METHODS = ::T.let(nil, ::T.untyped)
+  HEADER = ::T.let(nil, ::T.untyped)
+  SPECIAL_METHOD_NAMES = ::T.let(nil, ::T.untyped)
+end
+
+class Sorbet::Private::GemGeneratorTracepoint::TracepointSerializer
+end
+
+class Sorbet::Private::GemGeneratorTracepoint::Tracer
+end
+
+class Sorbet::Private::GemGeneratorTracepoint::Tracer
+  def self.add_to_context(item); end
+
+  def self.disable_tracepoints(); end
+
+  def self.finish(); end
+
+  def self.install_tracepoints(); end
+
+  def self.on_method_added(mod, method, singleton); end
+
+  def self.on_module_created(mod); end
+
+  def self.on_module_extended(extended, extender); end
+
+  def self.on_module_included(included, includer); end
+
+  def self.pre_cache_module_methods(); end
+
+  def self.register_delegate_class(klass, delegate); end
+
+  def self.start(); end
+
+  def self.trace(); end
+
+  def self.trace_results(); end
+end
+
+module Sorbet::Private::GemGeneratorTracepoint
+  def self.main(output_dir=T.unsafe(nil)); end
+
+  def self.output_file(); end
+end
+
+class Sorbet::Private::GemLoader
+  GEM_LOADER = ::T.let(nil, ::T.untyped)
+  NO_GEM = ::T.let(nil, ::T.untyped)
+end
+
+class Sorbet::Private::GemLoader
+  def self.my_require(gem); end
+
+  def self.require_all_gems(); end
+
+  def self.require_gem(gem); end
+end
+
+class Sorbet::Private::HiddenMethodFinder
+  include ::Sorbet::Private::StepInterface
+  def all_modules_and_aliases(); end
+
+  def capture_stderr(); end
+
+  def constant_cache(); end
+
+  def gen_source_rbi(classes, aliases); end
+
+  def looks_like_stub_name(name); end
+
+  def main(); end
+
+  def mk_dir(); end
+
+  def read_constants(); end
+
+  def real_name(mod); end
+
+  def require_everything(); end
+
+  def rm_dir(); end
+
+  def serialize_alias(source_entry, rbi_entry, my_klass, source_symbols, rbi_symbols); end
+
+  def serialize_class(source_entry, rbi_entry, klass, source_symbols, rbi_symbols, source_by_name); end
+
+  def serialize_constants(source, rbi, klass, is_singleton, source_symbols, rbi_symbols); end
+
+  def symbols_id_to_name(entry, prefix); end
+
+  def write_constants(); end
+
+  def write_diff(source, rbi); end
+  BLACKLIST = ::T.let(nil, ::T.untyped)
+  DIFF_RBI = ::T.let(nil, ::T.untyped)
+  ERRORS_RBI = ::T.let(nil, ::T.untyped)
+  HEADER = ::T.let(nil, ::T.untyped)
+  HIDDEN_RBI = ::T.let(nil, ::T.untyped)
+  PATH = ::T.let(nil, ::T.untyped)
+  RBI_CONSTANTS = ::T.let(nil, ::T.untyped)
+  RBI_CONSTANTS_ERR = ::T.let(nil, ::T.untyped)
+  SOURCE_CONSTANTS = ::T.let(nil, ::T.untyped)
+  SOURCE_CONSTANTS_ERR = ::T.let(nil, ::T.untyped)
+  TMP_PATH = ::T.let(nil, ::T.untyped)
+  TMP_RBI = ::T.let(nil, ::T.untyped)
+end
+
+class Sorbet::Private::HiddenMethodFinder
+  def self.main(); end
+
+  def self.output_file(); end
+end
+
+module Sorbet::Private::Main
+end
+
+module Sorbet::Private::Main
+  def self.cyan(msg); end
+
+  def self.emojify(emoji, msg); end
+
+  def self.init(); end
+
+  def self.main(argv); end
+
+  def self.make_step(step); end
+
+  def self.usage(); end
+
+  def self.yellow(msg); end
+end
+
+module Sorbet::Private::RealStdlib
+end
+
+module Sorbet::Private::RealStdlib
+  def self.real_ancestors(mod); end
+
+  def self.real_autoload?(o, klass); end
+
+  def self.real_const_get(obj, const, arg); end
+
+  def self.real_constants(mod); end
+
+  def self.real_eqeq(obj, other); end
+
+  def self.real_hash(o); end
+
+  def self.real_instance_methods(mod, arg); end
+
+  def self.real_is_a?(o, klass); end
+
+  def self.real_method(obj, sym); end
+
+  def self.real_name(o); end
+
+  def self.real_object_id(o); end
+
+  def self.real_private_instance_methods(mod, arg); end
+
+  def self.real_singleton_class(obj); end
+
+  def self.real_singleton_methods(mod, arg); end
+
+  def self.real_spaceship(obj, arg); end
+
+  def self.real_superclass(o); end
+end
+
+class Sorbet::Private::RequireEverything
+end
+
+class Sorbet::Private::RequireEverything
+  def self.excluded_rails_files(); end
+
+  def self.load_bundler(); end
+
+  def self.load_rails(); end
+
+  def self.my_require(abs_path, numerator, denominator); end
+
+  def self.patch_kernel(); end
+
+  def self.rails?(); end
+
+  def self.rails_load_paths(); end
+
+  def self.rb_file_paths(); end
+
+  def self.require_all_files(); end
+
+  def self.require_everything(); end
+end
+
+class Sorbet::Private::Serialize
+  def alias(base, other_name); end
+
+  def ancestor_has_method(method, klass); end
+
+  def blacklisted_method(method); end
+
+  def class_or_module(class_name); end
+
+  def comparable?(value); end
+
+  def constant(const, value); end
+
+  def from_method(method); end
+
+  def initialize(constant_cache); end
+
+  def serialize_method(method, static=T.unsafe(nil), with_sig: T.unsafe(nil)); end
+
+  def serialize_sig(parameters); end
+
+  def to_sig(kind, name); end
+
+  def valid_class_name(name); end
+
+  def valid_method_name(name); end
+  BLACKLIST_CONSTANTS = ::T.let(nil, ::T.untyped)
+  KEYWORDS = ::T.let(nil, ::T.untyped)
+  SPECIAL_METHOD_NAMES = ::T.let(nil, ::T.untyped)
+end
+
+class Sorbet::Private::Serialize
+  def self.header(typed=T.unsafe(nil), subcommand=T.unsafe(nil)); end
+end
+
+module Sorbet::Private::Status
+end
+
+module Sorbet::Private::Status
+  def self.done(); end
+
+  def self.say(message, print_without_tty: T.unsafe(nil)); end
+end
+
+module Sorbet::Private::StepInterface
+end
+
+module Sorbet::Private::StepInterface
+  def self.main(); end
+
+  def self.output_file(); end
+end
+
+class Sorbet::Private::SuggestTyped
+  include ::Sorbet::Private::StepInterface
+end
+
+class Sorbet::Private::SuggestTyped
+  def self.main(); end
+
+  def self.output_file(); end
+
+  def self.suggest_typed(); end
+end
+
+class Sorbet::Private::TodoRBI
+  include ::Sorbet::Private::StepInterface
+  HEADER = ::T.let(nil, ::T.untyped)
+  OUTPUT = ::T.let(nil, ::T.untyped)
+end
+
+class Sorbet::Private::TodoRBI
+  def self.main(); end
+
+  def self.output_file(); end
+end
+
+class SortedSet
+  def initialize(*args, &block); end
+end
+
+class SortedSet
+  def self.setup(); end
+end
+
+class StopIteration
+  def result(); end
+end
+
+class String
+  include ::JSON::Ext::Generator::GeneratorMethods::String
+  def []=(*_); end
+
+  def blank?(); end
+
+  def casecmp?(_); end
+
+  def each_grapheme_cluster(); end
+
+  def encode!(*_); end
+
+  def ext(newext=T.unsafe(nil)); end
+
+  def grapheme_clusters(); end
+
+  def pathmap(spec=T.unsafe(nil), &block); end
+
+  def pathmap_explode(); end
+
+  def pathmap_partial(n); end
+
+  def pathmap_replace(patterns, &block); end
+
+  def reverse!(); end
+
+  def shellescape(); end
+
+  def shellsplit(); end
+
+  def succ!(); end
+
+  def undump(); end
+
+  def unicode_normalize(*_); end
+
+  def unicode_normalize!(*_); end
+
+  def unicode_normalized?(*_); end
+
+  def unpack1(_); end
+end
+
+class String
+  extend ::JSON::Ext::Generator::GeneratorMethods::String::Extend
+end
+
+class StringIO
+  def length(); end
+
+  def truncate(_); end
+end
+
+class StringScanner
+  def <<(_); end
+
+  def [](_); end
+
+  def beginning_of_line?(); end
+
+  def bol?(); end
+
+  def captures(); end
+
+  def charpos(); end
+
+  def check(_); end
+
+  def check_until(_); end
+
+  def clear(); end
+
+  def concat(_); end
+
+  def empty?(); end
+
+  def exist?(_); end
+
+  def get_byte(); end
+
+  def getbyte(); end
+
+  def initialize(*_); end
+
+  def match?(_); end
+
+  def matched(); end
+
+  def matched?(); end
+
+  def matched_size(); end
+
+  def peek(_); end
+
+  def peep(_); end
+
+  def pointer(); end
+
+  def pointer=(pointer); end
+
+  def pos(); end
+
+  def pos=(pos); end
+
+  def post_match(); end
+
+  def pre_match(); end
+
+  def reset(); end
+
+  def rest(); end
+
+  def rest?(); end
+
+  def rest_size(); end
+
+  def restsize(); end
+
+  def scan_full(_, _1, _2); end
+
+  def scan_until(_); end
+
+  def search_full(_, _1, _2); end
+
+  def size(); end
+
+  def skip(_); end
+
+  def skip_until(_); end
+
+  def string(); end
+
+  def string=(string); end
+
+  def terminate(); end
+
+  def unscan(); end
+
+  def values_at(*_); end
+  Id = ::T.let(nil, ::T.untyped)
+  Version = ::T.let(nil, ::T.untyped)
+end
+
+class StringScanner
+  def self.must_C_version(); end
+end
+
+class Struct
+  def [](_); end
+
+  def []=(_, _1); end
+
+  def dig(*_); end
+
+  def each_pair(); end
+
+  def filter(*_); end
+
+  def length(); end
+
+  def members(); end
+
+  def select(*_); end
+
+  def size(); end
+
+  def to_a(); end
+
+  def to_h(); end
+
+  def values(); end
+
+  def values_at(*_); end
+end
+
+Struct::Group = Etc::Group
+
+Struct::Passwd = Etc::Passwd
+
+Struct::Tms = Process::Tms
+
+class SystemCallError
+  def errno(); end
+end
+
+class SystemExit
+  def status(); end
+
+  def success?(); end
+end
+
+class Tempfile
+  def _close(); end
+
+  def inspect(); end
+end
+
+class Tempfile::Remover
+  def call(*args); end
+
+  def initialize(tmpfile); end
+end
+
+class Tempfile::Remover
+end
+
+class TracePoint
+  def __enable(_, _1); end
+
+  def eval_script(); end
+
+  def event(); end
+
+  def instruction_sequence(); end
+
+  def parameters(); end
+end
+
+class TrueClass
+  include ::JSON::Ext::Generator::GeneratorMethods::TrueClass
+end
+
+module URI
+  include ::URI::RFC2396_REGEXP
+end
+
+module URI::Escape
+  def decode(*arg); end
+
+  def encode(*arg); end
+
+  def escape(*arg); end
+
+  def unescape(*arg); end
+end
+
+class URI::FTP
+  def set_typecode(v); end
+
+  def typecode(); end
+
+  def typecode=(typecode); 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::LDAP
+  def attributes(); end
+
+  def attributes=(val); end
+
+  def dn(); end
+
+  def dn=(val); end
+
+  def extensions(); end
+
+  def extensions=(val); end
+
+  def filter(); end
+
+  def filter=(val); end
+
+  def initialize(*arg); end
+
+  def scope(); end
+
+  def scope=(val); end
+
+  def set_attributes(val); end
+
+  def set_dn(val); end
+
+  def set_extensions(val); end
+
+  def set_filter(val); end
+
+  def set_scope(val); end
+end
+
+class URI::MailTo
+  def headers(); end
+
+  def headers=(v); end
+
+  def initialize(*arg); end
+
+  def set_headers(v); end
+
+  def set_to(v); end
+
+  def to(); end
+
+  def to=(v); end
+
+  def to_mailtext(); end
+
+  def to_rfc822text(); end
+end
+
+URI::Parser = URI::RFC2396_Parser
+
+URI::REGEXP = URI::RFC2396_REGEXP
+
+class URI::RFC2396_Parser
+  def escape(str, unsafe=T.unsafe(nil)); end
+
+  def extract(str, schemes=T.unsafe(nil)); end
+
+  def initialize(opts=T.unsafe(nil)); end
+
+  def join(*uris); end
+
+  def make_regexp(schemes=T.unsafe(nil)); end
+
+  def parse(uri); end
+
+  def pattern(); end
+
+  def regexp(); end
+
+  def split(uri); end
+
+  def unescape(str, escaped=T.unsafe(nil)); end
+end
+
+class URI::RFC3986_Parser
+  def join(*uris); end
+
+  def parse(uri); end
+
+  def regexp(); end
+
+  def split(uri); end
+  RFC3986_relative_ref = ::T.let(nil, ::T.untyped)
+end
+
+module URI::Util
+  def self.make_components_hash(klass, array_hash); end
+end
+
+module URI
+  extend ::URI::Escape
+  def self.get_encoding(label); end
+
+end
+
+class UnboundMethod
+  def clone(); end
+
+  def original_name(); end
+end
+
+class UncaughtThrowError
+  def tag(); end
+
+  def value(); end
+end
+
+module Unicode
+end
+
+module Unicode::DisplayWidth
+  DATA_DIRECTORY = ::T.let(nil, ::T.untyped)
+  DEPTHS = ::T.let(nil, ::T.untyped)
+  INDEX = ::T.let(nil, ::T.untyped)
+  INDEX_FILENAME = ::T.let(nil, ::T.untyped)
+  NO_STRING_EXT = ::T.let(nil, ::T.untyped)
+  UNICODE_VERSION = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+module Unicode::DisplayWidth
+  def self.emoji_extra_width_of(string, ambiguous=T.unsafe(nil), overwrite=T.unsafe(nil), _=T.unsafe(nil)); end
+
+  def self.of(string, ambiguous=T.unsafe(nil), overwrite=T.unsafe(nil), options=T.unsafe(nil)); end
+end
+
+module Unicode
+end
+
+module UnicodeNormalize
+end
+
+module UnicodeNormalize
+end
+
+Visitor = Psych::Visitors::Visitor
+
+module Warning
+  def warn(_); end
+end
+
+module Warning
+  extend ::Warning
+end
+
+YAML = Psych
+
+YAMLTree = Psych::Visitors::YAMLTree
+
+module Zlib
+  ASCII = ::T.let(nil, ::T.untyped)
+  BEST_COMPRESSION = ::T.let(nil, ::T.untyped)
+  BEST_SPEED = ::T.let(nil, ::T.untyped)
+  BINARY = ::T.let(nil, ::T.untyped)
+  DEFAULT_COMPRESSION = ::T.let(nil, ::T.untyped)
+  DEFAULT_STRATEGY = ::T.let(nil, ::T.untyped)
+  DEF_MEM_LEVEL = ::T.let(nil, ::T.untyped)
+  FILTERED = ::T.let(nil, ::T.untyped)
+  FINISH = ::T.let(nil, ::T.untyped)
+  FIXED = ::T.let(nil, ::T.untyped)
+  FULL_FLUSH = ::T.let(nil, ::T.untyped)
+  HUFFMAN_ONLY = ::T.let(nil, ::T.untyped)
+  MAX_MEM_LEVEL = ::T.let(nil, ::T.untyped)
+  MAX_WBITS = ::T.let(nil, ::T.untyped)
+  NO_COMPRESSION = ::T.let(nil, ::T.untyped)
+  NO_FLUSH = ::T.let(nil, ::T.untyped)
+  OS_AMIGA = ::T.let(nil, ::T.untyped)
+  OS_ATARI = ::T.let(nil, ::T.untyped)
+  OS_CODE = ::T.let(nil, ::T.untyped)
+  OS_CPM = ::T.let(nil, ::T.untyped)
+  OS_MACOS = ::T.let(nil, ::T.untyped)
+  OS_MSDOS = ::T.let(nil, ::T.untyped)
+  OS_OS2 = ::T.let(nil, ::T.untyped)
+  OS_QDOS = ::T.let(nil, ::T.untyped)
+  OS_RISCOS = ::T.let(nil, ::T.untyped)
+  OS_TOPS20 = ::T.let(nil, ::T.untyped)
+  OS_UNIX = ::T.let(nil, ::T.untyped)
+  OS_UNKNOWN = ::T.let(nil, ::T.untyped)
+  OS_VMCMS = ::T.let(nil, ::T.untyped)
+  OS_VMS = ::T.let(nil, ::T.untyped)
+  OS_WIN32 = ::T.let(nil, ::T.untyped)
+  OS_ZSYSTEM = ::T.let(nil, ::T.untyped)
+  RLE = ::T.let(nil, ::T.untyped)
+  SYNC_FLUSH = ::T.let(nil, ::T.untyped)
+  TEXT = ::T.let(nil, ::T.untyped)
+  UNKNOWN = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+  ZLIB_VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class Zlib::BufError
+end
+
+class Zlib::BufError
+end
+
+class Zlib::DataError
+end
+
+class Zlib::DataError
+end
+
+class Zlib::Deflate
+  def <<(_); end
+
+  def deflate(*_); end
+
+  def flush(*_); end
+
+  def initialize(*_); end
+
+  def params(_, _1); end
+
+  def set_dictionary(_); end
+end
+
+class Zlib::Deflate
+  def self.deflate(*_); end
+end
+
+class Zlib::Error
+end
+
+class Zlib::Error
+end
+
+class Zlib::GzipFile
+  def close(); end
+
+  def closed?(); end
+
+  def comment(); end
+
+  def crc(); end
+
+  def finish(); end
+
+  def level(); end
+
+  def mtime(); end
+
+  def orig_name(); end
+
+  def os_code(); end
+
+  def sync(); end
+
+  def sync=(sync); end
+
+  def to_io(); end
+end
+
+class Zlib::GzipFile::CRCError
+end
+
+class Zlib::GzipFile::CRCError
+end
+
+class Zlib::GzipFile::Error
+  def input(); end
+end
+
+class Zlib::GzipFile::Error
+end
+
+class Zlib::GzipFile::LengthError
+end
+
+class Zlib::GzipFile::LengthError
+end
+
+class Zlib::GzipFile::NoFooter
+end
+
+class Zlib::GzipFile::NoFooter
+end
+
+class Zlib::GzipFile
+  def self.wrap(*_); end
+end
+
+class Zlib::GzipReader
+  include ::Enumerable
+  def bytes(); end
+
+  def each(*_, &blk); end
+
+  def each_byte(); end
+
+  def each_char(); end
+
+  def each_line(*_); end
+
+  def eof(); end
+
+  def eof?(); end
+
+  def external_encoding(); end
+
+  def getbyte(); end
+
+  def getc(); end
+
+  def initialize(*_); end
+
+  def lineno(); end
+
+  def lineno=(lineno); end
+
+  def lines(*_); end
+
+  def pos(); end
+
+  def read(*_); end
+
+  def readbyte(); end
+
+  def readchar(); end
+
+  def readpartial(*_); end
+
+  def rewind(); end
+
+  def tell(); end
+
+  def ungetbyte(_); end
+
+  def ungetc(_); end
+
+  def unused(); end
+end
+
+class Zlib::GzipReader
+end
+
+class Zlib::GzipWriter
+  def <<(_); end
+
+  def comment=(comment); end
+
+  def flush(*_); end
+
+  def initialize(*_); end
+
+  def mtime=(mtime); end
+
+  def orig_name=(orig_name); end
+
+  def pos(); end
+
+  def tell(); end
+
+  def write(*_); end
+end
+
+class Zlib::GzipWriter
+end
+
+class Zlib::Inflate
+  def <<(_); end
+
+  def add_dictionary(_); end
+
+  def inflate(_); end
+
+  def initialize(*_); end
+
+  def set_dictionary(_); end
+
+  def sync(_); end
+
+  def sync_point?(); end
+end
+
+class Zlib::Inflate
+  def self.inflate(_); end
+end
+
+class Zlib::MemError
+end
+
+class Zlib::MemError
+end
+
+class Zlib::NeedDict
+end
+
+class Zlib::NeedDict
+end
+
+class Zlib::StreamEnd
+end
+
+class Zlib::StreamEnd
+end
+
+class Zlib::StreamError
+end
+
+class Zlib::StreamError
+end
+
+class Zlib::VersionError
+end
+
+class Zlib::VersionError
+end
+
+class Zlib::ZStream
+  def adler(); end
+
+  def avail_in(); end
+
+  def avail_out(); end
+
+  def avail_out=(avail_out); end
+
+  def close(); end
+
+  def closed?(); end
+
+  def data_type(); end
+
+  def end(); end
+
+  def ended?(); end
+
+  def finish(); end
+
+  def finished?(); end
+
+  def flush_next_in(); end
+
+  def flush_next_out(); end
+
+  def reset(); end
+
+  def stream_end?(); end
+
+  def total_in(); end
+
+  def total_out(); end
+end
+
+class Zlib::ZStream
+end
+
+module Zlib
+  def self.adler32(*_); end
+
+  def self.adler32_combine(_, _1, _2); end
+
+  def self.crc32(*_); end
+
+  def self.crc32_combine(_, _1, _2); end
+
+  def self.crc_table(); end
+
+  def self.deflate(*_); end
+
+  def self.gunzip(_); end
+
+  def self.gzip(*_); end
+
+  def self.inflate(_); end
+
+  def self.zlib_version(); end
+end
diff --git a/sorbet/rbi/jaeger-client.rbi b/sorbet/rbi/jaeger-client.rbi
new file mode 100644
index 0000000..a8cab5d
--- /dev/null
+++ b/sorbet/rbi/jaeger-client.rbi
@@ -0,0 +1,5 @@
+# typed: strong
+
+module Jaeger::Client
+    def self.build(*args); end
+end
diff --git a/sorbet/rbi/rack.rbi b/sorbet/rbi/rack.rbi
new file mode 100644
index 0000000..094c70b
--- /dev/null
+++ b/sorbet/rbi/rack.rbi
@@ -0,0 +1,5 @@
+# typed: strong
+
+class Rack::Auth::Basic
+    def initialize(app, *args); end
+end
diff --git a/sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi b/sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi
new file mode 100644
index 0000000..f2db931
--- /dev/null
+++ b/sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi
@@ -0,0 +1,8684 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi sorbet-typed
+#
+# If you would like to make changes to this file, great! Please upstream any changes you make here:
+#
+#   https://github.com/sorbet/sorbet-typed/edit/master/lib/bundler/all/bundler.rbi
+#
+# typed: strong
+
+module Bundler
+  FREEBSD = ::T.let(nil, T.untyped)
+  NULL = ::T.let(nil, T.untyped)
+  ORIGINAL_ENV = ::T.let(nil, T.untyped)
+  SUDO_MUTEX = ::T.let(nil, T.untyped)
+  VERSION = ::T.let(nil, T.untyped)
+  WINDOWS = ::T.let(nil, T.untyped)
+
+  sig do
+    params(
+      custom_path: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.app_cache(custom_path=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def self.app_config_path(); end
+
+  sig {returns(T.untyped)}
+  def self.bin_path(); end
+
+  sig {returns(T.untyped)}
+  def self.bundle_path(); end
+
+  sig {returns(T.untyped)}
+  def self.bundler_major_version(); end
+
+  sig {returns(T.untyped)}
+  def self.clean_env(); end
+
+  sig do
+    params(
+      args: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.clean_exec(*args); end
+
+  sig do
+    params(
+      args: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.clean_system(*args); end
+
+  sig {returns(T.untyped)}
+  def self.clear_gemspec_cache(); end
+
+  sig {returns(T.untyped)}
+  def self.configure(); end
+
+  sig {returns(T.untyped)}
+  def self.configured_bundle_path(); end
+
+  sig {returns(T.untyped)}
+  def self.current_ruby(); end
+
+  sig {returns(T.untyped)}
+  def self.default_bundle_dir(); end
+
+  sig {returns(T.untyped)}
+  def self.default_gemfile(); end
+
+  sig {returns(T.untyped)}
+  def self.default_lockfile(); end
+
+  sig do
+    params(
+      unlock: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.definition(unlock=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def self.environment(); end
+
+  sig {returns(T.untyped)}
+  def self.feature_flag(); end
+
+  sig {returns(T.untyped)}
+  def self.frozen_bundle?(); end
+
+  sig {returns(T.untyped)}
+  def self.git_present?(); end
+
+  sig {returns(T.untyped)}
+  def self.home(); end
+
+  sig {returns(T.untyped)}
+  def self.install_path(); end
+
+  sig {returns(T.untyped)}
+  def self.load(); end
+
+  sig do
+    params(
+      file: T.untyped,
+      validate: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.load_gemspec(file, validate=T.unsafe(nil)); end
+
+  sig do
+    params(
+      file: T.untyped,
+      validate: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.load_gemspec_uncached(file, validate=T.unsafe(nil)); end
+
+  sig do
+    params(
+      data: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.load_marshal(data); end
+
+  sig {returns(T.untyped)}
+  def self.local_platform(); end
+
+  sig {returns(T.untyped)}
+  def self.locked_gems(); end
+
+  sig do
+    params(
+      path: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.mkdir_p(path, options=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def self.original_env(); end
+
+  sig do
+    params(
+      file: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.read_file(file); end
+
+  sig do
+    params(
+      groups: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.require(*groups); end
+
+  sig {returns(T.untyped)}
+  def self.require_thor_actions(); end
+
+  sig {returns(T.untyped)}
+  def self.requires_sudo?(); end
+
+  sig {returns(T.untyped)}
+  def self.reset!(); end
+
+  sig {returns(T.untyped)}
+  def self.reset_paths!(); end
+
+  sig {returns(T.untyped)}
+  def self.reset_rubygems!(); end
+
+  sig do
+    params(
+      path: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rm_rf(path); end
+
+  sig {returns(T.untyped)}
+  def self.root(); end
+
+  sig {returns(T.untyped)}
+  def self.ruby_scope(); end
+
+  sig {returns(T.untyped)}
+  def self.rubygems(); end
+
+  sig {returns(T.untyped)}
+  def self.settings(); end
+
+  sig do
+    params(
+      groups: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.setup(*groups); end
+
+  sig {returns(T.untyped)}
+  def self.specs_path(); end
+
+  sig do
+    params(
+      str: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.sudo(str); end
+
+  sig {returns(T.untyped)}
+  def self.system_bindir(); end
+
+  sig do
+    params(
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.tmp(name=T.unsafe(nil)); end
+
+  sig do
+    params(
+      login: T.untyped,
+      warning: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.tmp_home_path(login, warning); end
+
+  sig {returns(T.untyped)}
+  def self.ui(); end
+
+  sig do
+    params(
+      ui: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.ui=(ui); end
+
+  sig {returns(T.untyped)}
+  def self.use_system_gems?(); end
+
+  sig do
+    params(
+      dir: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.user_bundle_path(dir=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def self.user_cache(); end
+
+  sig {returns(T.untyped)}
+  def self.user_home(); end
+
+  sig do
+    params(
+      executable: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.which(executable); end
+
+  sig {returns(T.untyped)}
+  def self.with_clean_env(); end
+
+  sig {returns(T.untyped)}
+  def self.with_original_env(); end
+end
+
+class Bundler::APIResponseMismatchError < Bundler::BundlerError
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+module Bundler::BuildMetadata
+  sig {returns(T.untyped)}
+  def self.built_at(); end
+
+  sig {returns(T.untyped)}
+  def self.git_commit_sha(); end
+
+  sig {returns(T.untyped)}
+  def self.release?(); end
+
+  sig {returns(T.untyped)}
+  def self.to_h(); end
+end
+
+class Bundler::BundlerError < StandardError
+  sig {returns(T.untyped)}
+  def self.all_errors(); end
+
+  sig do
+    params(
+      code: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.status_code(code); end
+end
+
+class Bundler::CurrentRuby
+  KNOWN_MAJOR_VERSIONS = ::T.let(nil, T.untyped)
+  KNOWN_MINOR_VERSIONS = ::T.let(nil, T.untyped)
+  KNOWN_PLATFORMS = ::T.let(nil, T.untyped)
+
+  sig {returns(T.untyped)}
+  def jruby?(); end
+
+  sig {returns(T.untyped)}
+  def jruby_18?(); end
+
+  sig {returns(T.untyped)}
+  def jruby_19?(); end
+
+  sig {returns(T.untyped)}
+  def jruby_1?(); end
+
+  sig {returns(T.untyped)}
+  def jruby_20?(); end
+
+  sig {returns(T.untyped)}
+  def jruby_21?(); end
+
+  sig {returns(T.untyped)}
+  def jruby_22?(); end
+
+  sig {returns(T.untyped)}
+  def jruby_23?(); end
+
+  sig {returns(T.untyped)}
+  def jruby_24?(); end
+
+  sig {returns(T.untyped)}
+  def jruby_25?(); end
+
+  sig {returns(T.untyped)}
+  def jruby_26?(); end
+
+  sig {returns(T.untyped)}
+  def jruby_27?(); end
+
+  sig {returns(T.untyped)}
+  def jruby_2?(); end
+
+  sig {returns(T.untyped)}
+  def maglev?(); end
+
+  sig {returns(T.untyped)}
+  def maglev_18?(); end
+
+  sig {returns(T.untyped)}
+  def maglev_19?(); end
+
+  sig {returns(T.untyped)}
+  def maglev_1?(); end
+
+  sig {returns(T.untyped)}
+  def maglev_20?(); end
+
+  sig {returns(T.untyped)}
+  def maglev_21?(); end
+
+  sig {returns(T.untyped)}
+  def maglev_22?(); end
+
+  sig {returns(T.untyped)}
+  def maglev_23?(); end
+
+  sig {returns(T.untyped)}
+  def maglev_24?(); end
+
+  sig {returns(T.untyped)}
+  def maglev_25?(); end
+
+  sig {returns(T.untyped)}
+  def maglev_26?(); end
+
+  sig {returns(T.untyped)}
+  def maglev_27?(); end
+
+  sig {returns(T.untyped)}
+  def maglev_2?(); end
+
+  sig {returns(T.untyped)}
+  def mingw?(); end
+
+  sig {returns(T.untyped)}
+  def mingw_18?(); end
+
+  sig {returns(T.untyped)}
+  def mingw_19?(); end
+
+  sig {returns(T.untyped)}
+  def mingw_1?(); end
+
+  sig {returns(T.untyped)}
+  def mingw_20?(); end
+
+  sig {returns(T.untyped)}
+  def mingw_21?(); end
+
+  sig {returns(T.untyped)}
+  def mingw_22?(); end
+
+  sig {returns(T.untyped)}
+  def mingw_23?(); end
+
+  sig {returns(T.untyped)}
+  def mingw_24?(); end
+
+  sig {returns(T.untyped)}
+  def mingw_25?(); end
+
+  sig {returns(T.untyped)}
+  def mingw_26?(); end
+
+  sig {returns(T.untyped)}
+  def mingw_27?(); end
+
+  sig {returns(T.untyped)}
+  def mingw_2?(); end
+
+  sig {returns(T.untyped)}
+  def mri?(); end
+
+  sig {returns(T.untyped)}
+  def mri_18?(); end
+
+  sig {returns(T.untyped)}
+  def mri_19?(); end
+
+  sig {returns(T.untyped)}
+  def mri_1?(); end
+
+  sig {returns(T.untyped)}
+  def mri_20?(); end
+
+  sig {returns(T.untyped)}
+  def mri_21?(); end
+
+  sig {returns(T.untyped)}
+  def mri_22?(); end
+
+  sig {returns(T.untyped)}
+  def mri_23?(); end
+
+  sig {returns(T.untyped)}
+  def mri_24?(); end
+
+  sig {returns(T.untyped)}
+  def mri_25?(); end
+
+  sig {returns(T.untyped)}
+  def mri_26?(); end
+
+  sig {returns(T.untyped)}
+  def mri_27?(); end
+
+  sig {returns(T.untyped)}
+  def mri_2?(); end
+
+  sig {returns(T.untyped)}
+  def mswin64?(); end
+
+  sig {returns(T.untyped)}
+  def mswin64_18?(); end
+
+  sig {returns(T.untyped)}
+  def mswin64_19?(); end
+
+  sig {returns(T.untyped)}
+  def mswin64_1?(); end
+
+  sig {returns(T.untyped)}
+  def mswin64_20?(); end
+
+  sig {returns(T.untyped)}
+  def mswin64_21?(); end
+
+  sig {returns(T.untyped)}
+  def mswin64_22?(); end
+
+  sig {returns(T.untyped)}
+  def mswin64_23?(); end
+
+  sig {returns(T.untyped)}
+  def mswin64_24?(); end
+
+  sig {returns(T.untyped)}
+  def mswin64_25?(); end
+
+  sig {returns(T.untyped)}
+  def mswin64_26?(); end
+
+  sig {returns(T.untyped)}
+  def mswin64_27?(); end
+
+  sig {returns(T.untyped)}
+  def mswin64_2?(); end
+
+  sig {returns(T.untyped)}
+  def mswin?(); end
+
+  sig {returns(T.untyped)}
+  def mswin_18?(); end
+
+  sig {returns(T.untyped)}
+  def mswin_19?(); end
+
+  sig {returns(T.untyped)}
+  def mswin_1?(); end
+
+  sig {returns(T.untyped)}
+  def mswin_20?(); end
+
+  sig {returns(T.untyped)}
+  def mswin_21?(); end
+
+  sig {returns(T.untyped)}
+  def mswin_22?(); end
+
+  sig {returns(T.untyped)}
+  def mswin_23?(); end
+
+  sig {returns(T.untyped)}
+  def mswin_24?(); end
+
+  sig {returns(T.untyped)}
+  def mswin_25?(); end
+
+  sig {returns(T.untyped)}
+  def mswin_26?(); end
+
+  sig {returns(T.untyped)}
+  def mswin_27?(); end
+
+  sig {returns(T.untyped)}
+  def mswin_2?(); end
+
+  sig {returns(T.untyped)}
+  def on_18?(); end
+
+  sig {returns(T.untyped)}
+  def on_19?(); end
+
+  sig {returns(T.untyped)}
+  def on_1?(); end
+
+  sig {returns(T.untyped)}
+  def on_20?(); end
+
+  sig {returns(T.untyped)}
+  def on_21?(); end
+
+  sig {returns(T.untyped)}
+  def on_22?(); end
+
+  sig {returns(T.untyped)}
+  def on_23?(); end
+
+  sig {returns(T.untyped)}
+  def on_24?(); end
+
+  sig {returns(T.untyped)}
+  def on_25?(); end
+
+  sig {returns(T.untyped)}
+  def on_26?(); end
+
+  sig {returns(T.untyped)}
+  def on_27?(); end
+
+  sig {returns(T.untyped)}
+  def on_2?(); end
+
+  sig {returns(T.untyped)}
+  def rbx?(); end
+
+  sig {returns(T.untyped)}
+  def rbx_18?(); end
+
+  sig {returns(T.untyped)}
+  def rbx_19?(); end
+
+  sig {returns(T.untyped)}
+  def rbx_1?(); end
+
+  sig {returns(T.untyped)}
+  def rbx_20?(); end
+
+  sig {returns(T.untyped)}
+  def rbx_21?(); end
+
+  sig {returns(T.untyped)}
+  def rbx_22?(); end
+
+  sig {returns(T.untyped)}
+  def rbx_23?(); end
+
+  sig {returns(T.untyped)}
+  def rbx_24?(); end
+
+  sig {returns(T.untyped)}
+  def rbx_25?(); end
+
+  sig {returns(T.untyped)}
+  def rbx_26?(); end
+
+  sig {returns(T.untyped)}
+  def rbx_27?(); end
+
+  sig {returns(T.untyped)}
+  def rbx_2?(); end
+
+  sig {returns(T.untyped)}
+  def ruby?(); end
+
+  sig {returns(T.untyped)}
+  def ruby_18?(); end
+
+  sig {returns(T.untyped)}
+  def ruby_19?(); end
+
+  sig {returns(T.untyped)}
+  def ruby_1?(); end
+
+  sig {returns(T.untyped)}
+  def ruby_20?(); end
+
+  sig {returns(T.untyped)}
+  def ruby_21?(); end
+
+  sig {returns(T.untyped)}
+  def ruby_22?(); end
+
+  sig {returns(T.untyped)}
+  def ruby_23?(); end
+
+  sig {returns(T.untyped)}
+  def ruby_24?(); end
+
+  sig {returns(T.untyped)}
+  def ruby_25?(); end
+
+  sig {returns(T.untyped)}
+  def ruby_26?(); end
+
+  sig {returns(T.untyped)}
+  def ruby_27?(); end
+
+  sig {returns(T.untyped)}
+  def ruby_2?(); end
+
+  sig {returns(T.untyped)}
+  def truffleruby?(); end
+
+  sig {returns(T.untyped)}
+  def truffleruby_18?(); end
+
+  sig {returns(T.untyped)}
+  def truffleruby_19?(); end
+
+  sig {returns(T.untyped)}
+  def truffleruby_1?(); end
+
+  sig {returns(T.untyped)}
+  def truffleruby_20?(); end
+
+  sig {returns(T.untyped)}
+  def truffleruby_21?(); end
+
+  sig {returns(T.untyped)}
+  def truffleruby_22?(); end
+
+  sig {returns(T.untyped)}
+  def truffleruby_23?(); end
+
+  sig {returns(T.untyped)}
+  def truffleruby_24?(); end
+
+  sig {returns(T.untyped)}
+  def truffleruby_25?(); end
+
+  sig {returns(T.untyped)}
+  def truffleruby_26?(); end
+
+  sig {returns(T.untyped)}
+  def truffleruby_27?(); end
+
+  sig {returns(T.untyped)}
+  def truffleruby_2?(); end
+
+  sig {returns(T.untyped)}
+  def x64_mingw?(); end
+
+  sig {returns(T.untyped)}
+  def x64_mingw_18?(); end
+
+  sig {returns(T.untyped)}
+  def x64_mingw_19?(); end
+
+  sig {returns(T.untyped)}
+  def x64_mingw_1?(); end
+
+  sig {returns(T.untyped)}
+  def x64_mingw_20?(); end
+
+  sig {returns(T.untyped)}
+  def x64_mingw_21?(); end
+
+  sig {returns(T.untyped)}
+  def x64_mingw_22?(); end
+
+  sig {returns(T.untyped)}
+  def x64_mingw_23?(); end
+
+  sig {returns(T.untyped)}
+  def x64_mingw_24?(); end
+
+  sig {returns(T.untyped)}
+  def x64_mingw_25?(); end
+
+  sig {returns(T.untyped)}
+  def x64_mingw_26?(); end
+
+  sig {returns(T.untyped)}
+  def x64_mingw_27?(); end
+
+  sig {returns(T.untyped)}
+  def x64_mingw_2?(); end
+end
+
+class Bundler::CyclicDependencyError < Bundler::BundlerError
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::Definition
+  include ::Bundler::GemHelpers
+  sig {returns(T.untyped)}
+  def add_current_platform(); end
+
+  sig do
+    params(
+      platform: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def add_platform(platform); end
+
+  sig {returns(T.untyped)}
+  def current_dependencies(); end
+
+  sig {returns(T.untyped)}
+  def dependencies(); end
+
+  sig do
+    params(
+      explicit_flag: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def ensure_equivalent_gemfile_and_lockfile(explicit_flag=T.unsafe(nil)); end
+
+  sig do
+    params(
+      current_spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def find_indexed_specs(current_spec); end
+
+  sig do
+    params(
+      current_spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def find_resolved_spec(current_spec); end
+
+  sig {returns(T.untyped)}
+  def gem_version_promoter(); end
+
+  sig {returns(T.untyped)}
+  def gemfiles(); end
+
+  sig {returns(T.untyped)}
+  def groups(); end
+
+  sig {returns(T.untyped)}
+  def has_local_dependencies?(); end
+
+  sig {returns(T.untyped)}
+  def has_rubygems_remotes?(); end
+
+  sig {returns(T.untyped)}
+  def index(); end
+
+  sig do
+    params(
+      lockfile: T.untyped,
+      dependencies: T.untyped,
+      sources: T.untyped,
+      unlock: T.untyped,
+      ruby_version: T.untyped,
+      optional_groups: T.untyped,
+      gemfiles: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(lockfile, dependencies, sources, unlock, ruby_version=T.unsafe(nil), optional_groups=T.unsafe(nil), gemfiles=T.unsafe(nil)); end
+
+  sig do
+    params(
+      file: T.untyped,
+      preserve_unknown_sections: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def lock(file, preserve_unknown_sections=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def locked_bundler_version(); end
+
+  sig {returns(T.untyped)}
+  def locked_deps(); end
+
+  sig {returns(T.untyped)}
+  def locked_gems(); end
+
+  sig {returns(T.untyped)}
+  def locked_ruby_version(); end
+
+  sig {returns(T.untyped)}
+  def locked_ruby_version_object(); end
+
+  sig {returns(T.untyped)}
+  def lockfile(); end
+
+  sig {returns(T.untyped)}
+  def missing_specs(); end
+
+  sig {returns(T.untyped)}
+  def missing_specs?(); end
+
+  sig {returns(T.untyped)}
+  def new_platform?(); end
+
+  sig {returns(T.untyped)}
+  def new_specs(); end
+
+  sig {returns(T.untyped)}
+  def nothing_changed?(); end
+
+  sig {returns(T.untyped)}
+  def platforms(); end
+
+  sig do
+    params(
+      platform: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def remove_platform(platform); end
+
+  sig {returns(T.untyped)}
+  def removed_specs(); end
+
+  sig {returns(T.untyped)}
+  def requested_specs(); end
+
+  sig {returns(T.untyped)}
+  def requires(); end
+
+  sig {returns(T.untyped)}
+  def resolve(); end
+
+  sig {returns(T.untyped)}
+  def resolve_remotely!(); end
+
+  sig {returns(T.untyped)}
+  def resolve_with_cache!(); end
+
+  sig {returns(T.untyped)}
+  def ruby_version(); end
+
+  sig {returns(T.untyped)}
+  def spec_git_paths(); end
+
+  sig {returns(T.untyped)}
+  def specs(); end
+
+  sig do
+    params(
+      groups: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def specs_for(groups); end
+
+  sig {returns(T.untyped)}
+  def to_lock(); end
+
+  sig {returns(T.untyped)}
+  def unlocking?(); end
+
+  sig {returns(T.untyped)}
+  def validate_platforms!(); end
+
+  sig {returns(T.untyped)}
+  def validate_ruby!(); end
+
+  sig {returns(T.untyped)}
+  def validate_runtime!(); end
+
+  sig do
+    params(
+      gemfile: T.untyped,
+      lockfile: T.untyped,
+      unlock: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.build(gemfile, lockfile, unlock); end
+end
+
+class Bundler::DepProxy
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def ==(other); end
+
+  sig {returns(T.untyped)}
+  def __platform(); end
+
+  sig {returns(T.untyped)}
+  def dep(); end
+
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def eql?(other); end
+
+  sig {returns(T.untyped)}
+  def hash(); end
+
+  sig do
+    params(
+      dep: T.untyped,
+      platform: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(dep, platform); end
+
+  sig {returns(T.untyped)}
+  def name(); end
+
+  sig {returns(T.untyped)}
+  def requirement(); end
+
+  sig {returns(T.untyped)}
+  def to_s(); end
+
+  sig {returns(T.untyped)}
+  def type(); end
+end
+
+class Bundler::Dependency < Gem::Dependency
+  PLATFORM_MAP = ::T.let(nil, T.untyped)
+  REVERSE_PLATFORM_MAP = ::T.let(nil, T.untyped)
+
+  sig {returns(T.untyped)}
+  def autorequire(); end
+
+  sig {returns(T.untyped)}
+  def current_env?(); end
+
+  sig {returns(T.untyped)}
+  def current_platform?(); end
+
+  sig do
+    params(
+      valid_platforms: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def gem_platforms(valid_platforms); end
+
+  sig {returns(T.untyped)}
+  def gemfile(); end
+
+  sig {returns(T.untyped)}
+  def groups(); end
+
+  sig do
+    params(
+      name: T.untyped,
+      version: T.untyped,
+      options: T.untyped,
+      blk: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(name, version, options=T.unsafe(nil), &blk); end
+
+  sig {returns(T.untyped)}
+  def platforms(); end
+
+  sig {returns(T.untyped)}
+  def should_include?(); end
+
+  sig {returns(T.untyped)}
+  def specific?(); end
+
+  sig {returns(T.untyped)}
+  def to_lock(); end
+end
+
+class Bundler::DeprecatedError < Bundler::BundlerError
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::Dsl
+  include ::Bundler::RubyDsl
+  VALID_KEYS = ::T.let(nil, T.untyped)
+  VALID_PLATFORMS = ::T.let(nil, T.untyped)
+
+  sig {returns(T.untyped)}
+  def dependencies(); end
+
+  sig do
+    params(
+      dependencies: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def dependencies=(dependencies); end
+
+  sig do
+    params(
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def env(name); end
+
+  sig do
+    params(
+      gemfile: T.untyped,
+      contents: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def eval_gemfile(gemfile, contents=T.unsafe(nil)); end
+
+  sig do
+    params(
+      name: T.untyped,
+      args: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def gem(name, *args); end
+
+  sig do
+    params(
+      opts: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def gemspec(opts=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def gemspecs(); end
+
+  sig do
+    params(
+      uri: T.untyped,
+      options: T.untyped,
+      blk: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def git(uri, options=T.unsafe(nil), &blk); end
+
+  sig do
+    params(
+      name: T.untyped,
+      block: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def git_source(name, &block); end
+
+  sig do
+    params(
+      repo: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def github(repo, options=T.unsafe(nil)); end
+
+  sig do
+    params(
+      args: T.untyped,
+      blk: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def group(*args, &blk); end
+
+  sig {returns(T.untyped)}
+  def initialize(); end
+
+  sig do
+    params(
+      args: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def install_if(*args); end
+
+  sig do
+    params(
+      name: T.untyped,
+      args: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def method_missing(name, *args); end
+
+  sig do
+    params(
+      path: T.untyped,
+      options: T.untyped,
+      blk: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def path(path, options=T.unsafe(nil), &blk); end
+
+  sig do
+    params(
+      platforms: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def platform(*platforms); end
+
+  sig do
+    params(
+      platforms: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def platforms(*platforms); end
+
+  sig do
+    params(
+      args: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def plugin(*args); end
+
+  sig do
+    params(
+      source: T.untyped,
+      args: T.untyped,
+      blk: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def source(source, *args, &blk); end
+
+  sig do
+    params(
+      lockfile: T.untyped,
+      unlock: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def to_definition(lockfile, unlock); end
+
+  sig do
+    params(
+      gemfile: T.untyped,
+      lockfile: T.untyped,
+      unlock: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.evaluate(gemfile, lockfile, unlock); end
+end
+
+class Bundler::Dsl::DSLError < Bundler::GemfileError
+  sig {returns(T.untyped)}
+  def backtrace(); end
+
+  sig {returns(T.untyped)}
+  def contents(); end
+
+  sig {returns(T.untyped)}
+  def description(); end
+
+  sig {returns(T.untyped)}
+  def dsl_path(); end
+
+  sig do
+    params(
+      description: T.untyped,
+      dsl_path: T.untyped,
+      backtrace: T.untyped,
+      contents: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(description, dsl_path, backtrace, contents=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def status_code(); end
+
+  sig {returns(T.untyped)}
+  def to_s(); end
+end
+
+class Bundler::EndpointSpecification < Gem::Specification
+  # we need this because Gem::Specification extends Enumerable
+  Elem = type_template
+  ILLFORMED_MESSAGE = ::T.let(nil, T.untyped)
+
+  sig do
+    params(
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def __swap__(spec); end
+
+  sig {returns(T.untyped)}
+  def _local_specification(); end
+
+  sig {returns(T.untyped)}
+  def bindir(); end
+
+  sig {returns(T.untyped)}
+  def checksum(); end
+
+  sig {returns(T.untyped)}
+  def dependencies(); end
+
+  sig do
+    params(
+      dependencies: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def dependencies=(dependencies); end
+
+  sig {returns(T.untyped)}
+  def executables(); end
+
+  sig {returns(T.untyped)}
+  def extensions(); end
+
+  sig {returns(T.untyped)}
+  def fetch_platform(); end
+
+  sig do
+    params(
+      name: T.untyped,
+      version: T.untyped,
+      platform: T.untyped,
+      dependencies: T.untyped,
+      metadata: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(name, version, platform, dependencies, metadata=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def load_paths(); end
+
+  sig {returns(T.untyped)}
+  def name(); end
+
+  sig {returns(T.untyped)}
+  def platform(); end
+
+  sig {returns(T.untyped)}
+  def post_install_message(); end
+
+  sig {returns(T.untyped)}
+  def remote(); end
+
+  sig do
+    params(
+      remote: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def remote=(remote); end
+
+  sig {returns(T.untyped)}
+  def require_paths(); end
+
+  sig {returns(T.untyped)}
+  def required_ruby_version(); end
+
+  sig {returns(T.untyped)}
+  def required_rubygems_version(); end
+
+  sig {returns(T.untyped)}
+  def source(); end
+
+  sig do
+    params(
+      source: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def source=(source); end
+
+  sig {returns(T.untyped)}
+  def version(); end
+end
+
+class Bundler::EnvironmentPreserver
+  BUNDLER_KEYS = ::T.let(nil, T.untyped)
+  BUNDLER_PREFIX = ::T.let(nil, T.untyped)
+  INTENTIONALLY_NIL = ::T.let(nil, T.untyped)
+
+  sig {returns(T.untyped)}
+  def backup(); end
+
+  sig do
+    params(
+      env: T.untyped,
+      keys: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(env, keys); end
+
+  sig {returns(T.untyped)}
+  def restore(); end
+end
+
+class Bundler::FeatureFlag
+  sig {returns(T.untyped)}
+  def allow_bundler_dependency_conflicts?(); end
+
+  sig {returns(T.untyped)}
+  def allow_offline_install?(); end
+
+  sig {returns(T.untyped)}
+  def auto_clean_without_path?(); end
+
+  sig {returns(T.untyped)}
+  def auto_config_jobs?(); end
+
+  sig {returns(T.untyped)}
+  def bundler_10_mode?(); end
+
+  sig {returns(T.untyped)}
+  def bundler_1_mode?(); end
+
+  sig {returns(T.untyped)}
+  def bundler_2_mode?(); end
+
+  sig {returns(T.untyped)}
+  def bundler_3_mode?(); end
+
+  sig {returns(T.untyped)}
+  def bundler_4_mode?(); end
+
+  sig {returns(T.untyped)}
+  def bundler_5_mode?(); end
+
+  sig {returns(T.untyped)}
+  def bundler_6_mode?(); end
+
+  sig {returns(T.untyped)}
+  def bundler_7_mode?(); end
+
+  sig {returns(T.untyped)}
+  def bundler_8_mode?(); end
+
+  sig {returns(T.untyped)}
+  def bundler_9_mode?(); end
+
+  sig {returns(T.untyped)}
+  def cache_all?(); end
+
+  sig {returns(T.untyped)}
+  def cache_command_is_package?(); end
+
+  sig {returns(T.untyped)}
+  def console_command?(); end
+
+  sig {returns(T.untyped)}
+  def default_cli_command(); end
+
+  sig {returns(T.untyped)}
+  def default_install_uses_path?(); end
+
+  sig {returns(T.untyped)}
+  def deployment_means_frozen?(); end
+
+  sig {returns(T.untyped)}
+  def disable_multisource?(); end
+
+  sig {returns(T.untyped)}
+  def error_on_stderr?(); end
+
+  sig {returns(T.untyped)}
+  def forget_cli_options?(); end
+
+  sig {returns(T.untyped)}
+  def global_gem_cache?(); end
+
+  sig {returns(T.untyped)}
+  def global_path_appends_ruby_scope?(); end
+
+  sig {returns(T.untyped)}
+  def init_gems_rb?(); end
+
+  sig do
+    params(
+      bundler_version: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(bundler_version); end
+
+  sig {returns(T.untyped)}
+  def list_command?(); end
+
+  sig {returns(T.untyped)}
+  def lockfile_uses_separate_rubygems_sources?(); end
+
+  sig {returns(T.untyped)}
+  def only_update_to_newer_versions?(); end
+
+  sig {returns(T.untyped)}
+  def path_relative_to_cwd?(); end
+
+  sig {returns(T.untyped)}
+  def plugins?(); end
+
+  sig {returns(T.untyped)}
+  def prefer_gems_rb?(); end
+
+  sig {returns(T.untyped)}
+  def print_only_version_number?(); end
+
+  sig {returns(T.untyped)}
+  def setup_makes_kernel_gem_public?(); end
+
+  sig {returns(T.untyped)}
+  def skip_default_git_sources?(); end
+
+  sig {returns(T.untyped)}
+  def specific_platform?(); end
+
+  sig {returns(T.untyped)}
+  def suppress_install_using_messages?(); end
+
+  sig {returns(T.untyped)}
+  def unlock_source_unlocks_spec?(); end
+
+  sig {returns(T.untyped)}
+  def update_requires_all_flag?(); end
+
+  sig {returns(T.untyped)}
+  def use_gem_version_promoter_for_major_updates?(); end
+
+  sig {returns(T.untyped)}
+  def viz_command?(); end
+end
+
+module Bundler::FileUtils
+  include ::Bundler::FileUtils::StreamUtils_
+  extend ::Bundler::FileUtils::StreamUtils_
+  LOW_METHODS = ::T.let(nil, T.untyped)
+  METHODS = ::T.let(nil, T.untyped)
+  OPT_TABLE = ::T.let(nil, T.untyped)
+
+  sig do
+    params(
+      dir: T.untyped,
+      verbose: T.untyped,
+      block: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.cd(dir, verbose: T.unsafe(nil), &block); end
+
+  sig do
+    params(
+      dir: T.untyped,
+      verbose: T.untyped,
+      block: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.chdir(dir, verbose: T.unsafe(nil), &block); end
+
+  sig do
+    params(
+      mode: T.untyped,
+      list: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.chmod(mode, list, noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  sig do
+    params(
+      mode: T.untyped,
+      list: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+      force: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.chmod_R(mode, list, noop: T.unsafe(nil), verbose: T.unsafe(nil), force: T.unsafe(nil)); end
+
+  sig do
+    params(
+      user: T.untyped,
+      group: T.untyped,
+      list: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.chown(user, group, list, noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  sig do
+    params(
+      user: T.untyped,
+      group: T.untyped,
+      list: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+      force: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.chown_R(user, group, list, noop: T.unsafe(nil), verbose: T.unsafe(nil), force: T.unsafe(nil)); end
+
+  sig do
+    params(
+      a: T.untyped,
+      b: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.cmp(a, b); end
+
+  sig do
+    params(
+      opt: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.collect_method(opt); end
+
+  sig {returns(T.untyped)}
+  def self.commands(); end
+
+  sig do
+    params(
+      a: T.untyped,
+      b: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.compare_file(a, b); end
+
+  sig do
+    params(
+      a: T.untyped,
+      b: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.compare_stream(a, b); end
+
+  sig do
+    params(
+      src: T.untyped,
+      dest: T.untyped,
+      preserve: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.copy(src, dest, preserve: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  sig do
+    params(
+      src: T.untyped,
+      dest: T.untyped,
+      preserve: T.untyped,
+      dereference_root: T.untyped,
+      remove_destination: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.copy_entry(src, dest, preserve=T.unsafe(nil), dereference_root=T.unsafe(nil), remove_destination=T.unsafe(nil)); end
+
+  sig do
+    params(
+      src: T.untyped,
+      dest: T.untyped,
+      preserve: T.untyped,
+      dereference: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.copy_file(src, dest, preserve=T.unsafe(nil), dereference=T.unsafe(nil)); end
+
+  sig do
+    params(
+      src: T.untyped,
+      dest: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.copy_stream(src, dest); end
+
+  sig do
+    params(
+      src: T.untyped,
+      dest: T.untyped,
+      preserve: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.cp(src, dest, preserve: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  sig do
+    params(
+      src: T.untyped,
+      dest: T.untyped,
+      preserve: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+      dereference_root: T.untyped,
+      remove_destination: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.cp_r(src, dest, preserve: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil), dereference_root: T.unsafe(nil), remove_destination: T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def self.getwd(); end
+
+  sig do
+    params(
+      mid: T.untyped,
+      opt: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.have_option?(mid, opt); end
+
+  sig do
+    params(
+      a: T.untyped,
+      b: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.identical?(a, b); end
+
+  sig do
+    params(
+      src: T.untyped,
+      dest: T.untyped,
+      mode: T.untyped,
+      owner: T.untyped,
+      group: T.untyped,
+      preserve: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.install(src, dest, mode: T.unsafe(nil), owner: T.unsafe(nil), group: T.unsafe(nil), preserve: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  sig do
+    params(
+      src: T.untyped,
+      dest: T.untyped,
+      force: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.link(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  sig do
+    params(
+      src: T.untyped,
+      dest: T.untyped,
+      force: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.ln(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  sig do
+    params(
+      src: T.untyped,
+      dest: T.untyped,
+      force: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.ln_s(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  sig do
+    params(
+      src: T.untyped,
+      dest: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.ln_sf(src, dest, noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  sig do
+    params(
+      list: T.untyped,
+      mode: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.makedirs(list, mode: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  sig do
+    params(
+      list: T.untyped,
+      mode: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.mkdir(list, mode: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  sig do
+    params(
+      list: T.untyped,
+      mode: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.mkdir_p(list, mode: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  sig do
+    params(
+      list: T.untyped,
+      mode: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.mkpath(list, mode: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  sig do
+    params(
+      src: T.untyped,
+      dest: T.untyped,
+      force: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+      secure: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.move(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil), secure: T.unsafe(nil)); end
+
+  sig do
+    params(
+      src: T.untyped,
+      dest: T.untyped,
+      force: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+      secure: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.mv(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil), secure: T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def self.options(); end
+
+  sig do
+    params(
+      mid: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.options_of(mid); end
+
+  sig do
+    params(
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.private_module_function(name); end
+
+  sig {returns(T.untyped)}
+  def self.pwd(); end
+
+  sig do
+    params(
+      list: T.untyped,
+      force: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.remove(list, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  sig do
+    params(
+      path: T.untyped,
+      force: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.remove_dir(path, force=T.unsafe(nil)); end
+
+  sig do
+    params(
+      path: T.untyped,
+      force: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.remove_entry(path, force=T.unsafe(nil)); end
+
+  sig do
+    params(
+      path: T.untyped,
+      force: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.remove_entry_secure(path, force=T.unsafe(nil)); end
+
+  sig do
+    params(
+      path: T.untyped,
+      force: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.remove_file(path, force=T.unsafe(nil)); end
+
+  sig do
+    params(
+      list: T.untyped,
+      force: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rm(list, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  sig do
+    params(
+      list: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rm_f(list, noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  sig do
+    params(
+      list: T.untyped,
+      force: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+      secure: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rm_r(list, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil), secure: T.unsafe(nil)); end
+
+  sig do
+    params(
+      list: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+      secure: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rm_rf(list, noop: T.unsafe(nil), verbose: T.unsafe(nil), secure: T.unsafe(nil)); end
+
+  sig do
+    params(
+      list: T.untyped,
+      parents: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rmdir(list, parents: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  sig do
+    params(
+      list: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+      secure: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rmtree(list, noop: T.unsafe(nil), verbose: T.unsafe(nil), secure: T.unsafe(nil)); end
+
+  sig do
+    params(
+      list: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.safe_unlink(list, noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  sig do
+    params(
+      src: T.untyped,
+      dest: T.untyped,
+      force: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.symlink(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  sig do
+    params(
+      list: T.untyped,
+      noop: T.untyped,
+      verbose: T.untyped,
+      mtime: T.untyped,
+      nocreate: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.touch(list, noop: T.unsafe(nil), verbose: T.unsafe(nil), mtime: T.unsafe(nil), nocreate: T.unsafe(nil)); end
+
+  sig do
+    params(
+      new: T.untyped,
+      old_list: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.uptodate?(new, old_list); end
+end
+
+module Bundler::FileUtils::DryRun
+  include ::Bundler::FileUtils::LowMethods
+  include ::Bundler::FileUtils
+  include ::Bundler::FileUtils::StreamUtils_
+  extend ::Bundler::FileUtils::DryRun
+  extend ::Bundler::FileUtils::LowMethods
+  extend ::Bundler::FileUtils
+  extend ::Bundler::FileUtils::StreamUtils_
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.cd(*_); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.chdir(*_); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.chmod(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.chmod_R(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.chown(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.chown_R(*args, **options); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.cmp(*_); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.compare_file(*_); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.compare_stream(*_); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.copy(*args, **options); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.copy_entry(*_); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.copy_file(*_); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.copy_stream(*_); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.cp(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.cp_r(*args, **options); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.getwd(*_); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.identical?(*_); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.install(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.link(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.ln(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.ln_s(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.ln_sf(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.makedirs(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.mkdir(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.mkdir_p(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.mkpath(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.move(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.mv(*args, **options); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.pwd(*_); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.remove(*args, **options); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.remove_dir(*_); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.remove_entry(*_); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.remove_entry_secure(*_); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.remove_file(*_); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rm(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rm_f(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rm_r(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rm_rf(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rmdir(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rmtree(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.safe_unlink(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.symlink(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.touch(*args, **options); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.uptodate?(*_); end
+end
+
+class Bundler::FileUtils::Entry_
+  include ::Bundler::FileUtils::StreamUtils_
+  DIRECTORY_TERM = ::T.let(nil, T.untyped)
+  SYSCASE = ::T.let(nil, T.untyped)
+  S_IF_DOOR = ::T.let(nil, T.untyped)
+
+  sig {returns(T.untyped)}
+  def blockdev?(); end
+
+  sig {returns(T.untyped)}
+  def chardev?(); end
+
+  sig do
+    params(
+      mode: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def chmod(mode); end
+
+  sig do
+    params(
+      uid: T.untyped,
+      gid: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def chown(uid, gid); end
+
+  sig do
+    params(
+      dest: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def copy(dest); end
+
+  sig do
+    params(
+      dest: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def copy_file(dest); end
+
+  sig do
+    params(
+      path: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def copy_metadata(path); end
+
+  sig {returns(T.untyped)}
+  def dereference?(); end
+
+  sig {returns(T.untyped)}
+  def directory?(); end
+
+  sig {returns(T.untyped)}
+  def door?(); end
+
+  sig {returns(T.untyped)}
+  def entries(); end
+
+  sig {returns(T.untyped)}
+  def exist?(); end
+
+  sig {returns(T.untyped)}
+  def file?(); end
+
+  sig do
+    params(
+      a: T.untyped,
+      b: T.untyped,
+      deref: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(a, b=T.unsafe(nil), deref=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def inspect(); end
+
+  sig {returns(T.untyped)}
+  def lstat(); end
+
+  sig {returns(T.untyped)}
+  def lstat!(); end
+
+  sig {returns(T.untyped)}
+  def path(); end
+
+  sig {returns(T.untyped)}
+  def pipe?(); end
+
+  sig {returns(T.untyped)}
+  def platform_support(); end
+
+  sig {returns(T.untyped)}
+  def postorder_traverse(); end
+
+  sig {returns(T.untyped)}
+  def prefix(); end
+
+  sig {returns(T.untyped)}
+  def preorder_traverse(); end
+
+  sig {returns(T.untyped)}
+  def rel(); end
+
+  sig {returns(T.untyped)}
+  def remove(); end
+
+  sig {returns(T.untyped)}
+  def remove_dir1(); end
+
+  sig {returns(T.untyped)}
+  def remove_file(); end
+
+  sig {returns(T.untyped)}
+  def socket?(); end
+
+  sig {returns(T.untyped)}
+  def stat(); end
+
+  sig {returns(T.untyped)}
+  def stat!(); end
+
+  sig {returns(T.untyped)}
+  def symlink?(); end
+
+  sig {returns(T.untyped)}
+  def traverse(); end
+
+  sig do
+    params(
+      pre: T.untyped,
+      post: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def wrap_traverse(pre, post); end
+end
+
+module Bundler::FileUtils::LowMethods
+end
+
+module Bundler::FileUtils::NoWrite
+  include ::Bundler::FileUtils::LowMethods
+  include ::Bundler::FileUtils
+  include ::Bundler::FileUtils::StreamUtils_
+  extend ::Bundler::FileUtils::NoWrite
+  extend ::Bundler::FileUtils::LowMethods
+  extend ::Bundler::FileUtils
+  extend ::Bundler::FileUtils::StreamUtils_
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.cd(*_); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.chdir(*_); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.chmod(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.chmod_R(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.chown(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.chown_R(*args, **options); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.cmp(*_); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.compare_file(*_); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.compare_stream(*_); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.copy(*args, **options); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.copy_entry(*_); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.copy_file(*_); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.copy_stream(*_); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.cp(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.cp_r(*args, **options); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.getwd(*_); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.identical?(*_); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.install(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.link(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.ln(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.ln_s(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.ln_sf(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.makedirs(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.mkdir(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.mkdir_p(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.mkpath(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.move(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.mv(*args, **options); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.pwd(*_); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.remove(*args, **options); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.remove_dir(*_); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.remove_entry(*_); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.remove_entry_secure(*_); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.remove_file(*_); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rm(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rm_f(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rm_r(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rm_rf(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rmdir(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rmtree(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.safe_unlink(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.symlink(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.touch(*args, **options); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.uptodate?(*_); end
+end
+
+module Bundler::FileUtils::StreamUtils_
+end
+
+module Bundler::FileUtils::Verbose
+  include ::Bundler::FileUtils
+  include ::Bundler::FileUtils::StreamUtils_
+  extend ::Bundler::FileUtils::Verbose
+  extend ::Bundler::FileUtils
+  extend ::Bundler::FileUtils::StreamUtils_
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.cd(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.chdir(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.chmod(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.chmod_R(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.chown(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.chown_R(*args, **options); end
+
+  sig do
+    params(
+      a: T.untyped,
+      b: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.cmp(a, b); end
+
+  sig do
+    params(
+      a: T.untyped,
+      b: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.compare_file(a, b); end
+
+  sig do
+    params(
+      a: T.untyped,
+      b: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.compare_stream(a, b); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.copy(*args, **options); end
+
+  sig do
+    params(
+      src: T.untyped,
+      dest: T.untyped,
+      preserve: T.untyped,
+      dereference_root: T.untyped,
+      remove_destination: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.copy_entry(src, dest, preserve=T.unsafe(nil), dereference_root=T.unsafe(nil), remove_destination=T.unsafe(nil)); end
+
+  sig do
+    params(
+      src: T.untyped,
+      dest: T.untyped,
+      preserve: T.untyped,
+      dereference: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.copy_file(src, dest, preserve=T.unsafe(nil), dereference=T.unsafe(nil)); end
+
+  sig do
+    params(
+      src: T.untyped,
+      dest: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.copy_stream(src, dest); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.cp(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.cp_r(*args, **options); end
+
+  sig {returns(T.untyped)}
+  def self.getwd(); end
+
+  sig do
+    params(
+      a: T.untyped,
+      b: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.identical?(a, b); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.install(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.link(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.ln(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.ln_s(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.ln_sf(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.makedirs(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.mkdir(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.mkdir_p(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.mkpath(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.move(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.mv(*args, **options); end
+
+  sig {returns(T.untyped)}
+  def self.pwd(); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.remove(*args, **options); end
+
+  sig do
+    params(
+      path: T.untyped,
+      force: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.remove_dir(path, force=T.unsafe(nil)); end
+
+  sig do
+    params(
+      path: T.untyped,
+      force: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.remove_entry(path, force=T.unsafe(nil)); end
+
+  sig do
+    params(
+      path: T.untyped,
+      force: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.remove_entry_secure(path, force=T.unsafe(nil)); end
+
+  sig do
+    params(
+      path: T.untyped,
+      force: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.remove_file(path, force=T.unsafe(nil)); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rm(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rm_f(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rm_r(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rm_rf(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rmdir(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.rmtree(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.safe_unlink(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.symlink(*args, **options); end
+
+  sig do
+    params(
+      args: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.touch(*args, **options); end
+
+  sig do
+    params(
+      new: T.untyped,
+      old_list: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.uptodate?(new, old_list); end
+end
+
+module Bundler::GemHelpers
+  GENERICS = ::T.let(nil, T.untyped)
+  GENERIC_CACHE = ::T.let(nil, T.untyped)
+
+  sig do
+    params(
+      p: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.generic(p); end
+
+  sig {returns(T.untyped)}
+  def self.generic_local_platform(); end
+
+  sig do
+    params(
+      spec_platform: T.untyped,
+      user_platform: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.platform_specificity_match(spec_platform, user_platform); end
+
+  sig do
+    params(
+      specs: T.untyped,
+      platform: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.select_best_platform_match(specs, platform); end
+end
+
+class Bundler::GemHelpers::PlatformMatch < Struct
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
+
+  EXACT_MATCH = ::T.let(nil, T.untyped)
+  WORST_MATCH = ::T.let(nil, T.untyped)
+
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def <=>(other); end
+
+  sig {returns(T.untyped)}
+  def cpu_match(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def cpu_match=(_); end
+
+  sig {returns(T.untyped)}
+  def os_match(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def os_match=(_); end
+
+  sig {returns(T.untyped)}
+  def platform_version_match(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def platform_version_match=(_); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.[](*_); end
+
+  sig do
+    params(
+      spec_platform: T.untyped,
+      user_platform: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.cpu_match(spec_platform, user_platform); end
+
+  sig {returns(T.untyped)}
+  def self.members(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.new(*_); end
+
+  sig do
+    params(
+      spec_platform: T.untyped,
+      user_platform: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.os_match(spec_platform, user_platform); end
+
+  sig do
+    params(
+      spec_platform: T.untyped,
+      user_platform: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.platform_version_match(spec_platform, user_platform); end
+end
+
+class Bundler::GemNotFound < Bundler::BundlerError
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::GemRequireError < Bundler::BundlerError
+  sig do
+    params(
+      orig_exception: T.untyped,
+      msg: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(orig_exception, msg); end
+
+  sig {returns(T.untyped)}
+  def orig_exception(); end
+
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::GemfileError < Bundler::BundlerError
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::GemfileEvalError < Bundler::GemfileError
+end
+
+class Bundler::GemfileLockNotFound < Bundler::BundlerError
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::GemfileNotFound < Bundler::BundlerError
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::GemspecError < Bundler::BundlerError
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::GenericSystemCallError < Bundler::BundlerError
+  sig do
+    params(
+      underlying_error: T.untyped,
+      message: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(underlying_error, message); end
+
+  sig {returns(T.untyped)}
+  def status_code(); end
+
+  sig {returns(T.untyped)}
+  def underlying_error(); end
+end
+
+class Bundler::GitError < Bundler::BundlerError
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::HTTPError < Bundler::BundlerError
+  sig do
+    params(
+      uri: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def filter_uri(uri); end
+
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::Fetcher::AuthenticationRequiredError < Bundler::HTTPError
+end
+
+class Bundler::Fetcher::BadAuthenticationError < Bundler::HTTPError
+end
+
+class Bundler::Fetcher::CertificateFailureError < Bundler::HTTPError
+end
+
+class Bundler::Fetcher::FallbackError < Bundler::HTTPError
+end
+
+class Bundler::Fetcher::NetworkDownError < Bundler::HTTPError
+end
+
+class Bundler::Fetcher::SSLError < Bundler::HTTPError
+end
+
+class Bundler::Index
+  include T::Enumerable
+  EMPTY_SEARCH = ::T.let(nil, T.untyped)
+  NULL = ::T.let(nil, T.untyped)
+  RUBY = ::T.let(nil, T.untyped)
+
+  sig do
+    params(
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def <<(spec); end
+
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def ==(other); end
+
+  sig do
+    params(
+      query: T.untyped,
+      base: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def [](query, base=T.unsafe(nil)); end
+
+  sig do
+    params(
+      index: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def add_source(index); end
+
+  sig {returns(T.untyped)}
+  def all_specs(); end
+
+  sig do
+    params(
+      spec: T.untyped,
+      other_spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def dependencies_eql?(spec, other_spec); end
+
+  sig {returns(T.untyped)}
+  def dependency_names(); end
+
+  sig do
+    params(
+      blk: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def each(&blk); end
+
+  sig {returns(T.untyped)}
+  def empty?(); end
+
+  sig {returns(T.untyped)}
+  def initialize(); end
+
+  sig {returns(T.untyped)}
+  def inspect(); end
+
+  sig do
+    params(
+      query: T.untyped,
+      base: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def local_search(query, base=T.unsafe(nil)); end
+
+  sig do
+    params(
+      query: T.untyped,
+      base: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def search(query, base=T.unsafe(nil)); end
+
+  sig do
+    params(
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def search_all(name); end
+
+  sig {returns(T.untyped)}
+  def size(); end
+
+  sig do
+    params(
+      specs: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def sort_specs(specs); end
+
+  sig {returns(T.untyped)}
+  def sources(); end
+
+  sig {returns(T.untyped)}
+  def spec_names(); end
+
+  sig {returns(T.untyped)}
+  def specs(); end
+
+  sig {returns(T.untyped)}
+  def unmet_dependency_names(); end
+
+  sig do
+    params(
+      query: T.untyped,
+      base: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def unsorted_search(query, base); end
+
+  sig do
+    params(
+      other: T.untyped,
+      override_dupes: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def use(other, override_dupes=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def self.build(); end
+
+  sig do
+    params(
+      specs: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.sort_specs(specs); end
+end
+
+class Bundler::InstallError < Bundler::BundlerError
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::InstallHookError < Bundler::BundlerError
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::InvalidOption < Bundler::BundlerError
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::LazySpecification
+  include ::Bundler::MatchPlatform
+  include ::Bundler::GemHelpers
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def ==(other); end
+
+  sig {returns(T.untyped)}
+  def __materialize__(); end
+
+  sig {returns(T.untyped)}
+  def dependencies(); end
+
+  sig {returns(T.untyped)}
+  def full_name(); end
+
+  sig {returns(T.untyped)}
+  def git_version(); end
+
+  sig {returns(T.untyped)}
+  def identifier(); end
+
+  sig do
+    params(
+      name: T.untyped,
+      version: T.untyped,
+      platform: T.untyped,
+      source: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(name, version, platform, source=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def name(); end
+
+  sig {returns(T.untyped)}
+  def platform(); end
+
+  sig {returns(T.untyped)}
+  def remote(); end
+
+  sig do
+    params(
+      remote: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def remote=(remote); end
+
+  sig do
+    params(
+      args: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def respond_to?(*args); end
+
+  sig do
+    params(
+      dependency: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def satisfies?(dependency); end
+
+  sig {returns(T.untyped)}
+  def source(); end
+
+  sig do
+    params(
+      source: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def source=(source); end
+
+  sig {returns(T.untyped)}
+  def to_lock(); end
+
+  sig {returns(T.untyped)}
+  def to_s(); end
+
+  sig {returns(T.untyped)}
+  def version(); end
+end
+
+class Bundler::LazySpecification::Identifier < Struct
+  include ::Comparable
+  extend ::T::Generic
+
+  Elem = type_member(fixed: T.untyped)
+
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def <=>(other); end
+
+  sig {returns(T.untyped)}
+  def dependencies(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def dependencies=(_); end
+
+  sig {returns(T.untyped)}
+  def name(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def name=(_); end
+
+  sig {returns(T.untyped)}
+  def platform(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def platform=(_); end
+
+  sig {returns(T.untyped)}
+  def platform_string(); end
+
+  sig {returns(T.untyped)}
+  def source(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def source=(_); end
+
+  sig {returns(T.untyped)}
+  def version(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def version=(_); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.[](*_); end
+
+  sig {returns(T.untyped)}
+  def self.members(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.new(*_); end
+end
+
+class Bundler::LockfileError < Bundler::BundlerError
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::LockfileParser
+  BUNDLED = ::T.let(nil, T.untyped)
+  DEPENDENCIES = ::T.let(nil, T.untyped)
+  ENVIRONMENT_VERSION_SECTIONS = ::T.let(nil, T.untyped)
+  GEM = ::T.let(nil, T.untyped)
+  GIT = ::T.let(nil, T.untyped)
+  KNOWN_SECTIONS = ::T.let(nil, T.untyped)
+  NAME_VERSION = ::T.let(nil, T.untyped)
+  OPTIONS = ::T.let(nil, T.untyped)
+  PATH = ::T.let(nil, T.untyped)
+  PLATFORMS = ::T.let(nil, T.untyped)
+  PLUGIN = ::T.let(nil, T.untyped)
+  RUBY = ::T.let(nil, T.untyped)
+  SECTIONS_BY_VERSION_INTRODUCED = ::T.let(nil, T.untyped)
+  SOURCE = ::T.let(nil, T.untyped)
+  SPECS = ::T.let(nil, T.untyped)
+  TYPES = ::T.let(nil, T.untyped)
+
+  sig {returns(T.untyped)}
+  def bundler_version(); end
+
+  sig {returns(T.untyped)}
+  def dependencies(); end
+
+  sig do
+    params(
+      lockfile: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(lockfile); end
+
+  sig {returns(T.untyped)}
+  def platforms(); end
+
+  sig {returns(T.untyped)}
+  def ruby_version(); end
+
+  sig {returns(T.untyped)}
+  def sources(); end
+
+  sig {returns(T.untyped)}
+  def specs(); end
+
+  sig {returns(T.untyped)}
+  def warn_for_outdated_bundler_version(); end
+
+  sig do
+    params(
+      lockfile_contents: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.sections_in_lockfile(lockfile_contents); end
+
+  sig do
+    params(
+      base_version: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.sections_to_ignore(base_version=T.unsafe(nil)); end
+
+  sig do
+    params(
+      lockfile_contents: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.unknown_sections_in_lockfile(lockfile_contents); end
+end
+
+class Bundler::MarshalError < StandardError
+end
+
+module Bundler::MatchPlatform
+  include ::Bundler::GemHelpers
+  sig do
+    params(
+      p: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def match_platform(p); end
+
+  sig do
+    params(
+      gemspec_platform: T.untyped,
+      local_platform: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.platforms_match?(gemspec_platform, local_platform); end
+end
+
+module Bundler::Molinillo
+  VERSION = ::T.let(nil, T.untyped)
+
+end
+
+class Bundler::Molinillo::CircularDependencyError < Bundler::Molinillo::ResolverError
+  sig {returns(T.untyped)}
+  def dependencies(); end
+
+  sig do
+    params(
+      vertices: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(vertices); end
+end
+
+module Bundler::Molinillo::Compatibility
+  sig do
+    params(
+      enum: T.untyped,
+      blk: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.flat_map(enum, &blk); end
+end
+
+module Bundler::Molinillo::Delegates
+end
+
+module Bundler::Molinillo::Delegates::ResolutionState
+  sig {returns(T.untyped)}
+  def activated(); end
+
+  sig {returns(T.untyped)}
+  def conflicts(); end
+
+  sig {returns(T.untyped)}
+  def depth(); end
+
+  sig {returns(T.untyped)}
+  def name(); end
+
+  sig {returns(T.untyped)}
+  def possibilities(); end
+
+  sig {returns(T.untyped)}
+  def requirement(); end
+
+  sig {returns(T.untyped)}
+  def requirements(); end
+
+  sig {returns(T.untyped)}
+  def unused_unwind_options(); end
+end
+
+module Bundler::Molinillo::Delegates::SpecificationProvider
+  sig do
+    params(
+      dependency: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def allow_missing?(dependency); end
+
+  sig do
+    params(
+      specification: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def dependencies_for(specification); end
+
+  sig do
+    params(
+      dependency: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def name_for(dependency); end
+
+  sig {returns(T.untyped)}
+  def name_for_explicit_dependency_source(); end
+
+  sig {returns(T.untyped)}
+  def name_for_locking_dependency_source(); end
+
+  sig do
+    params(
+      requirement: T.untyped,
+      activated: T.untyped,
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def requirement_satisfied_by?(requirement, activated, spec); end
+
+  sig do
+    params(
+      dependency: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def search_for(dependency); end
+
+  sig do
+    params(
+      dependencies: T.untyped,
+      activated: T.untyped,
+      conflicts: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def sort_dependencies(dependencies, activated, conflicts); end
+end
+
+class Bundler::Molinillo::DependencyGraph
+  include ::TSort
+  include T::Enumerable
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def ==(other); end
+
+  sig do
+    params(
+      name: T.untyped,
+      payload: T.untyped,
+      parent_names: T.untyped,
+      requirement: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def add_child_vertex(name, payload, parent_names, requirement); end
+
+  sig do
+    params(
+      origin: T.untyped,
+      destination: T.untyped,
+      requirement: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def add_edge(origin, destination, requirement); end
+
+  sig do
+    params(
+      name: T.untyped,
+      payload: T.untyped,
+      root: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def add_vertex(name, payload, root=T.unsafe(nil)); end
+
+  sig do
+    params(
+      edge: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def delete_edge(edge); end
+
+  sig do
+    params(
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def detach_vertex_named(name); end
+
+  sig do
+    params(
+      blk: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def each(&blk); end
+
+  sig {returns(T.untyped)}
+  def initialize(); end
+
+  sig {returns(T.untyped)}
+  def inspect(); end
+
+  sig {returns(T.untyped)}
+  def log(); end
+
+  sig do
+    params(
+      tag: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def rewind_to(tag); end
+
+  sig do
+    params(
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def root_vertex_named(name); end
+
+  sig do
+    params(
+      name: T.untyped,
+      payload: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def set_payload(name, payload); end
+
+  sig do
+    params(
+      tag: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def tag(tag); end
+
+  sig do
+    params(
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def to_dot(options=T.unsafe(nil)); end
+
+  sig do
+    params(
+      vertex: T.untyped,
+      block: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def tsort_each_child(vertex, &block); end
+
+  sig {returns(T.untyped)}
+  def tsort_each_node(); end
+
+  sig do
+    params(
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def vertex_named(name); end
+
+  sig {returns(T.untyped)}
+  def vertices(); end
+
+  sig do
+    params(
+      vertices: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.tsort(vertices); end
+end
+
+class Bundler::Molinillo::DependencyGraph::Action
+  sig do
+    params(
+      graph: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def down(graph); end
+
+  sig {returns(T.untyped)}
+  def next(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def next=(_); end
+
+  sig {returns(T.untyped)}
+  def previous(); end
+
+  sig do
+    params(
+      previous: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def previous=(previous); end
+
+  sig do
+    params(
+      graph: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def up(graph); end
+
+  sig {returns(T.untyped)}
+  def self.action_name(); end
+end
+
+class Bundler::Molinillo::DependencyGraph::AddEdgeNoCircular < Bundler::Molinillo::DependencyGraph::Action
+  sig {returns(T.untyped)}
+  def destination(); end
+
+  sig do
+    params(
+      graph: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def down(graph); end
+
+  sig do
+    params(
+      origin: T.untyped,
+      destination: T.untyped,
+      requirement: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(origin, destination, requirement); end
+
+  sig do
+    params(
+      graph: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def make_edge(graph); end
+
+  sig {returns(T.untyped)}
+  def origin(); end
+
+  sig {returns(T.untyped)}
+  def requirement(); end
+
+  sig do
+    params(
+      graph: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def up(graph); end
+
+  sig {returns(T.untyped)}
+  def self.action_name(); end
+end
+
+class Bundler::Molinillo::DependencyGraph::AddVertex < Bundler::Molinillo::DependencyGraph::Action
+  sig do
+    params(
+      graph: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def down(graph); end
+
+  sig do
+    params(
+      name: T.untyped,
+      payload: T.untyped,
+      root: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(name, payload, root); end
+
+  sig {returns(T.untyped)}
+  def name(); end
+
+  sig {returns(T.untyped)}
+  def payload(); end
+
+  sig {returns(T.untyped)}
+  def root(); end
+
+  sig do
+    params(
+      graph: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def up(graph); end
+
+  sig {returns(T.untyped)}
+  def self.action_name(); end
+end
+
+class Bundler::Molinillo::DependencyGraph::DeleteEdge < Bundler::Molinillo::DependencyGraph::Action
+  sig {returns(T.untyped)}
+  def destination_name(); end
+
+  sig do
+    params(
+      graph: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def down(graph); end
+
+  sig do
+    params(
+      origin_name: T.untyped,
+      destination_name: T.untyped,
+      requirement: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(origin_name, destination_name, requirement); end
+
+  sig do
+    params(
+      graph: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def make_edge(graph); end
+
+  sig {returns(T.untyped)}
+  def origin_name(); end
+
+  sig {returns(T.untyped)}
+  def requirement(); end
+
+  sig do
+    params(
+      graph: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def up(graph); end
+
+  sig {returns(T.untyped)}
+  def self.action_name(); end
+end
+
+class Bundler::Molinillo::DependencyGraph::DetachVertexNamed < Bundler::Molinillo::DependencyGraph::Action
+  sig do
+    params(
+      graph: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def down(graph); end
+
+  sig do
+    params(
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(name); end
+
+  sig {returns(T.untyped)}
+  def name(); end
+
+  sig do
+    params(
+      graph: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def up(graph); end
+
+  sig {returns(T.untyped)}
+  def self.action_name(); end
+end
+
+class Bundler::Molinillo::DependencyGraph::Edge < Struct
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
+
+  sig {returns(T.untyped)}
+  def destination(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def destination=(_); end
+
+  sig {returns(T.untyped)}
+  def origin(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def origin=(_); end
+
+  sig {returns(T.untyped)}
+  def requirement(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def requirement=(_); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.[](*_); end
+
+  sig {returns(T.untyped)}
+  def self.members(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.new(*_); end
+end
+
+class Bundler::Molinillo::DependencyGraph::Log
+  extend T::Enumerable
+  sig do
+    params(
+      graph: T.untyped,
+      origin: T.untyped,
+      destination: T.untyped,
+      requirement: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def add_edge_no_circular(graph, origin, destination, requirement); end
+
+  sig do
+    params(
+      graph: T.untyped,
+      name: T.untyped,
+      payload: T.untyped,
+      root: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def add_vertex(graph, name, payload, root); end
+
+  sig do
+    params(
+      graph: T.untyped,
+      origin_name: T.untyped,
+      destination_name: T.untyped,
+      requirement: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def delete_edge(graph, origin_name, destination_name, requirement); end
+
+  sig do
+    params(
+      graph: T.untyped,
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def detach_vertex_named(graph, name); end
+
+  sig do
+    params(
+      blk: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def each(&blk); end
+
+  sig {returns(T.untyped)}
+  def initialize(); end
+
+  sig do
+    params(
+      graph: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def pop!(graph); end
+
+  sig {returns(T.untyped)}
+  def reverse_each(); end
+
+  sig do
+    params(
+      graph: T.untyped,
+      tag: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def rewind_to(graph, tag); end
+
+  sig do
+    params(
+      graph: T.untyped,
+      name: T.untyped,
+      payload: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def set_payload(graph, name, payload); end
+
+  sig do
+    params(
+      graph: T.untyped,
+      tag: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def tag(graph, tag); end
+end
+
+class Bundler::Molinillo::DependencyGraph::SetPayload < Bundler::Molinillo::DependencyGraph::Action
+  sig do
+    params(
+      graph: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def down(graph); end
+
+  sig do
+    params(
+      name: T.untyped,
+      payload: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(name, payload); end
+
+  sig {returns(T.untyped)}
+  def name(); end
+
+  sig {returns(T.untyped)}
+  def payload(); end
+
+  sig do
+    params(
+      graph: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def up(graph); end
+
+  sig {returns(T.untyped)}
+  def self.action_name(); end
+end
+
+class Bundler::Molinillo::DependencyGraph::Tag < Bundler::Molinillo::DependencyGraph::Action
+  sig do
+    params(
+      _graph: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def down(_graph); end
+
+  sig do
+    params(
+      tag: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(tag); end
+
+  sig {returns(T.untyped)}
+  def tag(); end
+
+  sig do
+    params(
+      _graph: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def up(_graph); end
+
+  sig {returns(T.untyped)}
+  def self.action_name(); end
+end
+
+class Bundler::Molinillo::DependencyGraph::Vertex
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def ==(other); end
+
+  sig do
+    params(
+      other: T.untyped,
+      visited: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def _path_to?(other, visited=T.unsafe(nil)); end
+
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def ancestor?(other); end
+
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def descendent?(other); end
+
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def eql?(other); end
+
+  sig {returns(T.untyped)}
+  def explicit_requirements(); end
+
+  sig {returns(T.untyped)}
+  def hash(); end
+
+  sig {returns(T.untyped)}
+  def incoming_edges(); end
+
+  sig do
+    params(
+      incoming_edges: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def incoming_edges=(incoming_edges); end
+
+  sig do
+    params(
+      name: T.untyped,
+      payload: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(name, payload); end
+
+  sig {returns(T.untyped)}
+  def inspect(); end
+
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def is_reachable_from?(other); end
+
+  sig {returns(T.untyped)}
+  def name(); end
+
+  sig do
+    params(
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def name=(name); end
+
+  sig {returns(T.untyped)}
+  def outgoing_edges(); end
+
+  sig do
+    params(
+      outgoing_edges: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def outgoing_edges=(outgoing_edges); end
+
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def path_to?(other); end
+
+  sig {returns(T.untyped)}
+  def payload(); end
+
+  sig do
+    params(
+      payload: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def payload=(payload); end
+
+  sig {returns(T.untyped)}
+  def predecessors(); end
+
+  sig {returns(T.untyped)}
+  def recursive_predecessors(); end
+
+  sig {returns(T.untyped)}
+  def recursive_successors(); end
+
+  sig {returns(T.untyped)}
+  def requirements(); end
+
+  sig {returns(T.untyped)}
+  def root(); end
+
+  sig do
+    params(
+      root: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def root=(root); end
+
+  sig {returns(T.untyped)}
+  def root?(); end
+
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def shallow_eql?(other); end
+
+  sig {returns(T.untyped)}
+  def successors(); end
+end
+
+class Bundler::Molinillo::DependencyState < Bundler::Molinillo::ResolutionState
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
+
+  sig {returns(T.untyped)}
+  def pop_possibility_state(); end
+end
+
+class Bundler::Molinillo::NoSuchDependencyError < Bundler::Molinillo::ResolverError
+  sig {returns(T.untyped)}
+  def dependency(); end
+
+  sig do
+    params(
+      dependency: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def dependency=(dependency); end
+
+  sig do
+    params(
+      dependency: T.untyped,
+      required_by: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(dependency, required_by=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def message(); end
+
+  sig {returns(T.untyped)}
+  def required_by(); end
+
+  sig do
+    params(
+      required_by: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def required_by=(required_by); end
+end
+
+class Bundler::Molinillo::PossibilityState < Bundler::Molinillo::ResolutionState
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
+end
+
+class Bundler::Molinillo::ResolutionState < Struct
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
+
+  sig {returns(T.untyped)}
+  def activated(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def activated=(_); end
+
+  sig {returns(T.untyped)}
+  def conflicts(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def conflicts=(_); end
+
+  sig {returns(T.untyped)}
+  def depth(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def depth=(_); end
+
+  sig {returns(T.untyped)}
+  def name(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def name=(_); end
+
+  sig {returns(T.untyped)}
+  def possibilities(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def possibilities=(_); end
+
+  sig {returns(T.untyped)}
+  def requirement(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def requirement=(_); end
+
+  sig {returns(T.untyped)}
+  def requirements(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def requirements=(_); end
+
+  sig {returns(T.untyped)}
+  def unused_unwind_options(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def unused_unwind_options=(_); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.[](*_); end
+
+  sig {returns(T.untyped)}
+  def self.empty(); end
+
+  sig {returns(T.untyped)}
+  def self.members(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.new(*_); end
+end
+
+class Bundler::Molinillo::Resolver
+  sig do
+    params(
+      specification_provider: T.untyped,
+      resolver_ui: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(specification_provider, resolver_ui); end
+
+  sig do
+    params(
+      requested: T.untyped,
+      base: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def resolve(requested, base=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def resolver_ui(); end
+
+  sig {returns(T.untyped)}
+  def specification_provider(); end
+end
+
+class Bundler::Molinillo::Resolver::Resolution
+  include ::Bundler::Molinillo::Delegates::SpecificationProvider
+  include ::Bundler::Molinillo::Delegates::ResolutionState
+  sig {returns(T.untyped)}
+  def base(); end
+
+  sig do
+    params(
+      specification_provider: T.untyped,
+      resolver_ui: T.untyped,
+      requested: T.untyped,
+      base: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(specification_provider, resolver_ui, requested, base); end
+
+  sig do
+    params(
+      iteration_rate: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def iteration_rate=(iteration_rate); end
+
+  sig {returns(T.untyped)}
+  def original_requested(); end
+
+  sig {returns(T.untyped)}
+  def resolve(); end
+
+  sig {returns(T.untyped)}
+  def resolver_ui(); end
+
+  sig {returns(T.untyped)}
+  def specification_provider(); end
+
+  sig do
+    params(
+      started_at: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def started_at=(started_at); end
+
+  sig do
+    params(
+      states: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def states=(states); end
+end
+
+class Bundler::Molinillo::Resolver::Resolution::Conflict < Struct
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
+
+  sig {returns(T.untyped)}
+  def activated_by_name(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def activated_by_name=(_); end
+
+  sig {returns(T.untyped)}
+  def existing(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def existing=(_); end
+
+  sig {returns(T.untyped)}
+  def locked_requirement(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def locked_requirement=(_); end
+
+  sig {returns(T.untyped)}
+  def possibility(); end
+
+  sig {returns(T.untyped)}
+  def possibility_set(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def possibility_set=(_); end
+
+  sig {returns(T.untyped)}
+  def requirement(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def requirement=(_); end
+
+  sig {returns(T.untyped)}
+  def requirement_trees(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def requirement_trees=(_); end
+
+  sig {returns(T.untyped)}
+  def requirements(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def requirements=(_); end
+
+  sig {returns(T.untyped)}
+  def underlying_error(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def underlying_error=(_); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.[](*_); end
+
+  sig {returns(T.untyped)}
+  def self.members(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.new(*_); end
+end
+
+class Bundler::Molinillo::Resolver::Resolution::PossibilitySet < Struct
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
+
+  sig {returns(T.untyped)}
+  def dependencies(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def dependencies=(_); end
+
+  sig {returns(T.untyped)}
+  def latest_version(); end
+
+  sig {returns(T.untyped)}
+  def possibilities(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def possibilities=(_); end
+
+  sig {returns(T.untyped)}
+  def to_s(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.[](*_); end
+
+  sig {returns(T.untyped)}
+  def self.members(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.new(*_); end
+end
+
+class Bundler::Molinillo::Resolver::Resolution::UnwindDetails < Struct
+  include ::Comparable
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
+
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def <=>(other); end
+
+  sig {returns(T.untyped)}
+  def all_requirements(); end
+
+  sig {returns(T.untyped)}
+  def conflicting_requirements(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def conflicting_requirements=(_); end
+
+  sig {returns(T.untyped)}
+  def requirement_tree(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def requirement_tree=(_); end
+
+  sig {returns(T.untyped)}
+  def requirement_trees(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def requirement_trees=(_); end
+
+  sig {returns(T.untyped)}
+  def requirements_unwound_to_instead(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def requirements_unwound_to_instead=(_); end
+
+  sig {returns(T.untyped)}
+  def reversed_requirement_tree_index(); end
+
+  sig {returns(T.untyped)}
+  def state_index(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def state_index=(_); end
+
+  sig {returns(T.untyped)}
+  def state_requirement(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def state_requirement=(_); end
+
+  sig {returns(T.untyped)}
+  def sub_dependencies_to_avoid(); end
+
+  sig {returns(T.untyped)}
+  def unwinding_to_primary_requirement?(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.[](*_); end
+
+  sig {returns(T.untyped)}
+  def self.members(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.new(*_); end
+end
+
+class Bundler::Molinillo::ResolverError < StandardError
+end
+
+module Bundler::Molinillo::SpecificationProvider
+  sig do
+    params(
+      dependency: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def allow_missing?(dependency); end
+
+  sig do
+    params(
+      specification: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def dependencies_for(specification); end
+
+  sig do
+    params(
+      dependency: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def name_for(dependency); end
+
+  sig {returns(T.untyped)}
+  def name_for_explicit_dependency_source(); end
+
+  sig {returns(T.untyped)}
+  def name_for_locking_dependency_source(); end
+
+  sig do
+    params(
+      requirement: T.untyped,
+      activated: T.untyped,
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def requirement_satisfied_by?(requirement, activated, spec); end
+
+  sig do
+    params(
+      dependency: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def search_for(dependency); end
+
+  sig do
+    params(
+      dependencies: T.untyped,
+      activated: T.untyped,
+      conflicts: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def sort_dependencies(dependencies, activated, conflicts); end
+end
+
+module Bundler::Molinillo::UI
+  sig {returns(T.untyped)}
+  def after_resolution(); end
+
+  sig {returns(T.untyped)}
+  def before_resolution(); end
+
+  sig do
+    params(
+      depth: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def debug(depth=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def debug?(); end
+
+  sig {returns(T.untyped)}
+  def indicate_progress(); end
+
+  sig {returns(T.untyped)}
+  def output(); end
+
+  sig {returns(T.untyped)}
+  def progress_rate(); end
+end
+
+class Bundler::Molinillo::VersionConflict < Bundler::Molinillo::ResolverError
+  include ::Bundler::Molinillo::Delegates::SpecificationProvider
+  sig {returns(T.untyped)}
+  def conflicts(); end
+
+  sig do
+    params(
+      conflicts: T.untyped,
+      specification_provider: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(conflicts, specification_provider); end
+
+  sig do
+    params(
+      opts: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def message_with_trees(opts=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def specification_provider(); end
+end
+
+class Bundler::NoSpaceOnDeviceError < Bundler::PermissionError
+  sig {returns(T.untyped)}
+  def message(); end
+
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::OperationNotSupportedError < Bundler::PermissionError
+  sig {returns(T.untyped)}
+  def message(); end
+
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::PathError < Bundler::BundlerError
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::PermissionError < Bundler::BundlerError
+  sig {returns(T.untyped)}
+  def action(); end
+
+  sig do
+    params(
+      path: T.untyped,
+      permission_type: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(path, permission_type=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def message(); end
+
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+module Bundler::Plugin
+  PLUGIN_FILE_NAME = ::T.let(nil, T.untyped)
+
+  sig do
+    params(
+      command: T.untyped,
+      cls: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.add_command(command, cls); end
+
+  sig do
+    params(
+      event: T.untyped,
+      block: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.add_hook(event, &block); end
+
+  sig do
+    params(
+      source: T.untyped,
+      cls: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.add_source(source, cls); end
+
+  sig {returns(T.untyped)}
+  def self.cache(); end
+
+  sig do
+    params(
+      command: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.command?(command); end
+
+  sig do
+    params(
+      command: T.untyped,
+      args: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.exec_command(command, args); end
+
+  sig do
+    params(
+      gemfile: T.untyped,
+      inline: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.gemfile_install(gemfile=T.unsafe(nil), &inline); end
+
+  sig {returns(T.untyped)}
+  def self.global_root(); end
+
+  sig do
+    params(
+      event: T.untyped,
+      args: T.untyped,
+      arg_blk: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.hook(event, *args, &arg_blk); end
+
+  sig {returns(T.untyped)}
+  def self.index(); end
+
+  sig do
+    params(
+      names: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.install(names, options); end
+
+  sig do
+    params(
+      plugin: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.installed?(plugin); end
+
+  sig {returns(T.untyped)}
+  def self.local_root(); end
+
+  sig {returns(T.untyped)}
+  def self.reset!(); end
+
+  sig {returns(T.untyped)}
+  def self.root(); end
+
+  sig do
+    params(
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.source(name); end
+
+  sig do
+    params(
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.source?(name); end
+
+  sig do
+    params(
+      locked_opts: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.source_from_lock(locked_opts); end
+end
+
+class Bundler::Plugin::API
+  sig {returns(T.untyped)}
+  def cache_dir(); end
+
+  sig do
+    params(
+      name: T.untyped,
+      args: T.untyped,
+      blk: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def method_missing(name, *args, &blk); end
+
+  sig do
+    params(
+      names: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def tmp(*names); end
+
+  sig do
+    params(
+      command: T.untyped,
+      cls: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.command(command, cls=T.unsafe(nil)); end
+
+  sig do
+    params(
+      event: T.untyped,
+      block: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.hook(event, &block); end
+
+  sig do
+    params(
+      source: T.untyped,
+      cls: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.source(source, cls=T.unsafe(nil)); end
+end
+
+class Bundler::Plugin::DSL
+  sig do
+    params(
+      name: T.untyped,
+      args: T.untyped
+    )
+    .returns(T.untyped)
+  end
+  def _gem(name, *args); end
+
+  sig { returns(T.untyped) }
+  def inferred_plugins(); end
+
+  sig do
+    params(
+      name: T.untyped,
+      args: T.untyped
+    )
+    .returns(T.untyped)
+  end
+  def plugin(name, *args); end
+end
+
+module Bundler::Plugin::Events
+  def self.defined_event?(event); end
+end
+
+class Bundler::Plugin::Index
+  def command_plugin(command); end
+
+  def commands(); end
+
+  def global_index_file(); end
+
+  def hook_plugins(event); end
+
+  def index_file(); end
+
+  def installed?(name); end
+
+  def load_paths(name); end
+
+  def local_index_file(); end
+
+  def plugin_path(name); end
+
+  def register_plugin(name, path, load_paths, commands, sources, hooks); end
+
+  def source?(source); end
+
+  def source_plugin(name); end
+end
+
+class Bundler::Plugin::MalformattedPlugin < Bundler::PluginError
+end
+
+class Bundler::Plugin::UndefinedCommandError < Bundler::PluginError
+end
+
+class Bundler::Plugin::UnknownSourceError < Bundler::PluginError
+end
+
+class Bundler::Plugin::DSL::PluginGemfileError < Bundler::PluginError
+end
+
+class Bundler::PluginError < Bundler::BundlerError
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::ProductionError < Bundler::BundlerError
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::RemoteSpecification
+  include ::Comparable
+  include ::Bundler::MatchPlatform
+  include ::Bundler::GemHelpers
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def <=>(other); end
+
+  sig do
+    params(
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def __swap__(spec); end
+
+  sig {returns(T.untyped)}
+  def dependencies(); end
+
+  sig do
+    params(
+      dependencies: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def dependencies=(dependencies); end
+
+  sig {returns(T.untyped)}
+  def fetch_platform(); end
+
+  sig {returns(T.untyped)}
+  def full_name(); end
+
+  sig {returns(T.untyped)}
+  def git_version(); end
+
+  sig do
+    params(
+      name: T.untyped,
+      version: T.untyped,
+      platform: T.untyped,
+      spec_fetcher: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(name, version, platform, spec_fetcher); end
+
+  sig {returns(T.untyped)}
+  def name(); end
+
+  sig {returns(T.untyped)}
+  def platform(); end
+
+  sig {returns(T.untyped)}
+  def remote(); end
+
+  sig do
+    params(
+      remote: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def remote=(remote); end
+
+  sig do
+    params(
+      method: T.untyped,
+      include_all: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def respond_to?(method, include_all=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def sort_obj(); end
+
+  sig {returns(T.untyped)}
+  def source(); end
+
+  sig do
+    params(
+      source: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def source=(source); end
+
+  sig {returns(T.untyped)}
+  def to_s(); end
+
+  sig {returns(T.untyped)}
+  def version(); end
+end
+
+class Bundler::Resolver
+  include ::Bundler::Molinillo::SpecificationProvider
+  include ::Bundler::Molinillo::UI
+  sig {returns(T.untyped)}
+  def after_resolution(); end
+
+  sig {returns(T.untyped)}
+  def before_resolution(); end
+
+  sig do
+    params(
+      depth: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def debug(depth=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def debug?(); end
+
+  sig do
+    params(
+      specification: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def dependencies_for(specification); end
+
+  sig do
+    params(
+      dependency: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def index_for(dependency); end
+
+  sig {returns(T.untyped)}
+  def indicate_progress(); end
+
+  sig do
+    params(
+      index: T.untyped,
+      source_requirements: T.untyped,
+      base: T.untyped,
+      gem_version_promoter: T.untyped,
+      additional_base_requirements: T.untyped,
+      platforms: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(index, source_requirements, base, gem_version_promoter, additional_base_requirements, platforms); end
+
+  sig do
+    params(
+      dependency: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def name_for(dependency); end
+
+  sig {returns(T.untyped)}
+  def name_for_explicit_dependency_source(); end
+
+  sig {returns(T.untyped)}
+  def name_for_locking_dependency_source(); end
+
+  sig do
+    params(
+      vertex: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def relevant_sources_for_vertex(vertex); end
+
+  sig do
+    params(
+      requirement: T.untyped,
+      activated: T.untyped,
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def requirement_satisfied_by?(requirement, activated, spec); end
+
+  sig do
+    params(
+      dependency: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def search_for(dependency); end
+
+  sig do
+    params(
+      dependencies: T.untyped,
+      activated: T.untyped,
+      conflicts: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def sort_dependencies(dependencies, activated, conflicts); end
+
+  sig do
+    params(
+      requirements: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def start(requirements); end
+
+  sig do
+    params(
+      platform: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.platform_sort_key(platform); end
+
+  sig do
+    params(
+      requirements: T.untyped,
+      index: T.untyped,
+      source_requirements: T.untyped,
+      base: T.untyped,
+      gem_version_promoter: T.untyped,
+      additional_base_requirements: T.untyped,
+      platforms: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.resolve(requirements, index, source_requirements=T.unsafe(nil), base=T.unsafe(nil), gem_version_promoter=T.unsafe(nil), additional_base_requirements=T.unsafe(nil), platforms=T.unsafe(nil)); end
+
+  sig do
+    params(
+      platforms: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.sort_platforms(platforms); end
+end
+
+class Bundler::Resolver::SpecGroup
+  include ::Bundler::GemHelpers
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def ==(other); end
+
+  sig do
+    params(
+      platform: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def activate_platform!(platform); end
+
+  sig {returns(T.untyped)}
+  def dependencies_for_activated_platforms(); end
+
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def eql?(other); end
+
+  sig do
+    params(
+      platform: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def for?(platform); end
+
+  sig {returns(T.untyped)}
+  def hash(); end
+
+  sig {returns(T.untyped)}
+  def ignores_bundler_dependencies(); end
+
+  sig do
+    params(
+      ignores_bundler_dependencies: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def ignores_bundler_dependencies=(ignores_bundler_dependencies); end
+
+  sig do
+    params(
+      all_specs: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(all_specs); end
+
+  sig {returns(T.untyped)}
+  def name(); end
+
+  sig do
+    params(
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def name=(name); end
+
+  sig {returns(T.untyped)}
+  def source(); end
+
+  sig do
+    params(
+      source: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def source=(source); end
+
+  sig {returns(T.untyped)}
+  def to_s(); end
+
+  sig {returns(T.untyped)}
+  def to_specs(); end
+
+  sig {returns(T.untyped)}
+  def version(); end
+
+  sig do
+    params(
+      version: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def version=(version); end
+end
+
+module Bundler::RubyDsl
+  sig do
+    params(
+      ruby_version: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def ruby(*ruby_version); end
+end
+
+class Bundler::RubyVersion
+  PATTERN = ::T.let(nil, T.untyped)
+
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def ==(other); end
+
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def diff(other); end
+
+  sig {returns(T.untyped)}
+  def engine(); end
+
+  sig {returns(T.untyped)}
+  def engine_gem_version(); end
+
+  sig {returns(T.untyped)}
+  def engine_versions(); end
+
+  sig {returns(T.untyped)}
+  def exact?(); end
+
+  sig {returns(T.untyped)}
+  def gem_version(); end
+
+  sig {returns(T.untyped)}
+  def host(); end
+
+  sig do
+    params(
+      versions: T.untyped,
+      patchlevel: T.untyped,
+      engine: T.untyped,
+      engine_version: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(versions, patchlevel, engine, engine_version); end
+
+  sig {returns(T.untyped)}
+  def patchlevel(); end
+
+  sig {returns(T.untyped)}
+  def single_version_string(); end
+
+  sig {returns(T.untyped)}
+  def to_gem_version_with_patchlevel(); end
+
+  sig do
+    params(
+      versions: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def to_s(versions=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def versions(); end
+
+  sig do
+    params(
+      versions: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def versions_string(versions); end
+
+  sig do
+    params(
+      string: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.from_string(string); end
+
+  sig {returns(T.untyped)}
+  def self.system(); end
+end
+
+class Bundler::RubyVersionMismatch < Bundler::BundlerError
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::RubygemsIntegration
+  EXT_LOCK = ::T.let(nil, T.untyped)
+
+  sig {returns(T.untyped)}
+  def backport_base_dir(); end
+
+  sig {returns(T.untyped)}
+  def backport_cache_file(); end
+
+  sig {returns(T.untyped)}
+  def backport_segment_generation(); end
+
+  sig {returns(T.untyped)}
+  def backport_spec_file(); end
+
+  sig {returns(T.untyped)}
+  def backport_yaml_initialize(); end
+
+  sig do
+    params(
+      gem: T.untyped,
+      bin: T.untyped,
+      ver: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def bin_path(gem, bin, ver); end
+
+  sig {returns(T.untyped)}
+  def binstubs_call_gem?(); end
+
+  sig do
+    params(
+      spec: T.untyped,
+      skip_validation: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def build(spec, skip_validation=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def build_args(); end
+
+  sig do
+    params(
+      args: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def build_args=(args); end
+
+  sig do
+    params(
+      gem_dir: T.untyped,
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def build_gem(gem_dir, spec); end
+
+  sig {returns(T.untyped)}
+  def clear_paths(); end
+
+  sig {returns(T.untyped)}
+  def config_map(); end
+
+  sig {returns(T.untyped)}
+  def configuration(); end
+
+  sig do
+    params(
+      spec: T.untyped,
+      uri: T.untyped,
+      path: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def download_gem(spec, uri, path); end
+
+  sig {returns(T.untyped)}
+  def ext_lock(); end
+
+  sig do
+    params(
+      remote: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def fetch_all_remote_specs(remote); end
+
+  sig {returns(T.untyped)}
+  def fetch_prerelease_specs(); end
+
+  sig do
+    params(
+      all: T.untyped,
+      pre: T.untyped,
+      blk: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def fetch_specs(all, pre, &blk); end
+
+  sig {returns(T.untyped)}
+  def gem_bindir(); end
+
+  sig {returns(T.untyped)}
+  def gem_cache(); end
+
+  sig {returns(T.untyped)}
+  def gem_dir(); end
+
+  sig do
+    params(
+      path: T.untyped,
+      policy: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def gem_from_path(path, policy=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def gem_path(); end
+
+  sig do
+    params(
+      obj: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def inflate(obj); end
+
+  sig {returns(T.untyped)}
+  def initialize(); end
+
+  sig do
+    params(
+      args: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def install_with_build_args(args); end
+
+  sig {returns(T.untyped)}
+  def load_path_insert_index(); end
+
+  sig do
+    params(
+      files: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def load_plugin_files(files); end
+
+  sig {returns(T.untyped)}
+  def load_plugins(); end
+
+  sig {returns(T.untyped)}
+  def loaded_gem_paths(); end
+
+  sig do
+    params(
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def loaded_specs(name); end
+
+  sig do
+    params(
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def mark_loaded(spec); end
+
+  sig {returns(T.untyped)}
+  def marshal_spec_dir(); end
+
+  sig do
+    params(
+      klass: T.untyped,
+      method: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def method_visibility(klass, method); end
+
+  sig do
+    params(
+      obj: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def path(obj); end
+
+  sig {returns(T.untyped)}
+  def path_separator(); end
+
+  sig {returns(T.untyped)}
+  def platforms(); end
+
+  sig {returns(T.untyped)}
+  def post_reset_hooks(); end
+
+  sig {returns(T.untyped)}
+  def preserve_paths(); end
+
+  sig do
+    params(
+      req_str: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def provides?(req_str); end
+
+  sig do
+    params(
+      path: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def read_binary(path); end
+
+  sig do
+    params(
+      klass: T.untyped,
+      method: T.untyped,
+      unbound_method: T.untyped,
+      block: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def redefine_method(klass, method, unbound_method=T.unsafe(nil), &block); end
+
+  sig do
+    params(
+      specs: T.untyped,
+      specs_by_name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def replace_bin_path(specs, specs_by_name); end
+
+  sig do
+    params(
+      specs: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def replace_entrypoints(specs); end
+
+  sig do
+    params(
+      specs: T.untyped,
+      specs_by_name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def replace_gem(specs, specs_by_name); end
+
+  sig {returns(T.untyped)}
+  def replace_refresh(); end
+
+  sig {returns(T.untyped)}
+  def repository_subdirectories(); end
+
+  sig {returns(T.untyped)}
+  def reset(); end
+
+  sig {returns(T.untyped)}
+  def reverse_rubygems_kernel_mixin(); end
+
+  sig {returns(T.untyped)}
+  def ruby_engine(); end
+
+  sig {returns(T.untyped)}
+  def security_policies(); end
+
+  sig {returns(T.untyped)}
+  def security_policy_keys(); end
+
+  sig do
+    params(
+      spec: T.untyped,
+      installed_by_version: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def set_installed_by_version(spec, installed_by_version=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def sources(); end
+
+  sig do
+    params(
+      val: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def sources=(val); end
+
+  sig {returns(T.untyped)}
+  def spec_cache_dirs(); end
+
+  sig do
+    params(
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def spec_default_gem?(spec); end
+
+  sig do
+    params(
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def spec_extension_dir(spec); end
+
+  sig do
+    params(
+      path: T.untyped,
+      policy: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def spec_from_gem(path, policy=T.unsafe(nil)); end
+
+  sig do
+    params(
+      spec: T.untyped,
+      glob: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def spec_matches_for_glob(spec, glob); end
+
+  sig do
+    params(
+      spec: T.untyped,
+      default: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def spec_missing_extensions?(spec, default=T.unsafe(nil)); end
+
+  sig do
+    params(
+      stub: T.untyped,
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def stub_set_spec(stub, spec); end
+
+  sig do
+    params(
+      specs: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def stub_source_index(specs); end
+
+  sig {returns(T.untyped)}
+  def stubs_provide_full_functionality?(); end
+
+  sig {returns(T.untyped)}
+  def suffix_pattern(); end
+
+  sig do
+    params(
+      obj: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def ui=(obj); end
+
+  sig {returns(T.untyped)}
+  def undo_replacements(); end
+
+  sig {returns(T.untyped)}
+  def user_home(); end
+
+  sig do
+    params(
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def validate(spec); end
+
+  sig {returns(T.untyped)}
+  def version(); end
+
+  sig do
+    params(
+      args: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def with_build_args(args); end
+
+  sig do
+    params(
+      req_str: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.provides?(req_str); end
+
+  sig {returns(T.untyped)}
+  def self.version(); end
+end
+
+class Bundler::RubygemsIntegration::AlmostModern < Bundler::RubygemsIntegration::Modern
+  sig {returns(T.untyped)}
+  def preserve_paths(); end
+end
+
+class Bundler::RubygemsIntegration::Ancient < Bundler::RubygemsIntegration::Legacy
+  sig {returns(T.untyped)}
+  def initialize(); end
+end
+
+class Bundler::RubygemsIntegration::Future < Bundler::RubygemsIntegration
+  sig {returns(T.untyped)}
+  def all_specs(); end
+
+  sig do
+    params(
+      spec: T.untyped,
+      skip_validation: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def build(spec, skip_validation=T.unsafe(nil)); end
+
+  sig do
+    params(
+      spec: T.untyped,
+      uri: T.untyped,
+      path: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def download_gem(spec, uri, path); end
+
+  sig do
+    params(
+      remote: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def fetch_all_remote_specs(remote); end
+
+  sig do
+    params(
+      source: T.untyped,
+      remote: T.untyped,
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def fetch_specs(source, remote, name); end
+
+  sig do
+    params(
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def find_name(name); end
+
+  sig do
+    params(
+      path: T.untyped,
+      policy: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def gem_from_path(path, policy=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def gem_remote_fetcher(); end
+
+  sig do
+    params(
+      args: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def install_with_build_args(args); end
+
+  sig {returns(T.untyped)}
+  def path_separator(); end
+
+  sig {returns(T.untyped)}
+  def repository_subdirectories(); end
+
+  sig do
+    params(
+      specs: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def stub_rubygems(specs); end
+end
+
+class Bundler::RubygemsIntegration::Legacy < Bundler::RubygemsIntegration
+  sig {returns(T.untyped)}
+  def all_specs(); end
+
+  sig do
+    params(
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def find_name(name); end
+
+  sig {returns(T.untyped)}
+  def initialize(); end
+
+  sig {returns(T.untyped)}
+  def post_reset_hooks(); end
+
+  sig {returns(T.untyped)}
+  def reset(); end
+
+  sig do
+    params(
+      specs: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def stub_rubygems(specs); end
+
+  sig do
+    params(
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def validate(spec); end
+end
+
+class Bundler::RubygemsIntegration::Modern < Bundler::RubygemsIntegration
+  sig {returns(T.untyped)}
+  def all_specs(); end
+
+  sig do
+    params(
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def find_name(name); end
+
+  sig do
+    params(
+      specs: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def stub_rubygems(specs); end
+end
+
+class Bundler::RubygemsIntegration::MoreFuture < Bundler::RubygemsIntegration::Future
+  sig {returns(T.untyped)}
+  def all_specs(); end
+
+  sig {returns(T.untyped)}
+  def backport_ext_builder_monitor(); end
+
+  sig {returns(T.untyped)}
+  def binstubs_call_gem?(); end
+
+  sig do
+    params(
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def find_name(name); end
+
+  sig {returns(T.untyped)}
+  def initialize(); end
+
+  sig {returns(T.untyped)}
+  def stubs_provide_full_functionality?(); end
+
+  sig do
+    params(
+      gemfile: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def use_gemdeps(gemfile); end
+end
+
+class Bundler::RubygemsIntegration::MoreModern < Bundler::RubygemsIntegration::Modern
+  sig do
+    params(
+      spec: T.untyped,
+      skip_validation: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def build(spec, skip_validation=T.unsafe(nil)); end
+end
+
+class Bundler::RubygemsIntegration::Transitional < Bundler::RubygemsIntegration::Legacy
+  sig do
+    params(
+      specs: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def stub_rubygems(specs); end
+
+  sig do
+    params(
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def validate(spec); end
+end
+
+class Bundler::Runtime
+  include ::Bundler::SharedHelpers
+  REQUIRE_ERRORS = ::T.let(nil, T.untyped)
+
+  sig do
+    params(
+      custom_path: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def cache(custom_path=T.unsafe(nil)); end
+
+  sig do
+    params(
+      dry_run: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def clean(dry_run=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def current_dependencies(); end
+
+  sig {returns(T.untyped)}
+  def dependencies(); end
+
+  sig {returns(T.untyped)}
+  def gems(); end
+
+  sig do
+    params(
+      root: T.untyped,
+      definition: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(root, definition); end
+
+  sig do
+    params(
+      opts: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def lock(opts=T.unsafe(nil)); end
+
+  sig do
+    params(
+      cache_path: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def prune_cache(cache_path); end
+
+  sig {returns(T.untyped)}
+  def requested_specs(); end
+
+  sig do
+    params(
+      groups: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def require(*groups); end
+
+  sig {returns(T.untyped)}
+  def requires(); end
+
+  sig do
+    params(
+      groups: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def setup(*groups); end
+
+  sig {returns(T.untyped)}
+  def specs(); end
+end
+
+class Bundler::SecurityError < Bundler::BundlerError
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::Settings
+  ARRAY_KEYS = ::T.let(nil, T.untyped)
+  BOOL_KEYS = ::T.let(nil, T.untyped)
+  CONFIG_REGEX = ::T.let(nil, T.untyped)
+  DEFAULT_CONFIG = ::T.let(nil, T.untyped)
+  NORMALIZE_URI_OPTIONS_PATTERN = ::T.let(nil, T.untyped)
+  NUMBER_KEYS = ::T.let(nil, T.untyped)
+  PER_URI_OPTIONS = ::T.let(nil, T.untyped)
+
+  sig do
+    params(
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def [](name); end
+
+  sig {returns(T.untyped)}
+  def all(); end
+
+  sig {returns(T.untyped)}
+  def allow_sudo?(); end
+
+  sig {returns(T.untyped)}
+  def app_cache_path(); end
+
+  sig do
+    params(
+      uri: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def credentials_for(uri); end
+
+  sig {returns(T.untyped)}
+  def gem_mirrors(); end
+
+  sig {returns(T.untyped)}
+  def ignore_config?(); end
+
+  sig do
+    params(
+      root: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(root=T.unsafe(nil)); end
+
+  sig do
+    params(
+      key: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def key_for(key); end
+
+  sig {returns(T.untyped)}
+  def local_overrides(); end
+
+  sig do
+    params(
+      key: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def locations(key); end
+
+  sig do
+    params(
+      uri: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def mirror_for(uri); end
+
+  sig {returns(T.untyped)}
+  def path(); end
+
+  sig do
+    params(
+      exposed_key: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def pretty_values_for(exposed_key); end
+
+  sig do
+    params(
+      key: T.untyped,
+      value: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def set_command_option(key, value); end
+
+  sig do
+    params(
+      key: T.untyped,
+      value: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def set_command_option_if_given(key, value); end
+
+  sig do
+    params(
+      key: T.untyped,
+      value: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def set_global(key, value); end
+
+  sig do
+    params(
+      key: T.untyped,
+      value: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def set_local(key, value); end
+
+  sig do
+    params(
+      update: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def temporary(update); end
+
+  sig {returns(T.untyped)}
+  def validate!(); end
+
+  sig do
+    params(
+      uri: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.normalize_uri(uri); end
+end
+
+class Bundler::Settings::Path < Struct
+  extend T::Generic
+  Elem = type_member(fixed: T.untyped)
+
+  sig {returns(T.untyped)}
+  def append_ruby_scope(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def append_ruby_scope=(_); end
+
+  sig {returns(T.untyped)}
+  def base_path(); end
+
+  sig {returns(T.untyped)}
+  def base_path_relative_to_pwd(); end
+
+  sig {returns(T.untyped)}
+  def default_install_uses_path(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def default_install_uses_path=(_); end
+
+  sig {returns(T.untyped)}
+  def explicit_path(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def explicit_path=(_); end
+
+  sig {returns(T.untyped)}
+  def path(); end
+
+  sig {returns(T.untyped)}
+  def system_path(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def system_path=(_); end
+
+  sig {returns(T.untyped)}
+  def use_system_gems?(); end
+
+  sig {returns(T.untyped)}
+  def validate!(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.[](*_); end
+
+  sig {returns(T.untyped)}
+  def self.members(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.new(*_); end
+end
+
+module Bundler::SharedHelpers
+  extend ::Bundler::SharedHelpers
+  sig do
+    params(
+      dir: T.untyped,
+      blk: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def chdir(dir, &blk); end
+
+  sig do
+    params(
+      constant_name: T.untyped,
+      namespace: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def const_get_safely(constant_name, namespace); end
+
+  sig {returns(T.untyped)}
+  def default_bundle_dir(); end
+
+  sig {returns(T.untyped)}
+  def default_gemfile(); end
+
+  sig {returns(T.untyped)}
+  def default_lockfile(); end
+
+  sig do
+    params(
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def digest(name); end
+
+  sig do
+    params(
+      spec: T.untyped,
+      old_deps: T.untyped,
+      new_deps: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def ensure_same_dependencies(spec, old_deps, new_deps); end
+
+  sig do
+    params(
+      path: T.untyped,
+      action: T.untyped,
+      block: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def filesystem_access(path, action=T.unsafe(nil), &block); end
+
+  sig {returns(T.untyped)}
+  def in_bundle?(); end
+
+  sig do
+    params(
+      major_version: T.untyped,
+      message: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def major_deprecation(major_version, message); end
+
+  sig {returns(T.untyped)}
+  def md5_available?(); end
+
+  sig do
+    params(
+      dep: T.untyped,
+      print_source: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def pretty_dependency(dep, print_source=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def print_major_deprecations!(); end
+
+  sig {returns(T.untyped)}
+  def pwd(); end
+
+  sig {returns(T.untyped)}
+  def root(); end
+
+  sig {returns(T.untyped)}
+  def set_bundle_environment(); end
+
+  sig do
+    params(
+      key: T.untyped,
+      value: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def set_env(key, value); end
+
+  sig do
+    params(
+      signal: T.untyped,
+      override: T.untyped,
+      block: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def trap(signal, override=T.unsafe(nil), &block); end
+
+  sig do
+    params(
+      block: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def with_clean_git_env(&block); end
+
+  sig do
+    params(
+      gemfile_path: T.untyped,
+      contents: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def write_to_gemfile(gemfile_path, contents); end
+end
+
+class Bundler::Source
+  sig do
+    params(
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def can_lock?(spec); end
+
+  sig {returns(T.untyped)}
+  def dependency_names(); end
+
+  sig do
+    params(
+      dependency_names: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def dependency_names=(dependency_names); end
+
+  sig {returns(T.untyped)}
+  def dependency_names_to_double_check(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def double_check_for(*_); end
+
+  sig do
+    params(
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def extension_cache_path(spec); end
+
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def include?(other); end
+
+  sig {returns(T.untyped)}
+  def inspect(); end
+
+  sig {returns(T.untyped)}
+  def path?(); end
+
+  sig {returns(T.untyped)}
+  def unmet_deps(); end
+
+  sig do
+    params(
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def version_message(spec); end
+end
+
+class Bundler::Source::Gemspec < Bundler::Source::Path
+  sig {returns(T.untyped)}
+  def as_path_source(); end
+
+  sig {returns(T.untyped)}
+  def gemspec(); end
+
+  sig do
+    params(
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(options); end
+end
+
+class Bundler::Source::Git < Bundler::Source::Path
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def ==(other); end
+
+  sig {returns(T.untyped)}
+  def allow_git_ops?(); end
+
+  sig {returns(T.untyped)}
+  def app_cache_dirname(); end
+
+  sig {returns(T.untyped)}
+  def branch(); end
+
+  sig do
+    params(
+      spec: T.untyped,
+      custom_path: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def cache(spec, custom_path=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def cache_path(); end
+
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def eql?(other); end
+
+  sig {returns(T.untyped)}
+  def extension_dir_name(); end
+
+  sig {returns(T.untyped)}
+  def hash(); end
+
+  sig do
+    params(
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(options); end
+
+  sig do
+    params(
+      spec: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def install(spec, options=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def install_path(); end
+
+  sig {returns(T.untyped)}
+  def load_spec_files(); end
+
+  sig do
+    params(
+      path: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def local_override!(path); end
+
+  sig {returns(T.untyped)}
+  def name(); end
+
+  sig {returns(T.untyped)}
+  def options(); end
+
+  sig {returns(T.untyped)}
+  def path(); end
+
+  sig {returns(T.untyped)}
+  def ref(); end
+
+  sig {returns(T.untyped)}
+  def revision(); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def specs(*_); end
+
+  sig {returns(T.untyped)}
+  def submodules(); end
+
+  sig {returns(T.untyped)}
+  def to_lock(); end
+
+  sig {returns(T.untyped)}
+  def to_s(); end
+
+  sig {returns(T.untyped)}
+  def unlock!(); end
+
+  sig {returns(T.untyped)}
+  def uri(); end
+
+  sig do
+    params(
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.from_lock(options); end
+end
+
+class Bundler::Source::Git::GitCommandError < Bundler::GitError
+  sig do
+    params(
+      command: T.untyped,
+      path: T.untyped,
+      extra_info: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(command, path=T.unsafe(nil), extra_info=T.unsafe(nil)); end
+end
+
+class Bundler::Source::Git::GitNotAllowedError < Bundler::GitError
+  sig do
+    params(
+      command: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(command); end
+end
+
+class Bundler::Source::Git::GitNotInstalledError < Bundler::GitError
+  sig {returns(T.untyped)}
+  def initialize(); end
+end
+
+class Bundler::Source::Git::GitProxy
+  sig {returns(T.untyped)}
+  def branch(); end
+
+  sig {returns(T.untyped)}
+  def checkout(); end
+
+  sig do
+    params(
+      commit: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def contains?(commit); end
+
+  sig do
+    params(
+      destination: T.untyped,
+      submodules: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def copy_to(destination, submodules=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def full_version(); end
+
+  sig do
+    params(
+      path: T.untyped,
+      uri: T.untyped,
+      ref: T.untyped,
+      revision: T.untyped,
+      git: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(path, uri, ref, revision=T.unsafe(nil), git=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def path(); end
+
+  sig do
+    params(
+      path: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def path=(path); end
+
+  sig {returns(T.untyped)}
+  def ref(); end
+
+  sig do
+    params(
+      ref: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def ref=(ref); end
+
+  sig {returns(T.untyped)}
+  def revision(); end
+
+  sig do
+    params(
+      revision: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def revision=(revision); end
+
+  sig {returns(T.untyped)}
+  def uri(); end
+
+  sig do
+    params(
+      uri: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def uri=(uri); end
+
+  sig {returns(T.untyped)}
+  def version(); end
+end
+
+class Bundler::Source::Git::MissingGitRevisionError < Bundler::GitError
+  sig do
+    params(
+      ref: T.untyped,
+      repo: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(ref, repo); end
+end
+
+class Bundler::Source::Metadata < Bundler::Source
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def ==(other); end
+
+  sig {returns(T.untyped)}
+  def cached!(); end
+
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def eql?(other); end
+
+  sig {returns(T.untyped)}
+  def hash(); end
+
+  sig do
+    params(
+      spec: T.untyped,
+      _opts: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def install(spec, _opts=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def options(); end
+
+  sig {returns(T.untyped)}
+  def remote!(); end
+
+  sig {returns(T.untyped)}
+  def specs(); end
+
+  sig {returns(T.untyped)}
+  def to_s(); end
+
+  sig do
+    params(
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def version_message(spec); end
+end
+
+class Bundler::Source::Path < Bundler::Source
+  DEFAULT_GLOB = ::T.let(nil, T.untyped)
+
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def ==(other); end
+
+  sig {returns(T.untyped)}
+  def app_cache_dirname(); end
+
+  sig do
+    params(
+      spec: T.untyped,
+      custom_path: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def cache(spec, custom_path=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def cached!(); end
+
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def eql?(other); end
+
+  sig {returns(T.untyped)}
+  def expanded_original_path(); end
+
+  sig {returns(T.untyped)}
+  def hash(); end
+
+  sig do
+    params(
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(options); end
+
+  sig do
+    params(
+      spec: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def install(spec, options=T.unsafe(nil)); end
+
+  sig do
+    params(
+      _: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def local_specs(*_); end
+
+  sig {returns(T.untyped)}
+  def name(); end
+
+  sig do
+    params(
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def name=(name); end
+
+  sig {returns(T.untyped)}
+  def options(); end
+
+  sig {returns(T.untyped)}
+  def original_path(); end
+
+  sig {returns(T.untyped)}
+  def path(); end
+
+  sig {returns(T.untyped)}
+  def remote!(); end
+
+  sig {returns(T.untyped)}
+  def root(); end
+
+  sig {returns(T.untyped)}
+  def root_path(); end
+
+  sig {returns(T.untyped)}
+  def specs(); end
+
+  sig {returns(T.untyped)}
+  def to_lock(); end
+
+  sig {returns(T.untyped)}
+  def to_s(); end
+
+  sig {returns(T.untyped)}
+  def version(); end
+
+  sig do
+    params(
+      version: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def version=(version); end
+
+  sig do
+    params(
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.from_lock(options); end
+end
+
+class Bundler::Source::Rubygems < Bundler::Source
+  API_REQUEST_LIMIT = ::T.let(nil, T.untyped)
+  API_REQUEST_SIZE = ::T.let(nil, T.untyped)
+
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def ==(other); end
+
+  sig do
+    params(
+      source: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def add_remote(source); end
+
+  sig {returns(T.untyped)}
+  def api_fetchers(); end
+
+  sig do
+    params(
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def builtin_gem?(spec); end
+
+  sig do
+    params(
+      spec: T.untyped,
+      custom_path: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def cache(spec, custom_path=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def cache_path(); end
+
+  sig {returns(T.untyped)}
+  def cached!(); end
+
+  sig do
+    params(
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def cached_built_in_gem(spec); end
+
+  sig do
+    params(
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def cached_gem(spec); end
+
+  sig do
+    params(
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def cached_path(spec); end
+
+  sig {returns(T.untyped)}
+  def cached_specs(); end
+
+  sig {returns(T.untyped)}
+  def caches(); end
+
+  sig do
+    params(
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def can_lock?(spec); end
+
+  sig {returns(T.untyped)}
+  def credless_remotes(); end
+
+  sig {returns(T.untyped)}
+  def dependency_names_to_double_check(); end
+
+  sig do
+    params(
+      unmet_dependency_names: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def double_check_for(unmet_dependency_names); end
+
+  sig do
+    params(
+      other: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def eql?(other); end
+
+  sig do
+    params(
+      other_remotes: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def equivalent_remotes?(other_remotes); end
+
+  sig do
+    params(
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def fetch_gem(spec); end
+
+  sig do
+    params(
+      fetchers: T.untyped,
+      dependency_names: T.untyped,
+      index: T.untyped,
+      override_dupes: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def fetch_names(fetchers, dependency_names, index, override_dupes); end
+
+  sig {returns(T.untyped)}
+  def fetchers(); end
+
+  sig {returns(T.untyped)}
+  def hash(); end
+
+  sig do
+    params(
+      o: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def include?(o); end
+
+  sig do
+    params(
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(options=T.unsafe(nil)); end
+
+  sig do
+    params(
+      spec: T.untyped,
+      opts: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def install(spec, opts=T.unsafe(nil)); end
+
+  sig do
+    params(
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def installed?(spec); end
+
+  sig {returns(T.untyped)}
+  def installed_specs(); end
+
+  sig do
+    params(
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def loaded_from(spec); end
+
+  sig {returns(T.untyped)}
+  def name(); end
+
+  sig do
+    params(
+      uri: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def normalize_uri(uri); end
+
+  sig {returns(T.untyped)}
+  def options(); end
+
+  sig {returns(T.untyped)}
+  def remote!(); end
+
+  sig {returns(T.untyped)}
+  def remote_specs(); end
+
+  sig {returns(T.untyped)}
+  def remotes(); end
+
+  sig do
+    params(
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def remotes_for_spec(spec); end
+
+  sig do
+    params(
+      remote: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def remove_auth(remote); end
+
+  sig do
+    params(
+      other_remotes: T.untyped,
+      allow_equivalent: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def replace_remotes(other_remotes, allow_equivalent=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def requires_sudo?(); end
+
+  sig {returns(T.untyped)}
+  def rubygems_dir(); end
+
+  sig {returns(T.untyped)}
+  def specs(); end
+
+  sig do
+    params(
+      remote: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def suppress_configured_credentials(remote); end
+
+  sig {returns(T.untyped)}
+  def to_lock(); end
+
+  sig {returns(T.untyped)}
+  def to_s(); end
+
+  sig {returns(T.untyped)}
+  def unmet_deps(); end
+
+  sig do
+    params(
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.from_lock(options); end
+end
+
+class Bundler::SourceList
+  sig do
+    params(
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def add_git_source(options=T.unsafe(nil)); end
+
+  sig do
+    params(
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def add_path_source(options=T.unsafe(nil)); end
+
+  sig do
+    params(
+      source: T.untyped,
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def add_plugin_source(source, options=T.unsafe(nil)); end
+
+  sig do
+    params(
+      uri: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def add_rubygems_remote(uri); end
+
+  sig do
+    params(
+      options: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def add_rubygems_source(options=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def all_sources(); end
+
+  sig {returns(T.untyped)}
+  def cached!(); end
+
+  sig {returns(T.untyped)}
+  def default_source(); end
+
+  sig do
+    params(
+      source: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def get(source); end
+
+  sig {returns(T.untyped)}
+  def git_sources(); end
+
+  sig {returns(T.untyped)}
+  def global_rubygems_source(); end
+
+  sig do
+    params(
+      uri: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def global_rubygems_source=(uri); end
+
+  sig {returns(T.untyped)}
+  def initialize(); end
+
+  sig {returns(T.untyped)}
+  def lock_sources(); end
+
+  sig {returns(T.untyped)}
+  def metadata_source(); end
+
+  sig {returns(T.untyped)}
+  def path_sources(); end
+
+  sig {returns(T.untyped)}
+  def plugin_sources(); end
+
+  sig {returns(T.untyped)}
+  def remote!(); end
+
+  sig do
+    params(
+      replacement_sources: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def replace_sources!(replacement_sources); end
+
+  sig {returns(T.untyped)}
+  def rubygems_primary_remotes(); end
+
+  sig {returns(T.untyped)}
+  def rubygems_remotes(); end
+
+  sig {returns(T.untyped)}
+  def rubygems_sources(); end
+end
+
+class Bundler::SpecSet
+  include ::TSort
+  include T::Enumerable
+  extend ::Forwardable
+
+  sig do
+    params(
+      args: T.untyped,
+      block: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def <<(*args, &block); end
+
+  sig do
+    params(
+      key: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def [](key); end
+
+  sig do
+    params(
+      key: T.untyped,
+      value: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def []=(key, value); end
+
+  sig do
+    params(
+      args: T.untyped,
+      block: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def add(*args, &block); end
+
+  sig do
+    params(
+      args: T.untyped,
+      block: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def each(*args, &block); end
+
+  sig do
+    params(
+      args: T.untyped,
+      block: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def empty?(*args, &block); end
+
+  sig do
+    params(
+      name: T.untyped,
+      platform: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def find_by_name_and_platform(name, platform); end
+
+  sig do
+    params(
+      dependencies: T.untyped,
+      skip: T.untyped,
+      check: T.untyped,
+      match_current_platform: T.untyped,
+      raise_on_missing: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def for(dependencies, skip=T.unsafe(nil), check=T.unsafe(nil), match_current_platform=T.unsafe(nil), raise_on_missing=T.unsafe(nil)); end
+
+  sig do
+    params(
+      specs: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(specs); end
+
+  sig do
+    params(
+      args: T.untyped,
+      block: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def length(*args, &block); end
+
+  sig do
+    params(
+      deps: T.untyped,
+      missing_specs: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def materialize(deps, missing_specs=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def materialized_for_all_platforms(); end
+
+  sig do
+    params(
+      set: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def merge(set); end
+
+  sig do
+    params(
+      args: T.untyped,
+      block: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def remove(*args, &block); end
+
+  sig do
+    params(
+      args: T.untyped,
+      block: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def size(*args, &block); end
+
+  sig {returns(T.untyped)}
+  def sort!(); end
+
+  sig {returns(T.untyped)}
+  def to_a(); end
+
+  sig {returns(T.untyped)}
+  def to_hash(); end
+
+  sig do
+    params(
+      deps: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def valid_for?(deps); end
+
+  sig do
+    params(
+      spec: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def what_required(spec); end
+end
+
+class Bundler::StubSpecification < Bundler::RemoteSpecification
+  sig {returns(T.untyped)}
+  def activated(); end
+
+  sig do
+    params(
+      activated: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def activated=(activated); end
+
+  sig {returns(T.untyped)}
+  def default_gem(); end
+
+  sig {returns(T.untyped)}
+  def full_gem_path(); end
+
+  sig {returns(T.untyped)}
+  def full_require_paths(); end
+
+  sig {returns(T.untyped)}
+  def ignored(); end
+
+  sig do
+    params(
+      ignored: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def ignored=(ignored); end
+
+  sig {returns(T.untyped)}
+  def load_paths(); end
+
+  sig {returns(T.untyped)}
+  def loaded_from(); end
+
+  sig do
+    params(
+      glob: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def matches_for_glob(glob); end
+
+  sig {returns(T.untyped)}
+  def missing_extensions?(); end
+
+  sig {returns(T.untyped)}
+  def raw_require_paths(); end
+
+  sig do
+    params(
+      source: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def source=(source); end
+
+  sig {returns(T.untyped)}
+  def stub(); end
+
+  sig do
+    params(
+      stub: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def stub=(stub); end
+
+  sig {returns(T.untyped)}
+  def to_yaml(); end
+
+  sig do
+    params(
+      stub: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.from_stub(stub); end
+end
+
+class Bundler::SudoNotPermittedError < Bundler::BundlerError
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::TemporaryResourceError < Bundler::PermissionError
+  sig {returns(T.untyped)}
+  def message(); end
+
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::ThreadCreationError < Bundler::BundlerError
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+module Bundler::UI
+end
+
+class Bundler::UI::RGProxy < Gem::SilentUI
+  sig do
+    params(
+      ui: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(ui); end
+
+  sig do
+    params(
+      message: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def say(message); end
+end
+
+class Bundler::UI::Silent
+  sig do
+    params(
+      string: T.untyped,
+      color: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def add_color(string, color); end
+
+  sig do
+    params(
+      message: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def ask(message); end
+
+  sig do
+    params(
+      message: T.untyped,
+      newline: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def confirm(message, newline=T.unsafe(nil)); end
+
+  sig do
+    params(
+      message: T.untyped,
+      newline: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def debug(message, newline=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def debug?(); end
+
+  sig do
+    params(
+      message: T.untyped,
+      newline: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def error(message, newline=T.unsafe(nil)); end
+
+  sig do
+    params(
+      message: T.untyped,
+      newline: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def info(message, newline=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def initialize(); end
+
+  sig do
+    params(
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def level(name=T.unsafe(nil)); end
+
+  sig do
+    params(
+      name: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def level=(name); end
+
+  sig {returns(T.untyped)}
+  def no?(); end
+
+  sig {returns(T.untyped)}
+  def quiet?(); end
+
+  sig do
+    params(
+      shell: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def shell=(shell); end
+
+  sig {returns(T.untyped)}
+  def silence(); end
+
+  sig do
+    params(
+      message: T.untyped,
+      newline: T.untyped,
+      force: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def trace(message, newline=T.unsafe(nil), force=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def unprinted_warnings(); end
+
+  sig do
+    params(
+      message: T.untyped,
+      newline: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def warn(message, newline=T.unsafe(nil)); end
+
+  sig do
+    params(
+      msg: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def yes?(msg); end
+end
+
+module Bundler::URICredentialsFilter
+  sig do
+    params(
+      str_to_filter: T.untyped,
+      uri: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.credential_filtered_string(str_to_filter, uri); end
+
+  sig do
+    params(
+      uri_to_anonymize: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.credential_filtered_uri(uri_to_anonymize); end
+end
+
+class Bundler::VersionConflict < Bundler::BundlerError
+  sig {returns(T.untyped)}
+  def conflicts(); end
+
+  sig do
+    params(
+      conflicts: T.untyped,
+      msg: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(conflicts, msg=T.unsafe(nil)); end
+
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+class Bundler::VirtualProtocolError < Bundler::BundlerError
+  sig {returns(T.untyped)}
+  def message(); end
+
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
+
+module Bundler::YAMLSerializer
+  ARRAY_REGEX = ::T.let(nil, T.untyped)
+  HASH_REGEX = ::T.let(nil, T.untyped)
+
+  sig do
+    params(
+      hash: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.dump(hash); end
+
+  sig do
+    params(
+      str: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def self.load(str); end
+end
+
+class Bundler::YamlSyntaxError < Bundler::BundlerError
+  sig do
+    params(
+      orig_exception: T.untyped,
+      msg: T.untyped,
+    )
+    .returns(T.untyped)
+  end
+  def initialize(orig_exception, msg); end
+
+  sig {returns(T.untyped)}
+  def orig_exception(); end
+
+  sig {returns(T.untyped)}
+  def status_code(); end
+end
diff --git a/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi b/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi
new file mode 100644
index 0000000..a486719
--- /dev/null
+++ b/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi
@@ -0,0 +1,276 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi sorbet-typed
+#
+# If you would like to make changes to this file, great! Please upstream any changes you make here:
+#
+#   https://github.com/sorbet/sorbet-typed/edit/master/lib/rainbow/all/rainbow.rbi
+#
+# typed: strong
+
+module Rainbow
+  sig { returns(T::Boolean) }
+  attr_accessor :enabled
+
+  class Color
+    sig { returns(Symbol) }
+    attr_reader :ground
+
+    sig do
+      params(
+        ground: Symbol,
+        values: T.any([Integer], [Integer, Integer, Integer])
+      ).returns(Color)
+    end
+    def self.build(ground, values); end
+
+    sig { params(hex: String).returns([Integer, Integer, Integer]) }
+    def self.parse_hex_color(hex); end
+
+    class Indexed < Color
+      sig { returns(Integer) }
+      attr_reader :num
+
+      sig { params(ground: Symbol, num: Integer).returns(Indexed) }
+      def initialize(ground, num); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+    end
+
+    class Named < Indexed
+      NAMES = T.let(nil, T::Hash[Symbol, Integer])
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+
+      sig { params(ground: Symbol, name: Symbol).returns(Named) }
+      def initialize(ground, name); end
+    end
+
+    class RGB < Indexed
+      sig { returns(Integer) }
+      attr_accessor :r, :g, :b
+
+      sig { params(value: Numeric).returns(Integer) }
+      def to_ansi_domain(value); end
+
+      sig { params(ground: Symbol, values: Integer).returns(RGB) }
+      def initialize(ground, *values); end
+
+      sig { returns(T::Array[Integer]) }
+      def codes; end
+    end
+
+    class X11Named < RGB
+      include X11ColorNames
+
+      sig { returns(T::Array[Symbol]) }
+      def self.color_names; end
+
+      sig { returns(String) }
+      def self.valid_names; end
+
+      sig { params(ground: Symbol, name: Symbol).returns(X11Named) }
+      def initialize(ground, name); end
+    end
+  end
+
+  sig { returns(Wrapper) }
+  def self.global; end
+
+  sig { returns(T::Boolean) }
+  def self.enabled; end
+
+  sig { params(value: T::Boolean).returns(T::Boolean) }
+  def self.enabled=(value); end
+
+  sig { params(string: String).returns(String) }
+  def self.uncolor(string); end
+
+  class NullPresenter < String
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) }
+    def bg(*values); end
+
+    sig { returns(NullPresenter) }
+    def reset; end
+
+    sig { returns(NullPresenter) }
+    def bright; end
+
+    sig { returns(NullPresenter) }
+    def faint; end
+
+    sig { returns(NullPresenter) }
+    def italic; end
+
+    sig { returns(NullPresenter) }
+    def underline; end
+
+    sig { returns(NullPresenter) }
+    def blink; end
+
+    sig { returns(NullPresenter) }
+    def inverse; end
+
+    sig { returns(NullPresenter) }
+    def hide; end
+
+    sig { returns(NullPresenter) }
+    def cross_out; end
+
+    sig { returns(NullPresenter) }
+    def black; end
+
+    sig { returns(NullPresenter) }
+    def red; end
+
+    sig { returns(NullPresenter) }
+    def green; end
+
+    sig { returns(NullPresenter) }
+    def yellow; end
+
+    sig { returns(NullPresenter) }
+    def blue; end
+
+    sig { returns(NullPresenter) }
+    def magenta; end
+
+    sig { returns(NullPresenter) }
+    def cyan; end
+
+    sig { returns(NullPresenter) }
+    def white; end
+
+    sig { returns(NullPresenter) }
+    def bold; end
+
+    sig { returns(NullPresenter) }
+    def dark; end
+
+    sig { returns(NullPresenter) }
+    def strike; end
+  end
+
+  class Presenter < String
+    TERM_EFFECTS = T.let(nil, T::Hash[Symbol, Integer])
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def color(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def foreground(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def fg(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def background(*values); end
+
+    sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) }
+    def bg(*values); end
+
+    sig { returns(Presenter) }
+    def reset; end
+
+    sig { returns(Presenter) }
+    def bright; end
+
+    sig { returns(Presenter) }
+    def faint; end
+
+    sig { returns(Presenter) }
+    def italic; end
+
+    sig { returns(Presenter) }
+    def underline; end
+
+    sig { returns(Presenter) }
+    def blink; end
+
+    sig { returns(Presenter) }
+    def inverse; end
+
+    sig { returns(Presenter) }
+    def hide; end
+
+    sig { returns(Presenter) }
+    def cross_out; end
+
+    sig { returns(Presenter) }
+    def black; end
+
+    sig { returns(Presenter) }
+    def red; end
+
+    sig { returns(Presenter) }
+    def green; end
+
+    sig { returns(Presenter) }
+    def yellow; end
+
+    sig { returns(Presenter) }
+    def blue; end
+
+    sig { returns(Presenter) }
+    def magenta; end
+
+    sig { returns(Presenter) }
+    def cyan; end
+
+    sig { returns(Presenter) }
+    def white; end
+
+    sig { returns(Presenter) }
+    def bold; end
+
+    sig { returns(Presenter) }
+    def dark; end
+
+    sig { returns(Presenter) }
+    def strike; end
+  end
+
+  class StringUtils
+    sig { params(string: String, codes: T::Array[Integer]).returns(String) }
+    def self.wrap_with_sgr(string, codes); end
+
+    sig { params(string: String).returns(String) }
+    def uncolor(string); end
+  end
+
+  VERSION = T.let(nil, String)
+
+  class Wrapper
+    sig { returns(T::Boolean) }
+    attr_accessor :enabled
+
+    sig { params(enabled: T::Boolean).returns(Wrapper) }
+    def initialize(enabled = true); end
+
+    sig { params(string: String).returns(T.any(Rainbow::Presenter, Rainbow::NullPresenter)) }
+    def wrap(string); end
+  end
+
+  module X11ColorNames
+    NAMES = T.let(nil, T::Hash[Symbol, [Integer, Integer, Integer]])
+  end
+end
+
+sig { params(string: String).returns(Rainbow::Presenter) }
+def Rainbow(string); end
diff --git a/sorbet/rbi/sorbet-typed/lib/ruby/all/gem.rbi b/sorbet/rbi/sorbet-typed/lib/ruby/all/gem.rbi
new file mode 100644
index 0000000..2f8d981
--- /dev/null
+++ b/sorbet/rbi/sorbet-typed/lib/ruby/all/gem.rbi
@@ -0,0 +1,4222 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi sorbet-typed
+#
+# If you would like to make changes to this file, great! Please upstream any changes you make here:
+#
+#   https://github.com/sorbet/sorbet-typed/edit/master/lib/ruby/all/gem.rbi
+#
+# typed: strong
+module Gem
+  ConfigMap = T.let(nil, T.untyped)
+  RbConfigPriorities = T.let(nil, T.untyped)
+  RubyGemsPackageVersion = T.let(nil, T.untyped)
+  RubyGemsVersion = T.let(nil, T.untyped)
+  USE_BUNDLER_FOR_GEMDEPS = T.let(nil, T.untyped)
+
+  def self._deprecated_detect_gemdeps(path = T.unsafe(nil)); end
+
+  def self._deprecated_gunzip(data); end
+
+  def self._deprecated_gzip(data); end
+
+  def self._deprecated_inflate(data); end
+
+  def self.activate_bin_path(name, *args); end
+
+  def self.default_ext_dir_for(base_dir); end
+
+  def self.default_gems_use_full_paths?; end
+
+  def self.default_spec_cache_dir; end
+
+  def self.deflate(data); end
+
+  def self.detect_gemdeps(*args, &block); end
+
+  def self.dir; end
+
+  def self.done_installing(&hook); end
+
+  def self.done_installing_hooks; end
+
+  def self.ensure_default_gem_subdirectories(dir = Gem.dir, mode = nil); end
+
+  def self.ensure_gem_subdirectories(dir = Gem.dir, mode = nil); end
+
+  def self.ensure_subdirectories(dir, mode, subdirs); end
+
+  def self.env_requirement(gem_name); end
+
+  def self.extension_api_version; end
+
+  def self.find_files(glob, check_load_path = true); end
+
+  def self.find_files_from_load_path(glob); end
+
+  def self.find_latest_files(glob, check_load_path = T.unsafe(nil)); end
+
+  def self.find_unresolved_default_spec(path); end
+
+  def self.finish_resolve(*_); end
+
+  def self.gemdeps; end
+
+  def self.gunzip(*args, &block); end
+
+  def self.gzip(*args, &block); end
+
+  def self.host; end
+
+  def self.host=(host); end
+
+  def self.inflate(*args, &block); end
+
+  def self.install(name, version = T.unsafe(nil), *options); end
+
+  def self.install_extension_in_lib; end
+
+  def self.latest_rubygems_version; end
+
+  def self.latest_spec_for(name); end
+
+  def self.latest_version_for(name); end
+
+  def self.load_env_plugins; end
+
+  def self.load_path_insert_index; end
+
+  def self.load_plugin_files(plugins); end
+
+  def self.load_plugins; end
+
+  def self.load_yaml; end
+
+  def self.loaded_specs; end
+
+  def self.location_of_caller(depth = T.unsafe(nil)); end
+
+  def self.marshal_version; end
+
+  def self.needs; end
+
+  def self.operating_system_defaults; end
+
+  def self.path; end
+
+  def self.path_separator; end
+
+  def self.paths; end
+
+  def self.paths=(env); end
+
+  def self.platform_defaults; end
+
+  def self.platforms; end
+
+  def self.platforms=(platforms); end
+
+  def self.post_build(&hook); end
+
+  def self.post_build_hooks; end
+
+  def self.post_install(&hook); end
+
+  def self.post_install_hooks; end
+
+  def self.post_reset(&hook); end
+
+  def self.post_reset_hooks; end
+
+  def self.post_uninstall(&hook); end
+
+  def self.post_uninstall_hooks; end
+
+  def self.pre_install(&hook); end
+
+  def self.pre_install_hooks; end
+
+  def self.pre_reset(&hook); end
+
+  def self.pre_reset_hooks; end
+
+  def self.pre_uninstall(&hook); end
+
+  def self.pre_uninstall_hooks; end
+
+  def self.prefix; end
+
+  def self.read_binary(path); end
+
+  def self.refresh; end
+
+  def self.register_default_spec(spec); end
+
+  def self.remove_unresolved_default_spec(spec); end
+
+  def self.ruby; end
+
+  def self.ruby_api_version; end
+
+  def self.ruby_engine; end
+
+  def self.ruby_version; end
+
+  def self.rubygems_version; end
+
+  def self.sources; end
+
+  def self.sources=(new_sources); end
+
+  def self.spec_cache_dir; end
+
+  def self.suffix_pattern; end
+
+  def self.suffixes; end
+
+  def self.time(msg, width = T.unsafe(nil), display = T.unsafe(nil)); end
+
+  def self.try_activate(path); end
+
+  def self.ui; end
+
+  def self.use_gemdeps(path = T.unsafe(nil)); end
+
+  def self.use_paths(home, *paths); end
+
+  def self.user_dir; end
+
+  def self.user_home; end
+
+  def self.vendor_dir; end
+
+  def self.win_platform?; end
+
+  def self.write_binary(path, data); end
+
+  class AvailableSet
+    include Enumerable
+    Elem = type_member(fixed: T.untyped)
+
+    def <<(o); end
+
+    def add(spec, source); end
+
+    def all_specs; end
+
+    def each(&blk); end
+
+    def each_spec; end
+
+    def empty?; end
+
+    def find_all(req); end
+
+    def inject_into_list(dep_list); end
+
+    def match_platform!; end
+
+    def pick_best!; end
+
+    def prefetch(reqs); end
+
+    def remote; end
+
+    def remote=(remote); end
+
+    def remove_installed!(dep); end
+
+    def set; end
+
+    def size; end
+
+    def sorted; end
+
+    def source_for(spec); end
+
+    def to_request_set(development = T.unsafe(nil)); end
+
+    class Tuple
+      def source; end
+
+      def source=(_); end
+
+      def spec; end
+
+      def spec=(_); end
+
+      def self.[](*_); end
+
+      def self.members; end
+    end
+  end
+
+  class BasicSpecification
+    def activated?; end
+
+    def base_dir; end
+
+    def base_dir=(base_dir); end
+
+    def contains_requirable_file?(file); end
+
+    def datadir; end
+
+    def default_gem?; end
+
+    def extension_dir; end
+
+    def extension_dir=(extension_dir); end
+
+    def extensions_dir; end
+
+    def full_gem_path; end
+
+    def full_gem_path=(full_gem_path); end
+
+    def full_name; end
+
+    def full_require_paths; end
+
+    def gem_build_complete_path; end
+
+    def gem_dir; end
+
+    def gems_dir; end
+
+    def ignored=(ignored); end
+
+    def internal_init; end
+
+    def lib_dirs_glob; end
+
+    def loaded_from; end
+
+    def loaded_from=(loaded_from); end
+
+    def matches_for_glob(glob); end
+
+    def name; end
+
+    def platform; end
+
+    def raw_require_paths; end
+
+    def require_paths; end
+
+    def source_paths; end
+
+    def stubbed?; end
+
+    def this; end
+
+    def to_fullpath(path); end
+
+    def to_spec; end
+
+    def version; end
+
+    def self.default_specifications_dir; end
+  end
+
+  module BundlerVersionFinder
+    def self.bundler_version; end
+
+    def self.bundler_version_with_reason; end
+
+    def self.compatible?(spec); end
+
+    def self.filter!(specs); end
+
+    def self.missing_version_message; end
+  end
+
+  class Command
+    include Gem::UserInteraction
+    include Gem::DefaultUserInteraction
+    include Gem::Text
+    HELP = T.let(nil, T.untyped)
+
+    def add_extra_args(args); end
+
+    def add_option(*opts, &handler); end
+
+    def arguments; end
+
+    def begins?(long, short); end
+
+    def command; end
+
+    def defaults; end
+
+    def defaults=(defaults); end
+
+    def defaults_str; end
+
+    def description; end
+
+    def execute; end
+
+    def get_all_gem_names; end
+
+    def get_all_gem_names_and_versions; end
+
+    def get_one_gem_name; end
+
+    def get_one_optional_argument; end
+
+    def handle_options(args); end
+
+    def handles?(args); end
+
+    def initialize(command, summary = T.unsafe(nil), defaults = T.unsafe(nil)); end
+
+    def invoke(*args); end
+
+    def invoke_with_build_args(args, build_args); end
+
+    def merge_options(new_options); end
+
+    def options; end
+
+    def program_name; end
+
+    def program_name=(program_name); end
+
+    def remove_option(name); end
+
+    def show_help; end
+
+    def show_lookup_failure(gem_name, version, errors, domain, required_by = T.unsafe(nil)); end
+
+    def summary; end
+
+    def summary=(summary); end
+
+    def usage; end
+
+    def when_invoked(&block); end
+
+    def self.add_common_option(*args, &handler); end
+
+    def self.add_specific_extra_args(cmd, args); end
+
+    def self.build_args; end
+
+    def self.build_args=(value); end
+
+    def self.common_options; end
+
+    def self.extra_args; end
+
+    def self.extra_args=(value); end
+
+    def self.specific_extra_args(cmd); end
+
+    def self.specific_extra_args_hash; end
+
+    def clean_text(text); end
+
+    def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def levenshtein_distance(str1, str2); end
+
+    def min3(a, b, c); end
+
+    def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+    def ui; end
+
+    def ui=(new_ui); end
+
+    def use_ui(new_ui, &block); end
+
+    def alert(statement, question = T.unsafe(nil)); end
+
+    def alert_error(statement, question = T.unsafe(nil)); end
+
+    def alert_warning(statement, question = T.unsafe(nil)); end
+
+    def ask(question); end
+
+    def ask_for_password(prompt); end
+
+    def ask_yes_no(question, default = T.unsafe(nil)); end
+
+    def choose_from_list(question, list); end
+
+    def say(statement = T.unsafe(nil)); end
+
+    def terminate_interaction(exit_code = T.unsafe(nil)); end
+
+    def verbose(msg = T.unsafe(nil)); end
+  end
+
+  module Commands
+  end
+
+  class ConfigFile
+    include Gem::UserInteraction
+    include Gem::DefaultUserInteraction
+    include Gem::Text
+    DEFAULT_BACKTRACE = T.let(nil, T.untyped)
+    DEFAULT_BULK_THRESHOLD = T.let(nil, T.untyped)
+    DEFAULT_CERT_EXPIRATION_LENGTH_DAYS = T.let(nil, T.untyped)
+    DEFAULT_CONCURRENT_DOWNLOADS = T.let(nil, T.untyped)
+    DEFAULT_UPDATE_SOURCES = T.let(nil, T.untyped)
+    DEFAULT_VERBOSITY = T.let(nil, T.untyped)
+    OPERATING_SYSTEM_DEFAULTS = T.let(nil, T.untyped)
+    PLATFORM_DEFAULTS = T.let(nil, T.untyped)
+    SYSTEM_CONFIG_PATH = T.let(nil, T.untyped)
+    SYSTEM_WIDE_CONFIG_FILE = T.let(nil, T.untyped)
+
+    def ==(other); end
+
+    def [](key); end
+
+    def []=(key, value); end
+
+    def api_keys; end
+
+    def args; end
+
+    def backtrace; end
+
+    def backtrace=(backtrace); end
+
+    def bulk_threshold; end
+
+    def bulk_threshold=(bulk_threshold); end
+
+    def cert_expiration_length_days; end
+
+    def cert_expiration_length_days=(cert_expiration_length_days); end
+
+    def check_credentials_permissions; end
+
+    def concurrent_downloads; end
+
+    def concurrent_downloads=(concurrent_downloads); end
+
+    def config_file_name; end
+
+    def credentials_path; end
+
+    def disable_default_gem_server; end
+
+    def disable_default_gem_server=(disable_default_gem_server); end
+
+    def each(&block); end
+
+    def handle_arguments(arg_list); end
+
+    def home; end
+
+    def home=(home); end
+
+    def initialize(args); end
+
+    def load_api_keys; end
+
+    def load_file(filename); end
+
+    def path; end
+
+    def path=(path); end
+
+    def really_verbose; end
+
+    def rubygems_api_key; end
+
+    def rubygems_api_key=(api_key); end
+
+    def set_api_key(host, api_key); end
+
+    def sources; end
+
+    def sources=(sources); end
+
+    def ssl_ca_cert; end
+
+    def ssl_ca_cert=(ssl_ca_cert); end
+
+    def ssl_client_cert; end
+
+    def ssl_verify_mode; end
+
+    def to_yaml; end
+
+    def unset_api_key!; end
+
+    def update_sources; end
+
+    def update_sources=(update_sources); end
+
+    def verbose; end
+
+    def verbose=(verbose); end
+
+    def write; end
+
+    def clean_text(text); end
+
+    def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def levenshtein_distance(str1, str2); end
+
+    def min3(a, b, c); end
+
+    def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+    def ui; end
+
+    def ui=(new_ui); end
+
+    def use_ui(new_ui, &block); end
+
+    def alert(statement, question = T.unsafe(nil)); end
+
+    def alert_error(statement, question = T.unsafe(nil)); end
+
+    def alert_warning(statement, question = T.unsafe(nil)); end
+
+    def ask(question); end
+
+    def ask_for_password(prompt); end
+
+    def ask_yes_no(question, default = T.unsafe(nil)); end
+
+    def choose_from_list(question, list); end
+
+    def say(statement = T.unsafe(nil)); end
+
+    def terminate_interaction(exit_code = T.unsafe(nil)); end
+  end
+
+  class ConflictError
+    def conflicts; end
+
+    def initialize(target, conflicts); end
+
+    def target; end
+  end
+
+  class ConsoleUI
+    def initialize; end
+  end
+
+  module DefaultUserInteraction
+    include Gem::Text
+
+    def ui; end
+
+    def ui=(new_ui); end
+
+    def use_ui(new_ui, &block); end
+
+    def self.ui; end
+
+    def self.ui=(new_ui); end
+
+    def self.use_ui(new_ui); end
+
+    def clean_text(text); end
+
+    def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def levenshtein_distance(str1, str2); end
+
+    def min3(a, b, c); end
+
+    def truncate_text(text, description, max_length = T.unsafe(nil)); end
+  end
+
+  class Dependency
+    def ==(other); end
+
+    def ===(other); end
+
+    def =~(other); end
+
+    def all_sources; end
+
+    def all_sources=(all_sources); end
+
+    def encode_with(coder); end
+
+    def eql?(other); end
+
+    def groups; end
+
+    def groups=(groups); end
+
+    def initialize(name, *requirements); end
+
+    def latest_version?; end
+
+    def match?(obj, version = T.unsafe(nil), allow_prerelease = T.unsafe(nil)); end
+
+    def matches_spec?(spec); end
+
+    def matching_specs(platform_only = T.unsafe(nil)); end
+
+    def merge(other); end
+
+    def name; end
+
+    def name=(name); end
+
+    def prerelease=(prerelease); end
+
+    def prerelease?; end
+
+    def pretty_print(q); end
+
+    def requirement; end
+
+    def requirements_list; end
+
+    def runtime?; end
+
+    def source; end
+
+    def source=(source); end
+
+    def specific?; end
+
+    def to_lock; end
+
+    def to_spec; end
+
+    def to_specs; end
+
+    def to_yaml_properties; end
+
+    def type; end
+  end
+
+  class DependencyInstaller
+    include Gem::UserInteraction
+    include Gem::DefaultUserInteraction
+    include Gem::Text
+    extend Gem::Deprecate
+    DEFAULT_OPTIONS = T.let(nil, T.untyped)
+
+    def _deprecated_add_found_dependencies(to_do, dependency_list); end
+
+    def _deprecated_gather_dependencies; end
+
+    def add_found_dependencies(*args, &block); end
+
+    def available_set_for(dep_or_name, version); end
+
+    def consider_local?; end
+
+    def consider_remote?; end
+
+    def document; end
+
+    def errors; end
+
+    def find_gems_with_sources(dep, best_only = T.unsafe(nil)); end
+
+    def find_spec_by_name_and_version(gem_name, version = T.unsafe(nil), prerelease = T.unsafe(nil)); end
+
+    def gather_dependencies(*args, &block); end
+
+    def in_background(what); end
+
+    def initialize(options = T.unsafe(nil)); end
+
+    def install(dep_or_name, version = T.unsafe(nil)); end
+
+    def install_development_deps; end
+
+    def installed_gems; end
+
+    def resolve_dependencies(dep_or_name, version); end
+
+    def clean_text(text); end
+
+    def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def levenshtein_distance(str1, str2); end
+
+    def min3(a, b, c); end
+
+    def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+    def ui; end
+
+    def ui=(new_ui); end
+
+    def use_ui(new_ui, &block); end
+
+    def alert(statement, question = T.unsafe(nil)); end
+
+    def alert_error(statement, question = T.unsafe(nil)); end
+
+    def alert_warning(statement, question = T.unsafe(nil)); end
+
+    def ask(question); end
+
+    def ask_for_password(prompt); end
+
+    def ask_yes_no(question, default = T.unsafe(nil)); end
+
+    def choose_from_list(question, list); end
+
+    def say(statement = T.unsafe(nil)); end
+
+    def terminate_interaction(exit_code = T.unsafe(nil)); end
+
+    def verbose(msg = T.unsafe(nil)); end
+  end
+
+  class DependencyList
+    include Enumerable
+    include TSort
+    Elem = type_member(fixed: T.untyped)
+
+    def add(*gemspecs); end
+
+    def clear; end
+
+    def dependency_order; end
+
+    def development; end
+
+    def development=(development); end
+
+    def each(&block); end
+
+    def find_name(full_name); end
+
+    def initialize(development = T.unsafe(nil)); end
+
+    def ok?; end
+
+    def ok_to_remove?(full_name, check_dev = T.unsafe(nil)); end
+
+    def remove_by_name(full_name); end
+
+    def remove_specs_unsatisfied_by(dependencies); end
+
+    def spec_predecessors; end
+
+    def specs; end
+
+    def tsort_each_node(&block); end
+
+    def why_not_ok?(quick = T.unsafe(nil)); end
+
+    def self.from_specs; end
+  end
+
+  class DependencyResolutionError
+    def conflict; end
+
+    def conflicting_dependencies; end
+
+    def initialize(conflict); end
+  end
+
+  module Deprecate
+    def self.deprecate(name, repl, year, month); end
+
+    def self.skip; end
+
+    def self.skip=(v); end
+
+    def self.skip_during; end
+  end
+
+  class Exception
+    extend Gem::Deprecate
+
+    def _deprecated_source_exception; end
+
+    def source_exception(*args, &block); end
+
+    def source_exception=(source_exception); end
+  end
+
+  module Ext
+    class BuildError
+    end
+
+    class Builder
+      include Gem::UserInteraction
+      include Gem::DefaultUserInteraction
+      include Gem::Text
+      CHDIR_MONITOR = T.let(nil, T.untyped)
+      CHDIR_MUTEX = T.let(nil, T.untyped)
+
+      def build_args; end
+
+      def build_args=(build_args); end
+
+      def build_error(build_dir, output, backtrace = T.unsafe(nil)); end
+
+      def build_extension(extension, dest_path); end
+
+      def build_extensions; end
+
+      def builder_for(extension); end
+
+      def initialize(spec, build_args = T.unsafe(nil)); end
+
+      def write_gem_make_out(output); end
+
+      def self.class_name; end
+
+      def self.make(dest_path, results); end
+
+      def self.redirector; end
+
+      def self.run(command, results, command_name = T.unsafe(nil)); end
+
+      def clean_text(text); end
+
+      def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+      def levenshtein_distance(str1, str2); end
+
+      def min3(a, b, c); end
+
+      def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+      def ui; end
+
+      def ui=(new_ui); end
+
+      def use_ui(new_ui, &block); end
+
+      def alert(statement, question = T.unsafe(nil)); end
+
+      def alert_error(statement, question = T.unsafe(nil)); end
+
+      def alert_warning(statement, question = T.unsafe(nil)); end
+
+      def ask(question); end
+
+      def ask_for_password(prompt); end
+
+      def ask_yes_no(question, default = T.unsafe(nil)); end
+
+      def choose_from_list(question, list); end
+
+      def say(statement = T.unsafe(nil)); end
+
+      def terminate_interaction(exit_code = T.unsafe(nil)); end
+
+      def verbose(msg = T.unsafe(nil)); end
+    end
+
+    class CmakeBuilder
+      def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end
+    end
+
+    class ConfigureBuilder
+      def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end
+    end
+
+    class ExtConfBuilder
+      def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end
+
+      def self.get_relative_path(path); end
+    end
+
+    class RakeBuilder
+      def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end
+    end
+  end
+
+  class FilePermissionError
+    def directory; end
+
+    def initialize(directory); end
+  end
+
+  class FormatException
+    def file_path; end
+
+    def file_path=(file_path); end
+  end
+
+  class GemNotInHomeException
+    def spec; end
+
+    def spec=(spec); end
+  end
+
+  class ImpossibleDependenciesError
+    def build_message; end
+
+    def conflicts; end
+
+    def dependency; end
+
+    def initialize(request, conflicts); end
+
+    def request; end
+  end
+
+  class Installer
+    include Gem::UserInteraction
+    include Gem::DefaultUserInteraction
+    include Gem::Text
+    extend Gem::Deprecate
+    ENV_PATHS = T.let(nil, T.untyped)
+
+    def _deprecated_extension_build_error(build_dir, output, backtrace = T.unsafe(nil)); end
+
+    def app_script_text(bin_file_name); end
+
+    def bin_dir; end
+
+    def build_extensions; end
+
+    def build_root; end
+
+    def check_executable_overwrite(filename); end
+
+    def check_that_user_bin_dir_is_in_path; end
+
+    def default_spec_file; end
+
+    def dir; end
+
+    def ensure_dependencies_met; end
+
+    def ensure_dependency(spec, dependency); end
+
+    def ensure_loadable_spec; end
+
+    def ensure_required_ruby_version_met; end
+
+    def ensure_required_rubygems_version_met; end
+
+    def extension_build_error(*args, &block); end
+
+    def extract_bin; end
+
+    def extract_files; end
+
+    def formatted_program_filename(filename); end
+
+    def gem; end
+
+    def gem_dir; end
+
+    def gem_home; end
+
+    def generate_bin; end
+
+    def generate_bin_script(filename, bindir); end
+
+    def generate_bin_symlink(filename, bindir); end
+
+    def generate_windows_script(filename, bindir); end
+
+    def initialize(package, options = T.unsafe(nil)); end
+
+    def install; end
+
+    def installation_satisfies_dependency?(dependency); end
+
+    def installed_specs; end
+
+    def options; end
+
+    def pre_install_checks; end
+
+    def process_options; end
+
+    def run_post_build_hooks; end
+
+    def run_post_install_hooks; end
+
+    def run_pre_install_hooks; end
+
+    def shebang(bin_file_name); end
+
+    def spec; end
+
+    def spec_file; end
+
+    def unpack(directory); end
+
+    def verify_gem_home(unpack = T.unsafe(nil)); end
+
+    def verify_spec; end
+
+    def windows_stub_script(bindir, bin_file_name); end
+
+    def write_build_info_file; end
+
+    def write_cache_file; end
+
+    def write_default_spec; end
+
+    def write_spec; end
+
+    def self.at(path, options = T.unsafe(nil)); end
+
+    def self.exec_format; end
+
+    def self.exec_format=(exec_format); end
+
+    def self.for_spec(spec, options = T.unsafe(nil)); end
+
+    def self.install_lock; end
+
+    def self.path_warning; end
+
+    def self.path_warning=(path_warning); end
+
+    def clean_text(text); end
+
+    def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def levenshtein_distance(str1, str2); end
+
+    def min3(a, b, c); end
+
+    def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+    def ui; end
+
+    def ui=(new_ui); end
+
+    def use_ui(new_ui, &block); end
+
+    def alert(statement, question = T.unsafe(nil)); end
+
+    def alert_error(statement, question = T.unsafe(nil)); end
+
+    def alert_warning(statement, question = T.unsafe(nil)); end
+
+    def ask(question); end
+
+    def ask_for_password(prompt); end
+
+    def ask_yes_no(question, default = T.unsafe(nil)); end
+
+    def choose_from_list(question, list); end
+
+    def say(statement = T.unsafe(nil)); end
+
+    def terminate_interaction(exit_code = T.unsafe(nil)); end
+
+    def verbose(msg = T.unsafe(nil)); end
+  end
+
+  class Licenses
+    extend Gem::Text
+    EXCEPTION_IDENTIFIERS = T.let(nil, T.untyped)
+    LICENSE_IDENTIFIERS = T.let(nil, T.untyped)
+    NONSTANDARD = T.let(nil, T.untyped)
+    REGEXP = T.let(nil, T.untyped)
+
+    def self.match?(license); end
+
+    def self.suggestions(license); end
+
+    def self.clean_text(text); end
+
+    def self.format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def self.levenshtein_distance(str1, str2); end
+
+    def self.min3(a, b, c); end
+
+    def self.truncate_text(text, description, max_length = T.unsafe(nil)); end
+  end
+
+  class List
+    def each(&blk); end
+
+    def initialize(value = T.unsafe(nil), tail = T.unsafe(nil)); end
+
+    def prepend(value); end
+
+    def pretty_print(q); end
+
+    def tail; end
+
+    def tail=(tail); end
+
+    def to_a; end
+
+    def value; end
+
+    def value=(value); end
+
+    def self.prepend(list, value); end
+  end
+
+  class LoadError
+    def name; end
+
+    def name=(name); end
+
+    def requirement; end
+
+    def requirement=(requirement); end
+  end
+
+  class MissingSpecError
+    def initialize(name, requirement); end
+  end
+
+  class MissingSpecVersionError
+    def initialize(name, requirement, specs); end
+
+    def specs; end
+  end
+
+  class NameTuple
+    include Comparable
+
+    def ==(other); end
+
+    def eql?(other); end
+
+    def full_name; end
+
+    def initialize(name, version, platform = T.unsafe(nil)); end
+
+    def match_platform?; end
+
+    def name; end
+
+    def platform; end
+
+    def prerelease?; end
+
+    def spec_name; end
+
+    def to_a; end
+
+    def version; end
+
+    def self.from_list(list); end
+
+    def self.null; end
+
+    def self.to_basic(list); end
+  end
+
+  class Package
+    include Gem::UserInteraction
+    include Gem::DefaultUserInteraction
+    include Gem::Text
+
+    def add_checksums(tar); end
+
+    def add_contents(tar); end
+
+    def add_files(tar); end
+
+    def add_metadata(tar); end
+
+    def build(skip_validation = T.unsafe(nil), strict_validation = T.unsafe(nil)); end
+
+    def build_time; end
+
+    def build_time=(build_time); end
+
+    def checksums; end
+
+    def contents; end
+
+    def copy_to(path); end
+
+    def data_mode; end
+
+    def data_mode=(data_mode); end
+
+    def digest(entry); end
+
+    def dir_mode; end
+
+    def dir_mode=(dir_mode); end
+
+    def extract_files(destination_dir, pattern = T.unsafe(nil)); end
+
+    def extract_tar_gz(io, destination_dir, pattern = T.unsafe(nil)); end
+
+    def file_mode(mode); end
+
+    def files; end
+
+    def gzip_to(io); end
+
+    def initialize(gem, security_policy); end
+
+    def install_location(filename, destination_dir); end
+
+    def load_spec(entry); end
+
+    def mkdir_p_safe(mkdir, mkdir_options, destination_dir, file_name); end
+
+    def normalize_path(pathname); end
+
+    def open_tar_gz(io); end
+
+    def prog_mode; end
+
+    def prog_mode=(prog_mode); end
+
+    def read_checksums(gem); end
+
+    def security_policy; end
+
+    def security_policy=(security_policy); end
+
+    def setup_signer(signer_options: T.unsafe(nil)); end
+
+    def spec; end
+
+    def spec=(spec); end
+
+    def verify; end
+
+    def verify_checksums(digests, checksums); end
+
+    def verify_entry(entry); end
+
+    def verify_files(gem); end
+
+    def verify_gz(entry); end
+
+    def self.build(spec, skip_validation = T.unsafe(nil), strict_validation = T.unsafe(nil), file_name = T.unsafe(nil)); end
+
+    def self.new(gem, security_policy = T.unsafe(nil)); end
+
+    def clean_text(text); end
+
+    def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def levenshtein_distance(str1, str2); end
+
+    def min3(a, b, c); end
+
+    def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+    def ui; end
+
+    def ui=(new_ui); end
+
+    def use_ui(new_ui, &block); end
+
+    def alert(statement, question = T.unsafe(nil)); end
+
+    def alert_error(statement, question = T.unsafe(nil)); end
+
+    def alert_warning(statement, question = T.unsafe(nil)); end
+
+    def ask(question); end
+
+    def ask_for_password(prompt); end
+
+    def ask_yes_no(question, default = T.unsafe(nil)); end
+
+    def choose_from_list(question, list); end
+
+    def say(statement = T.unsafe(nil)); end
+
+    def terminate_interaction(exit_code = T.unsafe(nil)); end
+
+    def verbose(msg = T.unsafe(nil)); end
+
+    class DigestIO
+      def digests; end
+
+      def initialize(io, digests); end
+
+      def write(data); end
+
+      def self.wrap(io, digests); end
+    end
+
+    class Error
+    end
+
+    class FileSource
+      def initialize(path); end
+
+      def path; end
+
+      def present?; end
+
+      def start; end
+
+      def with_read_io(&block); end
+
+      def with_write_io(&block); end
+    end
+
+    class FormatError
+      def initialize(message, source = T.unsafe(nil)); end
+
+      def path; end
+    end
+
+    class IOSource
+      def initialize(io); end
+
+      def io; end
+
+      def path; end
+
+      def present?; end
+
+      def start; end
+
+      def with_read_io; end
+
+      def with_write_io; end
+    end
+
+    class NonSeekableIO
+    end
+
+    class Old
+      def extract_files(destination_dir); end
+
+      def file_list(io); end
+
+      def read_until_dashes(io); end
+
+      def skip_ruby(io); end
+    end
+
+    class PathError
+      def initialize(destination, destination_dir); end
+    end
+
+    class Source
+    end
+
+    class TarHeader
+      EMPTY_HEADER = T.let(nil, T.untyped)
+      FIELDS = T.let(nil, T.untyped)
+      PACK_FORMAT = T.let(nil, T.untyped)
+      UNPACK_FORMAT = T.let(nil, T.untyped)
+
+      def ==(other); end
+
+      def checksum; end
+
+      def devmajor; end
+
+      def devminor; end
+
+      def empty?; end
+
+      def gid; end
+
+      def gname; end
+
+      def initialize(vals); end
+
+      def linkname; end
+
+      def magic; end
+
+      def mode; end
+
+      def mtime; end
+
+      def name; end
+
+      def prefix; end
+
+      def size; end
+
+      def typeflag; end
+
+      def uid; end
+
+      def uname; end
+
+      def update_checksum; end
+
+      def version; end
+
+      def self.from(stream); end
+
+      def self.strict_oct(str); end
+    end
+
+    class TarInvalidError
+    end
+
+    class TarReader
+      include Enumerable
+      Elem = type_member(fixed: T.untyped)
+
+      def close; end
+
+      def each(&blk); end
+
+      def each_entry; end
+
+      def initialize(io); end
+
+      def rewind; end
+
+      def seek(name); end
+
+      def self.new(io); end
+
+      class Entry
+        def bytes_read; end
+
+        def check_closed; end
+
+        def close; end
+
+        def closed?; end
+
+        def directory?; end
+
+        def eof?; end
+
+        def file?; end
+
+        def full_name; end
+
+        def getc; end
+
+        def header; end
+
+        def initialize(header, io); end
+
+        def length; end
+
+        def pos; end
+
+        def read(len = T.unsafe(nil)); end
+
+        def readpartial(maxlen = T.unsafe(nil), outbuf = T.unsafe(nil)); end
+
+        def rewind; end
+
+        def size; end
+
+        def symlink?; end
+      end
+
+      class UnexpectedEOF
+      end
+    end
+
+    class TarWriter
+      def add_file(name, mode); end
+
+      def add_file_digest(name, mode, digest_algorithms); end
+
+      def add_file_signed(name, mode, signer); end
+
+      def add_file_simple(name, mode, size); end
+
+      def add_symlink(name, target, mode); end
+
+      def check_closed; end
+
+      def close; end
+
+      def closed?; end
+
+      def flush; end
+
+      def initialize(io); end
+
+      def mkdir(name, mode); end
+
+      def split_name(name); end
+
+      def self.new(io); end
+
+      class BoundedStream
+        def initialize(io, limit); end
+
+        def limit; end
+
+        def write(data); end
+
+        def written; end
+      end
+
+      class FileOverflow
+      end
+
+      class RestrictedStream
+        def initialize(io); end
+
+        def write(data); end
+      end
+    end
+
+    class TooLongFileName
+    end
+  end
+
+  class PathSupport
+    def home; end
+
+    def initialize(env); end
+
+    def path; end
+
+    def spec_cache_dir; end
+  end
+
+  class Platform
+    JAVA = T.let(nil, T.untyped)
+    MINGW = T.let(nil, T.untyped)
+    MSWIN = T.let(nil, T.untyped)
+    MSWIN64 = T.let(nil, T.untyped)
+    X64_MINGW = T.let(nil, T.untyped)
+
+    def ==(other); end
+
+    def ===(other); end
+
+    def =~(other); end
+
+    def cpu; end
+
+    def cpu=(cpu); end
+
+    def eql?(other); end
+
+    def initialize(arch); end
+
+    def os; end
+
+    def os=(os); end
+
+    def to_a; end
+
+    def version; end
+
+    def version=(version); end
+
+    def self.installable?(spec); end
+
+    def self.local; end
+
+    def self.match(platform); end
+
+    def self.new(arch); end
+  end
+
+  class PlatformMismatch
+    def add_platform(platform); end
+
+    def initialize(name, version); end
+
+    def name; end
+
+    def platforms; end
+
+    def version; end
+
+    def wordy; end
+  end
+
+  class RemoteFetcher
+    include Gem::UserInteraction
+    include Gem::DefaultUserInteraction
+    include Gem::Text
+    BASE64_URI_TRANSLATE = T.let(nil, T.untyped)
+
+    def cache_update_path(uri, path = T.unsafe(nil), update = T.unsafe(nil)); end
+
+    def close_all; end
+
+    def correct_for_windows_path(path); end
+
+    def download(spec, source_uri, install_dir = T.unsafe(nil)); end
+
+    def download_to_cache(dependency); end
+
+    def fetch_file(uri, *_); end
+
+    def fetch_http(uri, last_modified = T.unsafe(nil), head = T.unsafe(nil), depth = T.unsafe(nil)); end
+
+    def fetch_https(uri, last_modified = T.unsafe(nil), head = T.unsafe(nil), depth = T.unsafe(nil)); end
+
+    def fetch_path(uri, mtime = T.unsafe(nil), head = T.unsafe(nil)); end
+
+    def fetch_s3(uri, mtime = T.unsafe(nil), head = T.unsafe(nil)); end
+
+    def fetch_size(uri); end
+
+    def headers; end
+
+    def headers=(headers); end
+
+    def https?(uri); end
+
+    def initialize(proxy = T.unsafe(nil), dns = T.unsafe(nil), headers = T.unsafe(nil)); end
+
+    def request(uri, request_class, last_modified = T.unsafe(nil)); end
+
+    def s3_expiration; end
+
+    def sign_s3_url(uri, expiration = T.unsafe(nil)); end
+
+    def self.fetcher; end
+
+    def clean_text(text); end
+
+    def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def levenshtein_distance(str1, str2); end
+
+    def min3(a, b, c); end
+
+    def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+    def ui; end
+
+    def ui=(new_ui); end
+
+    def use_ui(new_ui, &block); end
+
+    def alert(statement, question = T.unsafe(nil)); end
+
+    def alert_error(statement, question = T.unsafe(nil)); end
+
+    def alert_warning(statement, question = T.unsafe(nil)); end
+
+    def ask(question); end
+
+    def ask_for_password(prompt); end
+
+    def ask_yes_no(question, default = T.unsafe(nil)); end
+
+    def choose_from_list(question, list); end
+
+    def say(statement = T.unsafe(nil)); end
+
+    def terminate_interaction(exit_code = T.unsafe(nil)); end
+
+    def verbose(msg = T.unsafe(nil)); end
+  end
+
+  class Request
+    include Gem::UserInteraction
+    include Gem::DefaultUserInteraction
+    include Gem::Text
+    extend Gem::UserInteraction
+    extend Gem::DefaultUserInteraction
+    extend Gem::Text
+
+    def cert_files; end
+
+    def connection_for(uri); end
+
+    def fetch; end
+
+    def initialize(uri, request_class, last_modified, pool); end
+
+    def perform_request(request); end
+
+    def proxy_uri; end
+
+    def reset(connection); end
+
+    def user_agent; end
+
+    def self.configure_connection_for_https(connection, cert_files); end
+
+    def self.create_with_proxy(uri, request_class, last_modified, proxy); end
+
+    def self.get_cert_files; end
+
+    def self.get_proxy_from_env(scheme = T.unsafe(nil)); end
+
+    def self.proxy_uri(proxy); end
+
+    def self.verify_certificate(store_context); end
+
+    def self.verify_certificate_message(error_number, cert); end
+
+    def self.clean_text(text); end
+
+    def self.format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def self.levenshtein_distance(str1, str2); end
+
+    def self.min3(a, b, c); end
+
+    def self.truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+    def self.ui; end
+
+    def self.ui=(new_ui); end
+
+    def self.use_ui(new_ui, &block); end
+
+    def self.alert(statement, question = T.unsafe(nil)); end
+
+    def self.alert_error(statement, question = T.unsafe(nil)); end
+
+    def self.alert_warning(statement, question = T.unsafe(nil)); end
+
+    def self.ask(question); end
+
+    def self.ask_for_password(prompt); end
+
+    def self.ask_yes_no(question, default = T.unsafe(nil)); end
+
+    def self.choose_from_list(question, list); end
+
+    def self.say(statement = T.unsafe(nil)); end
+
+    def self.terminate_interaction(exit_code = T.unsafe(nil)); end
+
+    def self.verbose(msg = T.unsafe(nil)); end
+
+    def clean_text(text); end
+
+    def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def levenshtein_distance(str1, str2); end
+
+    def min3(a, b, c); end
+
+    def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+    def ui; end
+
+    def ui=(new_ui); end
+
+    def use_ui(new_ui, &block); end
+
+    def alert(statement, question = T.unsafe(nil)); end
+
+    def alert_error(statement, question = T.unsafe(nil)); end
+
+    def alert_warning(statement, question = T.unsafe(nil)); end
+
+    def ask(question); end
+
+    def ask_for_password(prompt); end
+
+    def ask_yes_no(question, default = T.unsafe(nil)); end
+
+    def choose_from_list(question, list); end
+
+    def say(statement = T.unsafe(nil)); end
+
+    def terminate_interaction(exit_code = T.unsafe(nil)); end
+
+    def verbose(msg = T.unsafe(nil)); end
+
+    class ConnectionPools
+      def close_all; end
+
+      def initialize(proxy_uri, cert_files); end
+
+      def pool_for(uri); end
+
+      def self.client; end
+
+      def self.client=(client); end
+    end
+
+    class HTTPPool
+      def cert_files; end
+
+      def checkin(connection); end
+
+      def checkout; end
+
+      def close_all; end
+
+      def initialize(http_args, cert_files, proxy_uri); end
+
+      def proxy_uri; end
+    end
+
+    class HTTPSPool
+    end
+  end
+
+  class RequestSet
+    include TSort
+
+    def always_install; end
+
+    def always_install=(always_install); end
+
+    def dependencies; end
+
+    def development; end
+
+    def development=(development); end
+
+    def development_shallow; end
+
+    def development_shallow=(development_shallow); end
+
+    def errors; end
+
+    def gem(name, *reqs); end
+
+    def git_set; end
+
+    def ignore_dependencies; end
+
+    def ignore_dependencies=(ignore_dependencies); end
+
+    def import(deps); end
+
+    def initialize(*deps); end
+
+    def install(options, &block); end
+
+    def install_dir; end
+
+    def install_from_gemdeps(options, &block); end
+
+    def install_hooks(requests, options); end
+
+    def install_into(dir, force = T.unsafe(nil), options = T.unsafe(nil)); end
+
+    def load_gemdeps(path, without_groups = T.unsafe(nil), installing = T.unsafe(nil)); end
+
+    def prerelease; end
+
+    def prerelease=(prerelease); end
+
+    def pretty_print(q); end
+
+    def remote; end
+
+    def remote=(remote); end
+
+    def resolve(set = T.unsafe(nil)); end
+
+    def resolve_current; end
+
+    def resolver; end
+
+    def sets; end
+
+    def soft_missing; end
+
+    def soft_missing=(soft_missing); end
+
+    def sorted_requests; end
+
+    def source_set; end
+
+    def specs; end
+
+    def specs_in(dir); end
+
+    def tsort_each_node(&block); end
+
+    def vendor_set; end
+
+    class GemDependencyAPI
+      ENGINE_MAP = T.let(nil, T.untyped)
+      PLATFORM_MAP = T.let(nil, T.untyped)
+      VERSION_MAP = T.let(nil, T.untyped)
+      WINDOWS = T.let(nil, T.untyped)
+
+      def dependencies; end
+
+      def find_gemspec(name, path); end
+
+      def gem(name, *requirements); end
+
+      def gem_deps_file; end
+
+      def gem_git_reference(options); end
+
+      def gemspec(options = T.unsafe(nil)); end
+
+      def git(repository); end
+
+      def git_set; end
+
+      def git_source(name, &callback); end
+
+      def group(*groups); end
+
+      def initialize(set, path); end
+
+      def installing=(installing); end
+
+      def load; end
+
+      def platform(*platforms); end
+
+      def platforms(*platforms); end
+
+      def requires; end
+
+      def ruby(version, options = T.unsafe(nil)); end
+
+      def source(url); end
+
+      def vendor_set; end
+
+      def without_groups; end
+
+      def without_groups=(without_groups); end
+    end
+
+    class Lockfile
+      def add_DEPENDENCIES(out); end
+
+      def add_GEM(out, spec_groups); end
+
+      def add_GIT(out, git_requests); end
+
+      def add_PATH(out, path_requests); end
+
+      def add_PLATFORMS(out); end
+
+      def initialize(request_set, gem_deps_file, dependencies); end
+
+      def platforms; end
+
+      def relative_path_from(dest, base); end
+
+      def spec_groups; end
+
+      def write; end
+
+      def self.build(request_set, gem_deps_file, dependencies = T.unsafe(nil)); end
+
+      def self.requests_to_deps(requests); end
+
+      class ParseError
+        def column; end
+
+        def initialize(message, column, line, path); end
+
+        def line; end
+
+        def path; end
+      end
+
+      class Parser
+        def get(expected_types = T.unsafe(nil), expected_value = T.unsafe(nil)); end
+
+        def initialize(tokenizer, set, platforms, filename = T.unsafe(nil)); end
+
+        def parse; end
+
+        def parse_DEPENDENCIES; end
+
+        def parse_GEM; end
+
+        def parse_GIT; end
+
+        def parse_PATH; end
+
+        def parse_PLATFORMS; end
+
+        def parse_dependency(name, op); end
+      end
+
+      class Tokenizer
+        EOF = T.let(nil, T.untyped)
+
+        def empty?; end
+
+        def initialize(input, filename = T.unsafe(nil), line = T.unsafe(nil), pos = T.unsafe(nil)); end
+
+        def make_parser(set, platforms); end
+
+        def next_token; end
+
+        def peek; end
+
+        def shift; end
+
+        def skip(type); end
+
+        def to_a; end
+
+        def token_pos(byte_offset); end
+
+        def unshift(token); end
+
+        def self.from_file(file); end
+
+        class Token
+          def column; end
+
+          def column=(_); end
+
+          def line; end
+
+          def line=(_); end
+
+          def type; end
+
+          def type=(_); end
+
+          def value; end
+
+          def value=(_); end
+
+          def self.[](*_); end
+
+          def self.members; end
+        end
+      end
+    end
+  end
+
+  class Requirement
+    DefaultRequirement = T.let(nil, T.untyped)
+
+    def ==(other); end
+
+    def ===(version); end
+
+    def =~(version); end
+
+    def _tilde_requirements; end
+
+    def as_list; end
+
+    def concat(new); end
+
+    def encode_with(coder); end
+
+    def exact?; end
+
+    def for_lockfile; end
+
+    def init_with(coder); end
+
+    def initialize(*requirements); end
+
+    def marshal_dump; end
+
+    def marshal_load(array); end
+
+    def none?; end
+
+    def prerelease?; end
+
+    def pretty_print(q); end
+
+    def requirements; end
+
+    def satisfied_by?(version); end
+
+    def specific?; end
+
+    def to_yaml_properties; end
+
+    def yaml_initialize(tag, vals); end
+
+    def self.create(*inputs); end
+
+    def self.default; end
+
+    def self.parse(obj); end
+
+    def self.source_set; end
+  end
+
+  class Resolver
+    include Gem::Resolver::Molinillo::UI
+    include Gem::Resolver::Molinillo::SpecificationProvider
+    DEBUG_RESOLVER = T.let(nil, T.untyped)
+
+    def activation_request(dep, possible); end
+
+    def development; end
+
+    def development=(development); end
+
+    def development_shallow; end
+
+    def development_shallow=(development_shallow); end
+
+    def explain(stage, *data); end
+
+    def explain_list(stage); end
+
+    def find_possible(dependency); end
+
+    def ignore_dependencies; end
+
+    def ignore_dependencies=(ignore_dependencies); end
+
+    def initialize(needed, set = T.unsafe(nil)); end
+
+    def missing; end
+
+    def requests(s, act, reqs = T.unsafe(nil)); end
+
+    def resolve; end
+
+    def select_local_platforms(specs); end
+
+    def skip_gems; end
+
+    def skip_gems=(skip_gems); end
+
+    def soft_missing; end
+
+    def soft_missing=(soft_missing); end
+
+    def stats; end
+
+    def self.compose_sets(*sets); end
+
+    def self.for_current_gems(needed); end
+
+    def allow_missing?(dependency); end
+
+    def dependencies_for(specification); end
+
+    def name_for(dependency); end
+
+    def name_for_explicit_dependency_source; end
+
+    def name_for_locking_dependency_source; end
+
+    def requirement_satisfied_by?(requirement, activated, spec); end
+
+    def search_for(dependency); end
+
+    def sort_dependencies(dependencies, activated, conflicts); end
+
+    def after_resolution; end
+
+    def before_resolution; end
+
+    def debug(depth = T.unsafe(nil)); end
+
+    def debug?; end
+
+    def indicate_progress; end
+
+    def output; end
+
+    def progress_rate; end
+
+    class APISet
+      def dep_uri; end
+
+      def initialize(dep_uri = T.unsafe(nil)); end
+
+      def prefetch_now; end
+
+      def pretty_print(q); end
+
+      def source; end
+
+      def uri; end
+
+      def versions(name); end
+    end
+
+    class APISpecification
+      def ==(other); end
+
+      def initialize(set, api_data); end
+
+      def pretty_print(q); end
+    end
+
+    class ActivationRequest
+      def ==(other); end
+
+      def development?; end
+
+      def download(path); end
+
+      def full_name; end
+
+      def full_spec; end
+
+      def initialize(spec, request, others_possible = T.unsafe(nil)); end
+
+      def installed?; end
+
+      def name; end
+
+      def others_possible?; end
+
+      def parent; end
+
+      def pretty_print(q); end
+
+      def request; end
+
+      def spec; end
+
+      def version; end
+    end
+
+    class BestSet
+      def initialize(sources = T.unsafe(nil)); end
+
+      def pick_sets; end
+
+      def pretty_print(q); end
+
+      def replace_failed_api_set(error); end
+    end
+
+    class ComposedSet
+      def initialize(*sets); end
+
+      def prerelease=(allow_prerelease); end
+
+      def remote=(remote); end
+
+      def sets; end
+    end
+
+    class Conflict
+      def ==(other); end
+
+      def activated; end
+
+      def conflicting_dependencies; end
+
+      def dependency; end
+
+      def explain; end
+
+      def explanation; end
+
+      def failed_dep; end
+
+      def for_spec?(spec); end
+
+      def initialize(dependency, activated, failed_dep = T.unsafe(nil)); end
+
+      def pretty_print(q); end
+
+      def request_path(current); end
+
+      def requester; end
+    end
+
+    class CurrentSet
+    end
+
+    class DependencyRequest
+      def ==(other); end
+
+      def dependency; end
+
+      def development?; end
+
+      def explicit?; end
+
+      def implicit?; end
+
+      def initialize(dependency, requester); end
+
+      def match?(spec, allow_prerelease = T.unsafe(nil)); end
+
+      def matches_spec?(spec); end
+
+      def name; end
+
+      def pretty_print(q); end
+
+      def request_context; end
+
+      def requester; end
+
+      def requirement; end
+
+      def type; end
+    end
+
+    class GitSet
+      def add_git_gem(name, repository, reference, submodules); end
+
+      def add_git_spec(name, version, repository, reference, submodules); end
+
+      def need_submodules; end
+
+      def pretty_print(q); end
+
+      def repositories; end
+
+      def root_dir; end
+
+      def root_dir=(root_dir); end
+
+      def specs; end
+    end
+
+    class GitSpecification
+      def ==(other); end
+
+      def add_dependency(dependency); end
+
+      def pretty_print(q); end
+    end
+
+    class IndexSet
+      def initialize(source = T.unsafe(nil)); end
+
+      def pretty_print(q); end
+    end
+
+    class IndexSpecification
+      def initialize(set, name, version, source, platform); end
+
+      def pretty_print(q); end
+    end
+
+    class InstalledSpecification
+      def ==(other); end
+
+      def pretty_print(q); end
+    end
+
+    class InstallerSet
+      def add_always_install(dependency); end
+
+      def add_local(dep_name, spec, source); end
+
+      def always_install; end
+
+      def consider_local?; end
+
+      def consider_remote?; end
+
+      def ignore_dependencies; end
+
+      def ignore_dependencies=(ignore_dependencies); end
+
+      def ignore_installed; end
+
+      def ignore_installed=(ignore_installed); end
+
+      def initialize(domain); end
+
+      def load_spec(name, ver, platform, source); end
+
+      def local?(dep_name); end
+
+      def prerelease=(allow_prerelease); end
+
+      def pretty_print(q); end
+
+      def remote=(remote); end
+
+      def remote_set; end
+    end
+
+    class LocalSpecification
+      def pretty_print(q); end
+    end
+
+    class LockSet
+      def add(name, version, platform); end
+
+      def initialize(sources); end
+
+      def load_spec(name, version, platform, source); end
+
+      def pretty_print(q); end
+
+      def specs; end
+    end
+
+    class LockSpecification
+      def add_dependency(dependency); end
+
+      def initialize(set, name, version, sources, platform); end
+
+      def pretty_print(q); end
+
+      def sources; end
+    end
+
+    module Molinillo
+      VERSION = T.let(nil, T.untyped)
+
+      class CircularDependencyError
+        def dependencies; end
+
+        def initialize(nodes); end
+      end
+
+      module Delegates
+        module ResolutionState
+          def activated; end
+
+          def conflicts; end
+
+          def depth; end
+
+          def name; end
+
+          def possibilities; end
+
+          def requirement; end
+
+          def requirements; end
+        end
+
+        module SpecificationProvider
+          def allow_missing?(dependency); end
+
+          def dependencies_for(specification); end
+
+          def name_for(dependency); end
+
+          def name_for_explicit_dependency_source; end
+
+          def name_for_locking_dependency_source; end
+
+          def requirement_satisfied_by?(requirement, activated, spec); end
+
+          def search_for(dependency); end
+
+          def sort_dependencies(dependencies, activated, conflicts); end
+        end
+      end
+
+      class DependencyGraph
+        include Enumerable
+        include TSort
+        Elem = type_member(fixed: T.untyped)
+
+        def ==(other); end
+
+        def add_child_vertex(name, payload, parent_names, requirement); end
+
+        def add_edge(origin, destination, requirement); end
+
+        def add_vertex(name, payload, root = T.unsafe(nil)); end
+
+        def delete_edge(edge); end
+
+        def detach_vertex_named(name); end
+
+        def each(&blk); end
+
+        def log; end
+
+        def rewind_to(tag); end
+
+        def root_vertex_named(name); end
+
+        def set_payload(name, payload); end
+
+        def tag(tag); end
+
+        def to_dot(options = T.unsafe(nil)); end
+
+        def tsort_each_child(vertex, &block); end
+
+        def vertex_named(name); end
+
+        def vertices; end
+
+        def self.tsort(vertices); end
+
+        class Action
+          def down(graph); end
+
+          def next; end
+
+          def next=(_); end
+
+          def previous; end
+
+          def previous=(previous); end
+
+          def up(graph); end
+
+          def self.action_name; end
+        end
+
+        class AddEdgeNoCircular
+          def destination; end
+
+          def initialize(origin, destination, requirement); end
+
+          def make_edge(graph); end
+
+          def origin; end
+
+          def requirement; end
+        end
+
+        class AddVertex
+          def initialize(name, payload, root); end
+
+          def name; end
+
+          def payload; end
+
+          def root; end
+        end
+
+        class DeleteEdge
+          def destination_name; end
+
+          def initialize(origin_name, destination_name, requirement); end
+
+          def make_edge(graph); end
+
+          def origin_name; end
+
+          def requirement; end
+        end
+
+        class DetachVertexNamed
+          def initialize(name); end
+
+          def name; end
+        end
+
+        class Edge
+          def destination; end
+
+          def destination=(_); end
+
+          def origin; end
+
+          def origin=(_); end
+
+          def requirement; end
+
+          def requirement=(_); end
+
+          def self.[](*_); end
+
+          def self.members; end
+        end
+
+        class Log
+          extend T::Enumerable
+          Elem = type_member(fixed: T.untyped)
+
+          def add_edge_no_circular(graph, origin, destination, requirement); end
+
+          def add_vertex(graph, name, payload, root); end
+
+          def delete_edge(graph, origin_name, destination_name, requirement); end
+
+          def detach_vertex_named(graph, name); end
+
+          def each(&blk); end
+
+          def pop!(graph); end
+
+          def reverse_each; end
+
+          def rewind_to(graph, tag); end
+
+          def set_payload(graph, name, payload); end
+
+          def tag(graph, tag); end
+        end
+
+        class SetPayload
+          def initialize(name, payload); end
+
+          def name; end
+
+          def payload; end
+        end
+
+        class Tag
+          def down(_graph); end
+
+          def initialize(tag); end
+
+          def tag; end
+
+          def up(_graph); end
+        end
+
+        class Vertex
+          def ==(other); end
+
+          def ancestor?(other); end
+
+          def descendent?(other); end
+
+          def eql?(other); end
+
+          def explicit_requirements; end
+
+          def incoming_edges; end
+
+          def incoming_edges=(incoming_edges); end
+
+          def initialize(name, payload); end
+
+          def is_reachable_from?(other); end
+
+          def name; end
+
+          def name=(name); end
+
+          def outgoing_edges; end
+
+          def outgoing_edges=(outgoing_edges); end
+
+          def path_to?(other); end
+
+          def payload; end
+
+          def payload=(payload); end
+
+          def predecessors; end
+
+          def recursive_predecessors; end
+
+          def recursive_successors; end
+
+          def requirements; end
+
+          def root; end
+
+          def root=(root); end
+
+          def root?; end
+
+          def shallow_eql?(other); end
+
+          def successors; end
+        end
+      end
+
+      class DependencyState
+        def pop_possibility_state; end
+      end
+
+      class NoSuchDependencyError
+        def dependency; end
+
+        def dependency=(dependency); end
+
+        def initialize(dependency, required_by = T.unsafe(nil)); end
+
+        def required_by; end
+
+        def required_by=(required_by); end
+      end
+
+      class PossibilityState
+      end
+
+      class ResolutionState
+        def activated; end
+
+        def activated=(_); end
+
+        def conflicts; end
+
+        def conflicts=(_); end
+
+        def depth; end
+
+        def depth=(_); end
+
+        def name; end
+
+        def name=(_); end
+
+        def possibilities; end
+
+        def possibilities=(_); end
+
+        def requirement; end
+
+        def requirement=(_); end
+
+        def requirements; end
+
+        def requirements=(_); end
+
+        def self.[](*_); end
+
+        def self.empty; end
+
+        def self.members; end
+      end
+
+      class Resolver
+        def initialize(specification_provider, resolver_ui); end
+
+        def resolve(requested, base = T.unsafe(nil)); end
+
+        def resolver_ui; end
+
+        def specification_provider; end
+
+        class Resolution
+          include Gem::Resolver::Molinillo::Delegates::ResolutionState
+          include Gem::Resolver::Molinillo::Delegates::SpecificationProvider
+
+          def base; end
+
+          def initialize(specification_provider, resolver_ui, requested, base); end
+
+          def iteration_rate=(iteration_rate); end
+
+          def original_requested; end
+
+          def resolve; end
+
+          def resolver_ui; end
+
+          def specification_provider; end
+
+          def started_at=(started_at); end
+
+          def states=(states); end
+
+          def allow_missing?(dependency); end
+
+          def dependencies_for(specification); end
+
+          def name_for(dependency); end
+
+          def name_for_explicit_dependency_source; end
+
+          def name_for_locking_dependency_source; end
+
+          def requirement_satisfied_by?(requirement, activated, spec); end
+
+          def search_for(dependency); end
+
+          def sort_dependencies(dependencies, activated, conflicts); end
+
+          def activated; end
+
+          def conflicts; end
+
+          def depth; end
+
+          def name; end
+
+          def possibilities; end
+
+          def requirement; end
+
+          def requirements; end
+
+          class Conflict
+            def activated_by_name; end
+
+            def activated_by_name=(_); end
+
+            def existing; end
+
+            def existing=(_); end
+
+            def locked_requirement; end
+
+            def locked_requirement=(_); end
+
+            def possibility; end
+
+            def possibility=(_); end
+
+            def requirement; end
+
+            def requirement=(_); end
+
+            def requirement_trees; end
+
+            def requirement_trees=(_); end
+
+            def requirements; end
+
+            def requirements=(_); end
+
+            def self.[](*_); end
+
+            def self.members; end
+          end
+        end
+      end
+
+      class ResolverError
+      end
+
+      module SpecificationProvider
+        def allow_missing?(dependency); end
+
+        def dependencies_for(specification); end
+
+        def name_for(dependency); end
+
+        def name_for_explicit_dependency_source; end
+
+        def name_for_locking_dependency_source; end
+
+        def requirement_satisfied_by?(requirement, activated, spec); end
+
+        def search_for(dependency); end
+
+        def sort_dependencies(dependencies, activated, conflicts); end
+      end
+
+      module UI
+        def after_resolution; end
+
+        def before_resolution; end
+
+        def debug(depth = T.unsafe(nil)); end
+
+        def debug?; end
+
+        def indicate_progress; end
+
+        def output; end
+
+        def progress_rate; end
+      end
+
+      class VersionConflict
+        def conflicts; end
+
+        def initialize(conflicts); end
+      end
+    end
+
+    class RequirementList
+      include Enumerable
+      Elem = type_member(fixed: T.untyped)
+
+      def add(req); end
+
+      def each(&blk); end
+
+      def empty?; end
+
+      def next5; end
+
+      def remove; end
+
+      def size; end
+    end
+
+    class Set
+      def errors; end
+
+      def errors=(errors); end
+
+      def find_all(req); end
+
+      def prefetch(reqs); end
+
+      def prerelease; end
+
+      def prerelease=(prerelease); end
+
+      def remote; end
+
+      def remote=(remote); end
+
+      def remote?; end
+    end
+
+    class SourceSet
+      def add_source_gem(name, source); end
+    end
+
+    class SpecSpecification
+      def initialize(set, spec, source = T.unsafe(nil)); end
+    end
+
+    class Specification
+      def dependencies; end
+
+      def download(options); end
+
+      def fetch_development_dependencies; end
+
+      def full_name; end
+
+      def install(options = T.unsafe(nil)); end
+
+      def installable_platform?; end
+
+      def local?; end
+
+      def name; end
+
+      def platform; end
+
+      def set; end
+
+      def source; end
+
+      def spec; end
+
+      def version; end
+    end
+
+    class Stats
+      PATTERN = T.let(nil, T.untyped)
+
+      def backtracking!; end
+
+      def display; end
+
+      def iteration!; end
+
+      def record_depth(stack); end
+
+      def record_requirements(reqs); end
+
+      def requirement!; end
+    end
+
+    class VendorSet
+      def add_vendor_gem(name, directory); end
+
+      def load_spec(name, version, platform, source); end
+
+      def pretty_print(q); end
+
+      def specs; end
+    end
+
+    class VendorSpecification
+      def ==(other); end
+    end
+  end
+
+  class RuntimeRequirementNotMetError
+    def suggestion; end
+
+    def suggestion=(suggestion); end
+  end
+
+  module Security
+    AlmostNoSecurity = T.let(nil, T.untyped)
+    DIGEST_NAME = T.let(nil, T.untyped)
+    EXTENSIONS = T.let(nil, T.untyped)
+    HighSecurity = T.let(nil, T.untyped)
+    KEY_CIPHER = T.let(nil, T.untyped)
+    KEY_LENGTH = T.let(nil, T.untyped)
+    LowSecurity = T.let(nil, T.untyped)
+    MediumSecurity = T.let(nil, T.untyped)
+    NoSecurity = T.let(nil, T.untyped)
+    ONE_DAY = T.let(nil, T.untyped)
+    ONE_YEAR = T.let(nil, T.untyped)
+    Policies = T.let(nil, T.untyped)
+    SigningPolicy = T.let(nil, T.untyped)
+
+    def self.alt_name_or_x509_entry(certificate, x509_entry); end
+
+    def self.create_cert(subject, key, age = T.unsafe(nil), extensions = T.unsafe(nil), serial = T.unsafe(nil)); end
+
+    def self.create_cert_email(email, key, age = T.unsafe(nil), extensions = T.unsafe(nil)); end
+
+    def self.create_cert_self_signed(subject, key, age = T.unsafe(nil), extensions = T.unsafe(nil), serial = T.unsafe(nil)); end
+
+    def self.create_key(length = T.unsafe(nil), algorithm = T.unsafe(nil)); end
+
+    def self.email_to_name(email_address); end
+
+    def self.re_sign(expired_certificate, private_key, age = T.unsafe(nil), extensions = T.unsafe(nil)); end
+
+    def self.reset; end
+
+    def self.sign(certificate, signing_key, signing_cert, age = T.unsafe(nil), extensions = T.unsafe(nil), serial = T.unsafe(nil)); end
+
+    def self.trust_dir; end
+
+    def self.trusted_certificates(&block); end
+
+    def self.write(pemmable, path, permissions = T.unsafe(nil), passphrase = T.unsafe(nil), cipher = T.unsafe(nil)); end
+
+    class DIGEST_ALGORITHM
+      def initialize(data = T.unsafe(nil)); end
+
+      def self.digest(data); end
+
+      def self.hexdigest(data); end
+    end
+
+    class Exception
+    end
+
+    class KEY_ALGORITHM
+      NO_PADDING = T.let(nil, T.untyped)
+      PKCS1_OAEP_PADDING = T.let(nil, T.untyped)
+      PKCS1_PADDING = T.let(nil, T.untyped)
+      SSLV23_PADDING = T.let(nil, T.untyped)
+
+      def d; end
+
+      def d=(d); end
+
+      def dmp1; end
+
+      def dmp1=(dmp1); end
+
+      def dmq1; end
+
+      def dmq1=(dmq1); end
+
+      def e; end
+
+      def e=(e); end
+
+      def export(*_); end
+
+      def initialize(*_); end
+
+      def iqmp; end
+
+      def iqmp=(iqmp); end
+
+      def n; end
+
+      def n=(n); end
+
+      def p; end
+
+      def p=(p); end
+
+      def params; end
+
+      def private?; end
+
+      def private_decrypt(*_); end
+
+      def private_encrypt(*_); end
+
+      def public?; end
+
+      def public_decrypt(*_); end
+
+      def public_encrypt(*_); end
+
+      def public_key; end
+
+      def q; end
+
+      def q=(q); end
+
+      def set_crt_params(_, _1, _2); end
+
+      def set_factors(_, _1); end
+
+      def set_key(_, _1, _2); end
+
+      def sign_pss(*_); end
+
+      def to_der; end
+
+      def to_pem(*_); end
+
+      def to_s(*_); end
+
+      def to_text; end
+
+      def verify_pss(*_); end
+
+      def self.generate(*_); end
+    end
+
+    class Policy
+      include Gem::UserInteraction
+      include Gem::DefaultUserInteraction
+      include Gem::Text
+
+      def check_cert(signer, issuer, time); end
+
+      def check_chain(chain, time); end
+
+      def check_data(public_key, digest, signature, data); end
+
+      def check_key(signer, key); end
+
+      def check_root(chain, time); end
+
+      def check_trust(chain, digester, trust_dir); end
+
+      def initialize(name, policy = T.unsafe(nil), opt = T.unsafe(nil)); end
+
+      def name; end
+
+      def only_signed; end
+
+      def only_signed=(only_signed); end
+
+      def only_trusted; end
+
+      def only_trusted=(only_trusted); end
+
+      def subject(certificate); end
+
+      def verify(chain, key = T.unsafe(nil), digests = T.unsafe(nil), signatures = T.unsafe(nil), full_name = T.unsafe(nil)); end
+
+      def verify_chain; end
+
+      def verify_chain=(verify_chain); end
+
+      def verify_data; end
+
+      def verify_data=(verify_data); end
+
+      def verify_root; end
+
+      def verify_root=(verify_root); end
+
+      def verify_signatures(spec, digests, signatures); end
+
+      def verify_signer; end
+
+      def verify_signer=(verify_signer); end
+
+      def clean_text(text); end
+
+      def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+      def levenshtein_distance(str1, str2); end
+
+      def min3(a, b, c); end
+
+      def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+      def ui; end
+
+      def ui=(new_ui); end
+
+      def use_ui(new_ui, &block); end
+
+      def alert(statement, question = T.unsafe(nil)); end
+
+      def alert_error(statement, question = T.unsafe(nil)); end
+
+      def alert_warning(statement, question = T.unsafe(nil)); end
+
+      def ask(question); end
+
+      def ask_for_password(prompt); end
+
+      def ask_yes_no(question, default = T.unsafe(nil)); end
+
+      def choose_from_list(question, list); end
+
+      def say(statement = T.unsafe(nil)); end
+
+      def terminate_interaction(exit_code = T.unsafe(nil)); end
+
+      def verbose(msg = T.unsafe(nil)); end
+    end
+
+    class Signer
+      include Gem::UserInteraction
+      include Gem::DefaultUserInteraction
+      include Gem::Text
+      DEFAULT_OPTIONS = T.let(nil, T.untyped)
+
+      def cert_chain; end
+
+      def cert_chain=(cert_chain); end
+
+      def digest_algorithm; end
+
+      def digest_name; end
+
+      def extract_name(cert); end
+
+      def initialize(key, cert_chain, passphrase = T.unsafe(nil), options = T.unsafe(nil)); end
+
+      def key; end
+
+      def key=(key); end
+
+      def load_cert_chain; end
+
+      def options; end
+
+      def re_sign_key(expiration_length: T.unsafe(nil)); end
+
+      def sign(data); end
+
+      def self.re_sign_cert(expired_cert, expired_cert_path, private_key); end
+
+      def clean_text(text); end
+
+      def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+      def levenshtein_distance(str1, str2); end
+
+      def min3(a, b, c); end
+
+      def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+      def ui; end
+
+      def ui=(new_ui); end
+
+      def use_ui(new_ui, &block); end
+
+      def alert(statement, question = T.unsafe(nil)); end
+
+      def alert_error(statement, question = T.unsafe(nil)); end
+
+      def alert_warning(statement, question = T.unsafe(nil)); end
+
+      def ask(question); end
+
+      def ask_for_password(prompt); end
+
+      def ask_yes_no(question, default = T.unsafe(nil)); end
+
+      def choose_from_list(question, list); end
+
+      def say(statement = T.unsafe(nil)); end
+
+      def terminate_interaction(exit_code = T.unsafe(nil)); end
+
+      def verbose(msg = T.unsafe(nil)); end
+    end
+
+    class TrustDir
+      DEFAULT_PERMISSIONS = T.let(nil, T.untyped)
+
+      def cert_path(certificate); end
+
+      def dir; end
+
+      def each_certificate; end
+
+      def initialize(dir, permissions = T.unsafe(nil)); end
+
+      def issuer_of(certificate); end
+
+      def load_certificate(certificate_file); end
+
+      def name_path(name); end
+
+      def trust_cert(certificate); end
+
+      def verify; end
+    end
+  end
+
+  class SilentUI
+    def initialize; end
+  end
+
+  class Source
+    include Comparable
+    FILES = T.let(nil, T.untyped)
+
+    def ==(other); end
+
+    def cache_dir(uri); end
+
+    def dependency_resolver_set; end
+
+    def download(spec, dir = T.unsafe(nil)); end
+
+    def eql?(other); end
+
+    def fetch_spec(name_tuple); end
+
+    def initialize(uri); end
+
+    def load_specs(type); end
+
+    def pretty_print(q); end
+
+    def update_cache?; end
+
+    def uri; end
+
+    class Git
+      def base_dir; end
+
+      def cache; end
+
+      def checkout; end
+
+      def dir_shortref; end
+
+      def download(full_spec, path); end
+
+      def initialize(name, repository, reference, submodules = T.unsafe(nil)); end
+
+      def install_dir; end
+
+      def name; end
+
+      def need_submodules; end
+
+      def reference; end
+
+      def remote; end
+
+      def remote=(remote); end
+
+      def repo_cache_dir; end
+
+      def repository; end
+
+      def rev_parse; end
+
+      def root_dir; end
+
+      def root_dir=(root_dir); end
+
+      def specs; end
+
+      def uri_hash; end
+    end
+
+    class Installed
+      def download(spec, path); end
+
+      def initialize; end
+    end
+
+    class Local
+      def download(spec, cache_dir = T.unsafe(nil)); end
+
+      def fetch_spec(name); end
+
+      def find_gem(gem_name, version = T.unsafe(nil), prerelease = T.unsafe(nil)); end
+
+      def initialize; end
+    end
+
+    class Lock
+      def initialize(source); end
+
+      def wrapped; end
+    end
+
+    class SpecificFile
+      def fetch_spec(name); end
+
+      def initialize(file); end
+
+      def load_specs(*a); end
+
+      def path; end
+
+      def spec; end
+    end
+
+    class Vendor
+      def initialize(path); end
+    end
+  end
+
+  class SourceFetchProblem
+    def error; end
+
+    def exception; end
+
+    def initialize(source, error); end
+
+    def source; end
+
+    def wordy; end
+  end
+
+  class SourceList
+    include Enumerable
+    Elem = type_member(fixed: T.untyped)
+
+    def <<(obj); end
+
+    def ==(other); end
+
+    def clear; end
+
+    def delete(source); end
+
+    def each(&blk); end
+
+    def each_source(&b); end
+
+    def empty?; end
+
+    def first; end
+
+    def include?(other); end
+
+    def replace(other); end
+
+    def sources; end
+
+    def to_a; end
+
+    def to_ary; end
+
+    def self.from(ary); end
+  end
+
+  class SpecFetcher
+    include Gem::UserInteraction
+    include Gem::DefaultUserInteraction
+    include Gem::Text
+
+    def available_specs(type); end
+
+    def detect(type = T.unsafe(nil)); end
+
+    def initialize(sources = T.unsafe(nil)); end
+
+    def latest_specs; end
+
+    def prerelease_specs; end
+
+    def search_for_dependency(dependency, matching_platform = T.unsafe(nil)); end
+
+    def sources; end
+
+    def spec_for_dependency(dependency, matching_platform = T.unsafe(nil)); end
+
+    def specs; end
+
+    def suggest_gems_from_name(gem_name, type = T.unsafe(nil)); end
+
+    def tuples_for(source, type, gracefully_ignore = T.unsafe(nil)); end
+
+    def self.fetcher; end
+
+    def self.fetcher=(fetcher); end
+
+    def clean_text(text); end
+
+    def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def levenshtein_distance(str1, str2); end
+
+    def min3(a, b, c); end
+
+    def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+    def ui; end
+
+    def ui=(new_ui); end
+
+    def use_ui(new_ui, &block); end
+
+    def alert(statement, question = T.unsafe(nil)); end
+
+    def alert_error(statement, question = T.unsafe(nil)); end
+
+    def alert_warning(statement, question = T.unsafe(nil)); end
+
+    def ask(question); end
+
+    def ask_for_password(prompt); end
+
+    def ask_yes_no(question, default = T.unsafe(nil)); end
+
+    def choose_from_list(question, list); end
+
+    def say(statement = T.unsafe(nil)); end
+
+    def terminate_interaction(exit_code = T.unsafe(nil)); end
+
+    def verbose(msg = T.unsafe(nil)); end
+  end
+
+  class SpecificGemNotFoundException
+    def errors; end
+
+    def initialize(name, version, errors = T.unsafe(nil)); end
+
+    def name; end
+
+    def version; end
+  end
+
+  class Specification
+    include Bundler::MatchPlatform
+    include Bundler::GemHelpers
+    extend Gem::Deprecate
+    DateLike = T.let(nil, T.untyped)
+    DateTimeFormat = T.let(nil, T.untyped)
+    INITIALIZE_CODE_FOR_DEFAULTS = T.let(nil, T.untyped)
+
+    def ==(other); end
+
+    def _deprecated_default_executable; end
+
+    def _deprecated_default_executable=(_deprecated_default_executable); end
+
+    def _deprecated_has_rdoc; end
+
+    def _deprecated_has_rdoc=(ignored); end
+
+    def _deprecated_has_rdoc?(*args, &block); end
+
+    def _dump(limit); end
+
+    def abbreviate; end
+
+    def activate; end
+
+    def activate_dependencies; end
+
+    def activated; end
+
+    def activated=(activated); end
+
+    def add_bindir(executables); end
+
+    def add_dependency(gem, *requirements); end
+
+    def add_development_dependency(gem, *requirements); end
+
+    def add_runtime_dependency(gem, *requirements); end
+
+    def add_self_to_load_path; end
+
+    def author; end
+
+    def author=(o); end
+
+    def authors; end
+
+    def authors=(value); end
+
+    def autorequire; end
+
+    def autorequire=(autorequire); end
+
+    def bin_dir; end
+
+    def bin_file(name); end
+
+    def bindir; end
+
+    def bindir=(bindir); end
+
+    def build_args; end
+
+    def build_extensions; end
+
+    def build_info_dir; end
+
+    def build_info_file; end
+
+    def cache_dir; end
+
+    def cache_file; end
+
+    def cert_chain; end
+
+    def cert_chain=(cert_chain); end
+
+    def conficts_when_loaded_with?(list_of_specs); end
+
+    def conflicts; end
+
+    def date; end
+
+    def date=(date); end
+
+    def default_executable(*args, &block); end
+
+    def default_executable=(*args, &block); end
+
+    def default_value(name); end
+
+    def dependencies; end
+
+    def dependent_gems; end
+
+    def dependent_specs; end
+
+    def description; end
+
+    def description=(str); end
+
+    def development_dependencies; end
+
+    def doc_dir(type = T.unsafe(nil)); end
+
+    def email; end
+
+    def email=(email); end
+
+    def encode_with(coder); end
+
+    def eql?(other); end
+
+    def executable; end
+
+    def executable=(o); end
+
+    def executables; end
+
+    def executables=(value); end
+
+    def extensions; end
+
+    def extensions=(extensions); end
+
+    def extra_rdoc_files; end
+
+    def extra_rdoc_files=(files); end
+
+    def file_name; end
+
+    def files; end
+
+    def files=(files); end
+
+    def for_cache; end
+
+    def git_version; end
+
+    def groups; end
+
+    def has_conflicts?; end
+
+    def has_rdoc(*args, &block); end
+
+    def has_rdoc=(*args, &block); end
+
+    def has_rdoc?(*args, &block); end
+
+    def has_test_suite?; end
+
+    def has_unit_tests?; end
+
+    def homepage; end
+
+    def homepage=(homepage); end
+
+    def init_with(coder); end
+
+    def initialize(name = T.unsafe(nil), version = T.unsafe(nil)); end
+
+    def installed_by_version; end
+
+    def installed_by_version=(version); end
+
+    def keep_only_files_and_directories; end
+
+    def lib_files; end
+
+    def license; end
+
+    def license=(o); end
+
+    def licenses; end
+
+    def licenses=(licenses); end
+
+    def load_paths; end
+
+    def location; end
+
+    def location=(location); end
+
+    def mark_version; end
+
+    def metadata; end
+
+    def metadata=(metadata); end
+
+    def method_missing(sym, *a, &b); end
+
+    def missing_extensions?; end
+
+    def name=(name); end
+
+    def name_tuple; end
+
+    def nondevelopment_dependencies; end
+
+    def normalize; end
+
+    def original_name; end
+
+    def original_platform; end
+
+    def original_platform=(original_platform); end
+
+    def platform=(platform); end
+
+    def post_install_message; end
+
+    def post_install_message=(post_install_message); end
+
+    def pretty_print(q); end
+
+    def raise_if_conflicts; end
+
+    def rdoc_options; end
+
+    def rdoc_options=(options); end
+
+    def relative_loaded_from; end
+
+    def relative_loaded_from=(relative_loaded_from); end
+
+    def remote; end
+
+    def remote=(remote); end
+
+    def require_path; end
+
+    def require_path=(path); end
+
+    def require_paths=(val); end
+
+    def required_ruby_version; end
+
+    def required_ruby_version=(req); end
+
+    def required_rubygems_version; end
+
+    def required_rubygems_version=(req); end
+
+    def requirements; end
+
+    def requirements=(req); end
+
+    def reset_nil_attributes_to_default; end
+
+    def rg_extension_dir; end
+
+    def rg_full_gem_path; end
+
+    def rg_loaded_from; end
+
+    def ri_dir; end
+
+    def rubyforge_project=(rubyforge_project); end
+
+    def rubygems_version; end
+
+    def rubygems_version=(rubygems_version); end
+
+    def runtime_dependencies; end
+
+    def sanitize; end
+
+    def sanitize_string(string); end
+
+    def satisfies_requirement?(dependency); end
+
+    def signing_key; end
+
+    def signing_key=(signing_key); end
+
+    def sort_obj; end
+
+    def source; end
+
+    def source=(source); end
+
+    def spec_dir; end
+
+    def spec_file; end
+
+    def spec_name; end
+
+    def specification_version; end
+
+    def specification_version=(specification_version); end
+
+    def summary; end
+
+    def summary=(str); end
+
+    def test_file; end
+
+    def test_file=(file); end
+
+    def test_files; end
+
+    def test_files=(files); end
+
+    def to_gemfile(path = T.unsafe(nil)); end
+
+    def to_ruby; end
+
+    def to_ruby_for_cache; end
+
+    def to_yaml(opts = T.unsafe(nil)); end
+
+    def traverse(trail = T.unsafe(nil), visited = T.unsafe(nil), &block); end
+
+    def validate(packaging = T.unsafe(nil), strict = T.unsafe(nil)); end
+
+    def validate_dependencies; end
+
+    def validate_metadata; end
+
+    def validate_permissions; end
+
+    def version=(version); end
+
+    def yaml_initialize(tag, vals); end
+
+    def self._all; end
+
+    def self._clear_load_cache; end
+
+    def self._latest_specs(specs, prerelease = T.unsafe(nil)); end
+
+    def self._load(str); end
+
+    def self._resort!(specs); end
+
+    def self.add_spec(spec); end
+
+    def self.add_specs(*specs); end
+
+    def self.all; end
+
+    def self.all=(specs); end
+
+    def self.all_names; end
+
+    def self.array_attributes; end
+
+    def self.attribute_names; end
+
+    def self.dirs; end
+
+    def self.dirs=(dirs); end
+
+    def self.each(&blk); end
+
+    def self.each_gemspec(dirs); end
+
+    def self.each_spec(dirs); end
+
+    def self.find_active_stub_by_path(path); end
+
+    def self.find_all_by_full_name(full_name); end
+
+    def self.find_all_by_name(name, *requirements); end
+
+    def self.find_by_name(name, *requirements); end
+
+    def self.find_by_path(path); end
+
+    def self.find_in_unresolved(path); end
+
+    def self.find_in_unresolved_tree(path); end
+
+    def self.find_inactive_by_path(path); end
+
+    def self.from_yaml(input); end
+
+    def self.latest_specs(prerelease = T.unsafe(nil)); end
+
+    def self.load(file); end
+
+    def self.load_defaults; end
+
+    def self.non_nil_attributes; end
+
+    def self.normalize_yaml_input(input); end
+
+    def self.outdated; end
+
+    def self.outdated_and_latest_version; end
+
+    def self.remove_spec(spec); end
+
+    def self.required_attribute?(name); end
+
+    def self.required_attributes; end
+
+    def self.reset; end
+
+    def self.stubs; end
+
+    def self.stubs_for(name); end
+
+    def self.unresolved_deps; end
+  end
+
+  class SpecificationPolicy
+    HOMEPAGE_URI_PATTERN = T.let(nil, T.untyped)
+    LAZY = T.let(nil, T.untyped)
+    LAZY_PATTERN = T.let(nil, T.untyped)
+    METADATA_LINK_KEYS = T.let(nil, T.untyped)
+    SPECIAL_CHARACTERS = T.let(nil, T.untyped)
+    VALID_NAME_PATTERN = T.let(nil, T.untyped)
+    VALID_URI_PATTERN = T.let(nil, T.untyped)
+
+    def initialize(specification); end
+
+    def packaging; end
+
+    def packaging=(packaging); end
+
+    def validate(strict = T.unsafe(nil)); end
+
+    def validate_dependencies; end
+
+    def validate_metadata; end
+
+    def validate_permissions; end
+  end
+
+  class StreamUI
+    extend Gem::Deprecate
+
+    def _deprecated_debug(statement); end
+
+    def _gets_noecho; end
+
+    def alert(statement, question = T.unsafe(nil)); end
+
+    def alert_error(statement, question = T.unsafe(nil)); end
+
+    def alert_warning(statement, question = T.unsafe(nil)); end
+
+    def ask(question); end
+
+    def ask_for_password(question); end
+
+    def ask_yes_no(question, default = T.unsafe(nil)); end
+
+    def backtrace(exception); end
+
+    def choose_from_list(question, list); end
+
+    def close; end
+
+    def debug(*args, &block); end
+
+    def download_reporter(*args); end
+
+    def errs; end
+
+    def initialize(in_stream, out_stream, err_stream = T.unsafe(nil), usetty = T.unsafe(nil)); end
+
+    def ins; end
+
+    def outs; end
+
+    def progress_reporter(*args); end
+
+    def require_io_console; end
+
+    def say(statement = T.unsafe(nil)); end
+
+    def terminate_interaction(status = T.unsafe(nil)); end
+
+    def tty?; end
+  end
+
+  class StubSpecification
+    def build_extensions; end
+
+    def extensions; end
+
+    def initialize(filename, base_dir, gems_dir, default_gem); end
+
+    def missing_extensions?; end
+
+    def valid?; end
+
+    def self.default_gemspec_stub(filename, base_dir, gems_dir); end
+
+    def self.gemspec_stub(filename, base_dir, gems_dir); end
+
+    class StubLine
+      def extensions; end
+
+      def full_name; end
+
+      def initialize(data, extensions); end
+
+      def name; end
+
+      def platform; end
+
+      def require_paths; end
+
+      def version; end
+    end
+  end
+
+  class SystemExitException
+    def exit_code; end
+
+    def exit_code=(exit_code); end
+
+    def initialize(exit_code); end
+  end
+
+  module Text
+    def clean_text(text); end
+
+    def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def levenshtein_distance(str1, str2); end
+
+    def min3(a, b, c); end
+
+    def truncate_text(text, description, max_length = T.unsafe(nil)); end
+  end
+
+  class UninstallError
+    def spec; end
+
+    def spec=(spec); end
+  end
+
+  class UnsatisfiableDependencyError
+    def dependency; end
+
+    def errors; end
+
+    def errors=(errors); end
+
+    def initialize(dep, platform_mismatch = T.unsafe(nil)); end
+
+    def name; end
+
+    def version; end
+  end
+
+  class UriFormatter
+    def escape; end
+
+    def initialize(uri); end
+
+    def normalize; end
+
+    def unescape; end
+
+    def uri; end
+  end
+
+  module UserInteraction
+    include Gem::DefaultUserInteraction
+    include Gem::Text
+
+    def alert(statement, question = T.unsafe(nil)); end
+
+    def alert_error(statement, question = T.unsafe(nil)); end
+
+    def alert_warning(statement, question = T.unsafe(nil)); end
+
+    def ask(question); end
+
+    def ask_for_password(prompt); end
+
+    def ask_yes_no(question, default = T.unsafe(nil)); end
+
+    def choose_from_list(question, list); end
+
+    def say(statement = T.unsafe(nil)); end
+
+    def terminate_interaction(exit_code = T.unsafe(nil)); end
+
+    def verbose(msg = T.unsafe(nil)); end
+
+    def clean_text(text); end
+
+    def format_text(text, wrap, indent = T.unsafe(nil)); end
+
+    def levenshtein_distance(str1, str2); end
+
+    def min3(a, b, c); end
+
+    def truncate_text(text, description, max_length = T.unsafe(nil)); end
+
+    def ui; end
+
+    def ui=(new_ui); end
+
+    def use_ui(new_ui, &block); end
+  end
+
+  module Util
+    def self.glob_files_in_dir(glob, base_path); end
+
+    def self.gunzip(data); end
+
+    def self.gzip(data); end
+
+    def self.inflate(data); end
+
+    def self.popen(*command); end
+
+    def self.silent_system(*command); end
+
+    def self.traverse_parents(directory, &block); end
+  end
+
+  class Version
+    def _segments; end
+
+    def _split_segments; end
+
+    def _version; end
+
+    def approximate_recommendation; end
+
+    def bump; end
+
+    def canonical_segments; end
+
+    def encode_with(coder); end
+
+    def eql?(other); end
+
+    def init_with(coder); end
+
+    def marshal_dump; end
+
+    def marshal_load(array); end
+
+    def prerelease?; end
+
+    def pretty_print(q); end
+
+    def release; end
+
+    def segments; end
+
+    def to_yaml_properties; end
+
+    def version; end
+
+    def yaml_initialize(tag, map); end
+
+    def self.correct?(version); end
+
+    def self.create(input); end
+
+    def self.new(version); end
+  end
+end
+
+Gem::UnsatisfiableDepedencyError = Gem::UnsatisfiableDependencyError
+Gem::Ext::ExtConfBuilder::FileEntry = FileUtils::Entry_
+Gem::Version::Requirement = Gem::Requirement
+Gem::Resolver::DependencyConflict = Gem::Resolver::Conflict
diff --git a/sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi b/sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi
new file mode 100644
index 0000000..22474d7
--- /dev/null
+++ b/sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi
@@ -0,0 +1,111 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi sorbet-typed
+#
+# If you would like to make changes to this file, great! Please upstream any changes you make here:
+#
+#   https://github.com/sorbet/sorbet-typed/edit/master/lib/ruby/all/open3.rbi
+#
+# typed: strong
+
+module Open3
+  sig do
+    params(
+      cmd: T.any(String, T::Array[String]),
+      opts: T.untyped,
+      block: T.nilable(T.proc.params(stdin: IO, stdout: IO, stderr: IO, wait_thr: Process::Waiter).void)
+    ).returns([IO, IO, IO, Process::Waiter])
+  end
+  def self.popen3(*cmd, **opts, &block); end
+
+  sig do
+    params(
+      cmd: T.any(String, T::Array[String]),
+      opts: T.untyped,
+      block: T.nilable(T.proc.params(stdin: IO, stdout: IO, wait_thr: Process::Waiter).void)
+    ).returns([IO, IO, Process::Waiter])
+  end
+  def self.popen2(*cmd, **opts, &block); end
+
+  sig do
+    params(
+      cmd: T.any(String, T::Array[String]),
+      opts: T.untyped,
+      block: T.nilable(T.proc.params(stdin: IO, stdout_and_stderr: IO, wait_thr: Process::Waiter).void)
+    ).returns([IO, IO, Process::Waiter])
+  end
+  def self.popen2e(*cmd, **opts, &block); end
+
+  sig do
+    params(
+      cmd: T.any(String, T::Array[String]),
+      stdin_data: T.nilable(String),
+      binmode: T.any(FalseClass, TrueClass),
+      opts: T::Hash[Symbol, T.untyped]
+    ).returns([String, String, Process::Status])
+  end
+  def self.capture3(*cmd, stdin_data: '', binmode: false, **opts); end
+
+  sig do
+    params(
+      cmd: T.any(String, T::Array[String]),
+      stdin_data: T.nilable(String),
+      binmode: T.any(FalseClass, TrueClass),
+      opts: T::Hash[Symbol, T.untyped]
+    ).returns([String, Process::Status])
+  end
+  def self.capture2(*cmd, stdin_data: nil, binmode: false, **opts); end
+
+  sig do
+    params(
+      cmd: T.any(String, T::Array[String]),
+      stdin_data: T.nilable(String),
+      binmode: T.any(FalseClass, TrueClass),
+      opts: T::Hash[Symbol, T.untyped]
+    ).returns([String, Process::Status])
+  end
+  def self.capture2e(*cmd, stdin_data: nil, binmode: false, **opts); end
+
+  sig do
+    params(
+      cmds: T.any(String, T::Array[String]),
+      opts: T.untyped,
+      block: T.nilable(T.proc.params(first_stdin: IO, last_stdout: IO, wait_threads: T::Array[Process::Waiter]).void)
+    ).returns([IO, IO, T::Array[Process::Waiter]])
+  end
+  def self.pipeline_rw(*cmds, **opts, &block); end
+
+  sig do
+    params(
+      cmds: T.any(String, T::Array[String]),
+      opts: T.untyped,
+      block: T.nilable(T.proc.params(last_stdout: IO, wait_threads: T::Array[Process::Waiter]).void)
+    ).returns([IO, T::Array[Process::Waiter]])
+  end
+  def self.pipeline_r(*cmds, **opts, &block); end
+
+  sig do
+    params(
+      cmds: T.any(String, T::Array[String]),
+      opts: T.untyped,
+      block: T.nilable(T.proc.params(first_stdin: IO, wait_threads: T::Array[Process::Waiter]).void)
+    ).returns([IO, T::Array[Process::Waiter]])
+  end
+  def self.pipeline_w(*cmds, **opts, &block); end
+
+  sig do
+    params(
+      cmds: T.any(String, T::Array[String]),
+      opts: T.untyped,
+      block: T.nilable(T.proc.params(wait_threads: T::Array[Process::Waiter]).void)
+    ).returns(T::Array[Process::Waiter])
+  end
+  def self.pipeline_start(*cmds, **opts, &block); end
+
+  sig do
+    params(
+      cmds: T.any(String, T::Array[String]),
+      opts: T.untyped
+    ).returns(T::Array[Process::Status])
+  end
+  def self.pipeline(*cmds, **opts); end
+end
diff --git a/sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi b/sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi
new file mode 100644
index 0000000..487e803
--- /dev/null
+++ b/sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi
@@ -0,0 +1,543 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi sorbet-typed
+#
+# If you would like to make changes to this file, great! Please upstream any changes you make here:
+#
+#   https://github.com/sorbet/sorbet-typed/edit/master/lib/ruby/all/resolv.rbi
+#
+# typed: strong
+
+class Resolv
+  sig { params(name: String).returns(String) }
+  def self.getaddress(name); end
+
+  sig { params(name: String).returns(T::Array[String]) }
+  def self.getaddresses(name); end
+
+  sig { params(name: String, block: T.proc.params(address: String).void).void }
+  def self.each_address(name, &block); end
+
+  sig { params(address: String).returns(String) }
+  def self.getname(address); end
+
+  sig { params(address: String).returns(T::Array[String]) }
+  def self.getnames(address); end
+
+  sig { params(address: String, proc: T.proc.params(name: String).void).void }
+  def self.each_name(address, &proc); end
+
+  sig { params(resolvers: [Hosts, DNS]).void }
+  def initialize(resolvers=[Hosts.new, DNS.new]); end
+
+  sig { params(name: String).returns(String) }
+  def getaddress(name); end
+
+  sig { params(name: String).returns(T::Array[String]) }
+  def getaddresses(name); end
+
+  sig { params(name: String, block: T.proc.params(address: String).void).void }
+  def each_address(name, &block); end
+
+  sig { params(address: String).returns(String) }
+  def getname(address); end
+
+  sig { params(address: String).returns(T::Array[String]) }
+  def getnames(address); end
+
+  sig { params(address: String, proc: T.proc.params(name: String).void).void }
+  def each_name(address, &proc); end
+
+  class ResolvError < StandardError; end
+  class ResolvTimeout < Timeout::Error; end
+
+  class Hosts
+    DefaultFileName = T.let(T.unsafe(nil), String)
+
+    sig { params(filename: String).void }
+    def initialize(filename = DefaultFileName); end
+
+    sig { params(name: String).returns(String) }
+    def getaddress(name); end
+
+    sig { params(name: String).returns(T::Array[String]) }
+    def getaddresses(name); end
+
+    sig { params(name: String, block: T.proc.params(address: String).void).void }
+    def each_address(name, &block); end
+
+    sig { params(address: String).returns(String) }
+    def getname(address); end
+
+    sig { params(address: String).returns(T::Array[String]) }
+    def getnames(address); end
+
+    sig { params(address: String, proc: T.proc.params(name: String).void).void }
+    def each_name(address, &proc); end
+  end
+
+  class DNS
+    Port = T.let(T.unsafe(nil), Integer)
+
+    UDPSize = T.let(T.unsafe(nil), Integer)
+
+    sig do
+      params(
+        config_info: T.any(
+          NilClass,
+          String,
+          { nameserver: T.any(String, T::Array[String]), search: T::Array[String], ndots: Integer },
+          { nameserver_port: T::Array[[String, Integer]], search: T::Array[String], ndots: Integer }
+        )
+      ).returns(Resolv::DNS)
+    end
+    def self.open(config_info = nil); end
+
+    sig do
+      params(
+        config_info: T.any(
+          NilClass,
+          String,
+          { nameserver: T.any(String, T::Array[String]), search: T::Array[String], ndots: Integer },
+          { nameserver_port: T::Array[[String, Integer]], search: T::Array[String], ndots: Integer }
+        )
+      ).void
+    end
+    def initialize(config_info = nil); end
+
+    sig { params(values: T.any(NilClass, Integer, T::Array[Integer])).void }
+    def timeouts=(values); end
+
+    sig { void }
+    def close; end
+
+    sig { params(name: String).returns(String) }
+    def getaddress(name); end
+
+    sig { params(name: String).returns(T::Array[String]) }
+    def getaddresses(name); end
+
+    sig { params(name: String, block: T.proc.params(address: String).void).void }
+    def each_address(name, &block); end
+
+    sig { params(address: String).returns(String) }
+    def getname(address); end
+
+    sig { params(address: String).returns(T::Array[String]) }
+    def getnames(address); end
+
+    sig { params(address: String, proc: T.proc.params(name: String).void).void }
+    def each_name(address, &proc); end
+
+    sig do
+      params(
+        name: T.any(String, Resolv::DNS::Name),
+        typeclass: T.class_of(Resolv::DNS::Resource)
+      ).returns(Resolv::DNS::Resource)
+    end
+    def getresource(name, typeclass); end
+
+    sig do
+      params(
+        name: T.any(String, Resolv::DNS::Name),
+        typeclass: T.class_of(Resolv::DNS::Resource)
+      ).returns(T::Array[Resolv::DNS::Resource])
+    end
+    def getresources(name, typeclass); end
+
+    sig do
+      params(
+        name: T.any(String, Resolv::DNS::Name),
+        typeclass: T.class_of(Resolv::DNS::Resource),
+        proc: T.proc.params(resource: Resolv::DNS::Resource).void
+      ).void
+    end
+    def each_resource(name, typeclass, &proc); end
+
+    class DecodeError < StandardError; end
+    class EncodeError < StandardError; end
+
+    class Name
+      sig { params(arg: T.any(String, Resolv::DNS::Name)).returns(Resolv::DNS::Name) }
+      def self.create(arg); end
+
+      sig { params(labels: T::Array[String], absolute: T.any(FalseClass, TrueClass)).void }
+      def initialize(labels, absolute=true); end
+
+      sig { returns(T.any(FalseClass, TrueClass)) }
+      def absolute?; end
+
+      sig { params(other: Resolv::DNS::Name).returns(T.any(FalseClass, TrueClass)) }
+      def subdomain_of?(other); end
+    end
+
+    class Query; end
+
+    class Resource < Query
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :ttl
+
+      sig { void }
+      def initialize
+        @ttl = T.let(T.unsafe(nil), T.nilable(Integer))
+      end
+
+      class Generic < Resource
+        sig { params(data: T.untyped).void }
+        def initialize(data)
+          @data = T.let(T.unsafe(nil), T.untyped)
+        end
+
+        sig { returns(T.untyped) }
+        attr_reader :data
+      end
+
+      class DomainName < Resource
+        sig { params(name: String).void }
+        def initialize(name)
+          @name = T.let(T.unsafe(nil), String)
+        end
+
+        sig { returns(String) }
+        attr_reader :name
+      end
+
+      class NS < DomainName; end
+
+      class CNAME < DomainName; end
+
+      class SOA < Resource
+        sig do
+          params(
+            mname: String,
+            rname: String,
+            serial: Integer,
+            refresh: Integer,
+            retry_: Integer,
+            expire: Integer,
+            minimum: Integer
+          ).void
+        end
+        def initialize(mname, rname, serial, refresh, retry_, expire, minimum)
+          @mname = T.let(T.unsafe(nil), String)
+          @rname = T.let(T.unsafe(nil), String)
+          @serial = T.let(T.unsafe(nil), Integer)
+          @refresh = T.let(T.unsafe(nil), Integer)
+          @retry = T.let(T.unsafe(nil), Integer)
+          @expire = T.let(T.unsafe(nil), Integer)
+          @minimum = T.let(T.unsafe(nil), Integer)
+        end
+
+        sig { returns(String) }
+        attr_reader :mname
+
+        sig { returns(String) }
+        attr_reader :rname
+
+        sig { returns(Integer) }
+        attr_reader :serial
+
+        sig { returns(Integer) }
+        attr_reader :refresh
+
+        sig { returns(Integer) }
+        attr_reader :retry
+
+        sig { returns(Integer) }
+        attr_reader :expire
+
+        sig { returns(Integer) }
+        attr_reader :minimum
+      end
+
+      class PTR < DomainName; end
+
+      class HINFO < Resource
+        sig { params(cpu: String, os: String).void }
+        def initialize(cpu, os)
+          @cpu = T.let(T.unsafe(nil), String)
+          @os = T.let(T.unsafe(nil), String)
+        end
+
+        sig { returns(String) }
+        attr_reader :cpu
+
+        sig { returns(String) }
+        attr_reader :os
+      end
+
+      class MINFO < Resource
+        sig { params(rmailbx: String, emailbx: String).void }
+        def initialize(rmailbx, emailbx)
+          @rmailbx = T.let(T.unsafe(nil), String)
+          @emailbx = T.let(T.unsafe(nil), String)
+        end
+
+        sig { returns(String) }
+        attr_reader :rmailbx
+
+        sig { returns(String) }
+        attr_reader :emailbx
+      end
+
+      class MX < Resource
+        sig { params(preference: Integer, exchange: String).void }
+        def initialize(preference, exchange)
+          @preference = T.let(T.unsafe(nil), Integer)
+          @exchange = T.let(T.unsafe(nil), String)
+        end
+
+        sig { returns(Integer) }
+        attr_reader :preference
+
+        sig { returns(String) }
+        attr_reader :exchange
+      end
+
+      class TXT < Resource
+        sig { params(first_string: String, rest_strings: String).void }
+        def initialize(first_string, *rest_strings)
+          @strings = T.let(T.unsafe(nil), T::Array[String])
+        end
+
+        sig { returns(T::Array[String]) }
+        attr_reader :strings
+
+        sig { returns(String) }
+        def data; end
+      end
+
+      class LOC < Resource
+        sig do
+          params(
+            version: String,
+            ssize: T.any(String, Resolv::LOC::Size),
+            hprecision: T.any(String, Resolv::LOC::Size),
+            vprecision: T.any(String, Resolv::LOC::Size),
+            latitude: T.any(String, Resolv::LOC::Coord),
+            longitude: T.any(String, Resolv::LOC::Coord),
+            altitude: T.any(String, Resolv::LOC::Alt)
+          ).void
+        end
+        def initialize(version, ssize, hprecision, vprecision, latitude, longitude, altitude)
+          @version = T.let(T.unsafe(nil), String)
+          @ssize = T.let(T.unsafe(nil), Resolv::LOC::Size)
+          @hprecision = T.let(T.unsafe(nil), Resolv::LOC::Size)
+          @vprecision = T.let(T.unsafe(nil), Resolv::LOC::Size)
+          @latitude = T.let(T.unsafe(nil), Resolv::LOC::Coord)
+          @longitude = T.let(T.unsafe(nil), Resolv::LOC::Coord)
+          @altitude = T.let(T.unsafe(nil), Resolv::LOC::Alt)
+        end
+
+        sig { returns(String) }
+        attr_reader :version
+
+        sig { returns(Resolv::LOC::Size) }
+        attr_reader :ssize
+
+        sig { returns(Resolv::LOC::Size) }
+        attr_reader :hprecision
+
+        sig { returns(Resolv::LOC::Size) }
+        attr_reader :vprecision
+
+        sig { returns(Resolv::LOC::Coord) }
+        attr_reader :latitude
+
+        sig { returns(Resolv::LOC::Coord) }
+        attr_reader :longitude
+
+        sig { returns(Resolv::LOC::Alt) }
+        attr_reader :altitude
+      end
+
+      class ANY < Query; end
+
+      module IN
+        class A < Resource
+          sig { params(address: String).void }
+          def initialize(address)
+            @address = T.let(T.unsafe(nil), Resolv::IPv4)
+          end
+
+          sig { returns(Resolv::IPv4) }
+          attr_reader :address
+        end
+
+        class WKS < Resource
+          sig { params(address: String, protocol: Integer, bitmap: String).void }
+          def initialize(address, protocol, bitmap)
+            @address = T.let(T.unsafe(nil), Resolv::IPv4)
+            @protocol = T.let(T.unsafe(nil), Integer)
+            @bitmap = T.let(T.unsafe(nil), String)
+          end
+
+          sig { returns(Resolv::IPv4) }
+          attr_reader :address
+
+          sig { returns(Integer) }
+          attr_reader :protocol
+
+          sig { returns(String) }
+          attr_reader :bitmap
+        end
+
+        class AAAA < Resource
+          sig { params(address: String).void }
+          def initialize(address)
+            @address = T.let(T.unsafe(nil), Resolv::IPv6)
+          end
+
+          sig { returns(Resolv::IPv6) }
+          attr_reader :address
+        end
+
+        class SRV < Resource
+          # Create a SRV resource record.
+          #
+          # See the documentation for #priority, #weight, #port and #target
+          # for +priority+, +weight+, +port and +target+ respectively.
+
+          sig do
+            params(
+              priority: T.any(Integer, String),
+              weight: T.any(Integer, String),
+              port: T.any(Integer, String),
+              target: T.any(String, Resolv::DNS::Name)
+            ).void
+          end
+          def initialize(priority, weight, port, target)
+            @priority = T.let(T.unsafe(nil), Integer)
+            @weight = T.let(T.unsafe(nil), Integer)
+            @port = T.let(T.unsafe(nil), Integer)
+            @target = T.let(T.unsafe(nil), Resolv::DNS::Name)
+          end
+
+          sig { returns(Integer) }
+          attr_reader :priority
+
+          sig { returns(Integer) }
+          attr_reader :weight
+
+          sig { returns(Integer) }
+          attr_reader :port
+
+          sig { returns(Resolv::DNS::Name) }
+          attr_reader :target
+        end
+      end
+    end
+  end
+
+  class IPv4
+    Regex256 = T.let(T.unsafe(nil), Regexp)
+    Regex = T.let(T.unsafe(nil), Regexp)
+
+    sig { params(arg: T.any(String, Resolv::IPv4)).returns(Resolv::IPv4) }
+    def self.create(arg); end
+
+    sig { params(address: String).void }
+    def initialize(address)
+      @address = T.let(T.unsafe(nil), String)
+    end
+
+    sig { returns(String) }
+    attr_reader :address
+
+    sig { returns(DNS::Name) }
+    def to_name; end
+  end
+
+  class IPv6
+    Regex_8Hex = T.let(T.unsafe(nil), Regexp)
+    Regex_CompressedHex = T.let(T.unsafe(nil), Regexp)
+    Regex_6Hex4Dec = T.let(T.unsafe(nil), Regexp)
+    Regex_CompressedHex4Dec = T.let(T.unsafe(nil), Regexp)
+    Regex = T.let(T.unsafe(nil), Regexp)
+
+    sig { params(arg: T.any(String, Resolv::IPv6)).returns(Resolv::IPv6) }
+    def self.create(arg); end
+
+    sig { params(address: String).void }
+    def initialize(address)
+      @address = T.let(T.unsafe(nil), String)
+    end
+
+    sig { returns(String) }
+    attr_reader :address
+
+    sig { returns(DNS::Name) }
+    def to_name; end
+  end
+
+  class MDNS < DNS
+    Port = T.let(T.unsafe(nil), Integer)
+    AddressV4 = T.let(T.unsafe(nil), String)
+    AddressV6 = T.let(T.unsafe(nil), String)
+    Addresses = T.let(T.unsafe(nil), [[String, Integer], [String, Integer]])
+
+    sig do
+      params(
+        config_info: T.any(
+          NilClass,
+          { nameserver: T.any(String, T::Array[String]), search: T::Array[String], ndots: Integer },
+          { nameserver_port: T::Array[[String, Integer]], search: T::Array[String], ndots: Integer }
+        )
+      ).void
+    end
+    def initialize(config_info = nil); end
+  end
+
+  module LOC
+    class Size
+      Regex = T.let(T.unsafe(nil), Regexp)
+
+      sig { params(arg: T.any(String, Resolv::LOC::Size)).returns(Resolv::LOC::Size) }
+      def self.create(arg); end
+
+      sig { params(scalar: String).void }
+      def initialize(scalar)
+        @scalar = T.let(T.unsafe(nil), String)
+      end
+
+      sig { returns(String) }
+      attr_reader :scalar
+    end
+
+    class Coord
+      Regex = T.let(T.unsafe(nil), Regexp)
+
+      sig { params(arg: T.any(String, Resolv::LOC::Coord)).returns(Resolv::LOC::Coord) }
+      def self.create(arg); end
+
+      sig { params(coordinates: String, orientation: T.enum(%w[lat lon])).void }
+      def initialize(coordinates, orientation)
+        @coordinates = T.let(T.unsafe(nil), String)
+        @orientation = T.let(T.unsafe(nil), T.enum(%w[lat lon]))
+      end
+
+      sig { returns(String) }
+      attr_reader :coordinates
+
+      sig { returns(T.enum(%w[lat lon])) }
+      attr_reader :orientation
+    end
+
+    class Alt
+      Regex = T.let(T.unsafe(nil), Regexp)
+
+      sig { params(arg: T.any(String, Resolv::LOC::Alt)).returns(Resolv::LOC::Alt) }
+      def self.create(arg); end
+
+      sig { params(altitude: String).void }
+      def initialize(altitude)
+        @altitude = T.let(T.unsafe(nil), String)
+      end
+
+      sig { returns(String) }
+      attr_reader :altitude
+    end
+  end
+
+  DefaultResolver = T.let(T.unsafe(nil), Resolv)
+  AddressRegex = T.let(T.unsafe(nil), Regexp)
+end
diff --git a/spec/daemon_spec.rb b/spec/daemon_spec.rb
index fb3ff5d..9b6c8a4 100644
--- a/spec/daemon_spec.rb
+++ b/spec/daemon_spec.rb
@@ -1,3 +1,4 @@
+# typed: false
 require 'spec_helper'
 
 describe Dyndnsd::Daemon do
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index e766e4f..d5da226 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -1,3 +1,4 @@
+# typed: strong
 
 require 'rubygems'
 require 'bundler/setup'
diff --git a/spec/support/dummy_database.rb b/spec/support/dummy_database.rb
index b67a96d..45fb0da 100644
--- a/spec/support/dummy_database.rb
+++ b/spec/support/dummy_database.rb
@@ -1,3 +1,4 @@
+# typed: true
 
 require 'forwardable'
 
diff --git a/spec/support/dummy_updater.rb b/spec/support/dummy_updater.rb
index ca33cc4..926a6c8 100644
--- a/spec/support/dummy_updater.rb
+++ b/spec/support/dummy_updater.rb
@@ -1,3 +1,4 @@
+# typed: true
 
 module Dyndnsd
   module Updater