persistent-dmnd 2.0.2 → 2.0.3

data/sorbet/rbi/hidden-definitions/hidden.rbi

@@ -5,21 +5,7 @@
 
 class Array
   include ::JSON::Ext::Generator::GeneratorMethods::Array
-  def bsearch(); end
-
-  def bsearch_index(); end
-
-  def collect!(); end
-
-  def dig(*_); end
-
-  def filter!(); end
-
-  def flatten!(*_); end
-
-  def pack(*_); end
-
-  def replace(_); end
+  def deconstruct(); end
 
   def shelljoin(); end
 
@@ -39,12 +25,11 @@ 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
+  def self.interpret_loosely(_); end
 end
 
 class Binding
@@ -53,6 +38,37 @@ class Binding
   def irb(); end
 end
 
+class Bundler::APIResponseInvalidDependenciesError
+  def status_code(); end
+end
+
+class Bundler::APIResponseInvalidDependenciesError
+end
+
+class Bundler::Definition
+  def dependencies_for(groups); end
+
+  def most_specific_locked_platform(); end
+
+  def requested_dependencies(); end
+end
+
+class Bundler::DepProxy
+  def clone(); end
+end
+
+class Bundler::DepProxy
+  def self.get_proxy(dep, platform); end
+end
+
+class Bundler::Dependency
+  def branch(); end
+
+  def expanded_platforms(); end
+
+  def git(); end
+end
+
 Bundler::Deprecate = Gem::Deprecate
 
 class Bundler::Env
@@ -66,8 +82,14 @@ class Bundler::Env
   def self.write(io); end
 end
 
-class Bundler::FeatureFlag
-  def github_https?(); end
+class Bundler::EnvironmentPreserver
+  def replace_with_backup(); end
+end
+
+class Bundler::EnvironmentPreserver
+  def self.env_to_hash(env); end
+
+  def self.from_env(); end
 end
 
 class Bundler::Fetcher
@@ -202,6 +224,12 @@ class Bundler::Fetcher::SSLError
   def initialize(msg=T.unsafe(nil)); end
 end
 
+class Bundler::Fetcher::TooManyRequestsError
+end
+
+class Bundler::Fetcher::TooManyRequestsError
+end
+
 class Bundler::Fetcher
   def self.api_timeout(); end
 
@@ -220,6 +248,20 @@ class Bundler::Fetcher
   def self.redirect_limit=(redirect_limit); end
 end
 
+module Bundler::FileUtils
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::FileUtils::Entry_
+  def link(dest); end
+end
+
+module Bundler::FileUtils
+  def self.cp_lr(src, dest, noop: T.unsafe(nil), verbose: T.unsafe(nil), dereference_root: T.unsafe(nil), remove_destination: T.unsafe(nil)); end
+
+  def self.link_entry(src, dest, dereference_root=T.unsafe(nil), remove_destination=T.unsafe(nil)); end
+end
+
 class Bundler::GemHelper
   def allowed_push_host(); end
 
@@ -235,6 +277,12 @@ class Bundler::GemHelper
 
   def committed?(); end
 
+  def current_branch(); end
+
+  def default_remote(); end
+
+  def gem_command(); end
+
   def gem_key(); end
 
   def gem_push?(); end
@@ -261,10 +309,14 @@ class Bundler::GemHelper
 
   def sh(cmd, &block); end
 
-  def sh_with_code(cmd, &block); end
+  def sh_with_input(cmd); end
+
+  def sh_with_status(cmd, &block); end
 
   def spec_path(); end
 
+  def tag_prefix=(tag_prefix); end
+
   def tag_version(); end
 
   def version(); end
@@ -280,12 +332,20 @@ class Bundler::GemHelper
   def self.instance(); end
 
   def self.instance=(instance); end
+
+  def self.tag_prefix=(prefix); end
 end
 
-class Bundler::GemRemoteFetcher
+class Bundler::GemHelpers::PlatformMatch
+  def self.specificity_score(spec_platform, user_platform); end
 end
 
-class Bundler::GemRemoteFetcher
+module Bundler::GemHelpers
+  def self.local_platform(); end
+
+  def self.same_deps(spec, exemplary_spec); end
+
+  def self.same_specificity(platform, spec, exemplary_spec); end
 end
 
 class Bundler::GemVersionPromoter
@@ -373,7 +433,7 @@ end
 class Bundler::Installer
   def generate_bundler_executable_stubs(spec, options=T.unsafe(nil)); end
 
-  def generate_standalone_bundler_executable_stubs(spec); end
+  def generate_standalone_bundler_executable_stubs(spec, options=T.unsafe(nil)); end
 
   def initialize(root, definition); end
 
@@ -390,12 +450,14 @@ class Bundler::Installer
   def self.install(root, definition, options=T.unsafe(nil)); end
 end
 
-class Bundler::Molinillo::DependencyGraph
-  include ::Enumerable
+class Bundler::LazySpecification
+  def eql?(other); end
+
+  def platform_string(); end
 end
 
-class Bundler::Molinillo::DependencyGraph::Log
-  extend ::Enumerable
+module Bundler::Molinillo::SpecificationProvider
+  def dependencies_equal?(dependencies, other_dependencies); end
 end
 
 module Bundler::Plugin::API::Source
@@ -474,6 +536,14 @@ module Bundler::Plugin::Events
   GEM_BEFORE_INSTALL_ALL = ::T.let(nil, ::T.untyped)
 end
 
+class Bundler::Plugin::Index
+  def installed_plugins(); end
+
+  def plugin_commands(plugin); end
+
+  def unregister_plugin(name); end
+end
+
 class Bundler::Plugin::Index::CommandConflict
   def initialize(plugin, commands); end
 end
@@ -516,6 +586,12 @@ end
 class Bundler::Plugin::SourceList
 end
 
+module Bundler::Plugin
+  def self.list(); end
+
+  def self.uninstall(names, options); end
+end
+
 class Bundler::ProcessLock
 end
 
@@ -523,6 +599,26 @@ class Bundler::ProcessLock
   def self.lock(bundle_path=T.unsafe(nil)); end
 end
 
+class Bundler::Resolver
+  include ::Bundler::GemHelpers
+end
+
+class Bundler::Resolver::SpecGroup
+  def activate_all_platforms!(); end
+
+  def activated_platforms(); end
+
+  def activated_platforms=(activated_platforms); end
+
+  def partitioned_dependency_names_for_activated_platforms(); end
+
+  def sorted_activated_platforms(); end
+end
+
+class Bundler::Resolver::SpecGroup
+  def self.create_for(specs, all_platforms, specific_platform); end
+end
+
 class Bundler::Retry
   def attempt(&block); end
 
@@ -551,11 +647,32 @@ class Bundler::Retry
   def self.default_retries(); end
 end
 
-class Bundler::RubyGemsGemInstaller
-  def initialize(gem, options=T.unsafe(nil)); end
-end
+class Bundler::RubygemsIntegration
+  def add_default_gems_to(specs); end
+
+  def add_to_load_path(paths); end
+
+  def all_specs(); end
+
+  def backport_ext_builder_monitor(); end
+
+  def correct_for_windows_path(path); end
+
+  def default_stubs(); end
+
+  def find_name(name); end
+
+  def gem_remote_fetcher(); end
+
+  def load_env_plugins(); end
+
+  def plain_specs(); end
+
+  def plain_specs=(specs); end
+
+  def stub_rubygems(specs); end
 
-class Bundler::RubyGemsGemInstaller
+  def use_gemdeps(gemfile); end
 end
 
 class Bundler::Settings::Mirror
@@ -617,1967 +734,3300 @@ class Bundler::Settings::Validator
   def self.validate!(key, value, settings); end
 end
 
+class Bundler::Source::Git
+  def glob(); end
+
+  def local?(); end
+end
+
 class Bundler::SpecSet
   include ::Enumerable
 end
 
-class Bundler::UI::Shell
-  def add_color(string, *color); end
-
-  def ask(msg); end
+class Bundler::StubSpecification
+  def default_gem?(); end
 
-  def confirm(msg, newline=T.unsafe(nil)); end
+  def extensions(); end
 
-  def debug(msg, newline=T.unsafe(nil)); end
+  def gem_build_complete_path(); end
+end
 
-  def debug?(); end
+class Bundler::Thor
+  include ::Bundler::Thor::Base
+  include ::Bundler::Thor::Invocation
+  include ::Bundler::Thor::Shell
+  def help(command=T.unsafe(nil), subcommand=T.unsafe(nil)); end
+  HELP_MAPPINGS = ::T.let(nil, ::T.untyped)
+  TEMPLATE_EXTNAME = ::T.let(nil, ::T.untyped)
+  THOR_RESERVED_WORDS = ::T.let(nil, ::T.untyped)
+end
 
-  def error(msg, newline=T.unsafe(nil)); end
+module Bundler::Thor::Actions
+  def _cleanup_options_and_set(options, key); end
 
-  def info(msg, newline=T.unsafe(nil)); end
+  def _shared_configuration(); end
 
-  def initialize(options=T.unsafe(nil)); end
+  def action(instance); end
 
-  def level(name=T.unsafe(nil)); end
+  def add_file(destination, *args, &block); end
 
-  def level=(level); end
+  def add_link(destination, *args); end
 
-  def no?(); end
+  def append_file(path, *args, &block); end
 
-  def quiet?(); end
+  def append_to_file(path, *args, &block); end
 
-  def shell=(shell); end
+  def apply(path, config=T.unsafe(nil)); end
 
-  def silence(&blk); end
+  def behavior(); end
 
-  def trace(e, newline=T.unsafe(nil), force=T.unsafe(nil)); end
+  def behavior=(behavior); end
 
-  def unprinted_warnings(); end
+  def chmod(path, mode, config=T.unsafe(nil)); end
 
-  def warn(msg, newline=T.unsafe(nil)); end
+  def comment_lines(path, flag, *args); end
 
-  def yes?(msg); end
-  LEVELS = ::T.let(nil, ::T.untyped)
-end
+  def copy_file(source, *args, &block); end
 
-class Bundler::UI::Shell
-end
+  def create_file(destination, *args, &block); end
 
-module Bundler::VersionRanges
-end
+  def create_link(destination, *args); end
 
-class Bundler::VersionRanges::NEq
-  def version(); end
+  def destination_root(); end
 
-  def version=(_); end
-end
+  def destination_root=(root); end
 
-class Bundler::VersionRanges::NEq
-  def self.[](*_); end
+  def directory(source, *args, &block); end
 
-  def self.members(); end
-end
+  def empty_directory(destination, config=T.unsafe(nil)); end
 
-class Bundler::VersionRanges::ReqR
-  def cover?(v); end
+  def find_in_source_paths(file); end
 
-  def empty?(); end
+  def get(source, *args, &block); end
 
-  def left(); end
+  def gsub_file(path, flag, *args, &block); end
 
-  def left=(_); end
+  def in_root(); end
 
-  def right(); end
+  def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil)); end
 
-  def right=(_); end
+  def inject_into_class(path, klass, *args, &block); end
 
-  def single?(); end
-  INFINITY = ::T.let(nil, ::T.untyped)
-  UNIVERSAL = ::T.let(nil, ::T.untyped)
-  ZERO = ::T.let(nil, ::T.untyped)
-end
+  def inject_into_file(destination, *args, &block); end
 
-class Bundler::VersionRanges::ReqR::Endpoint
-  def inclusive(); end
+  def inject_into_module(path, module_name, *args, &block); end
 
-  def inclusive=(_); end
+  def insert_into_file(destination, *args, &block); end
 
-  def version(); end
+  def inside(dir=T.unsafe(nil), config=T.unsafe(nil), &block); end
 
-  def version=(_); end
-end
+  def link_file(source, *args); end
 
-class Bundler::VersionRanges::ReqR::Endpoint
-  def self.[](*_); end
+  def prepend_file(path, *args, &block); end
 
-  def self.members(); end
-end
+  def prepend_to_file(path, *args, &block); end
 
-class Bundler::VersionRanges::ReqR
-  def self.[](*_); end
+  def relative_to_original_destination_root(path, remove_dot=T.unsafe(nil)); end
 
-  def self.members(); end
-end
+  def remove_dir(path, config=T.unsafe(nil)); end
 
-module Bundler::VersionRanges
-  def self.empty?(ranges, neqs); end
+  def remove_file(path, config=T.unsafe(nil)); end
 
-  def self.for(requirement); end
+  def run(command, config=T.unsafe(nil)); end
 
-  def self.for_many(requirements); end
-end
+  def run_ruby_script(command, config=T.unsafe(nil)); end
 
-class Class
-  def json_creatable?(); end
-end
+  def source_paths(); end
 
-class Complex
-  def self.polar(*_); end
+  def template(source, *args, &block); end
 
-  def self.rect(*_); end
+  def thor(command, *args); end
 
-  def self.rectangular(*_); end
+  def uncomment_lines(path, flag, *args); end
+  WARNINGS = ::T.let(nil, ::T.untyped)
 end
 
-module Concurrent
-  AtExit = ::T.let(nil, ::T.untyped)
-  NULL = ::T.let(nil, ::T.untyped)
-  NULL_LOGGER = ::T.let(nil, ::T.untyped)
-  VERSION = ::T.let(nil, ::T.untyped)
+class Bundler::Thor::Actions::CapturableERB
 end
 
-class Concurrent::AbstractExecutorService
-  FALLBACK_POLICIES = ::T.let(nil, ::T.untyped)
+class Bundler::Thor::Actions::CapturableERB
 end
 
-Concurrent::Collection::MapImplementation = Concurrent::Collection::MriMapBackend
+module Bundler::Thor::Actions::ClassMethods
+  def add_runtime_options!(); end
 
-class Concurrent::ConcurrentUpdateError
-  CONC_UP_ERR_BACKTRACE = ::T.let(nil, ::T.untyped)
-end
+  def source_paths(); end
 
-class Concurrent::LockFreeStack
-  EMPTY = ::T.let(nil, ::T.untyped)
-end
+  def source_paths_for_search(); end
 
-class Concurrent::MVar
-  EMPTY = ::T.let(nil, ::T.untyped)
-  TIMEOUT = ::T.let(nil, ::T.untyped)
+  def source_root(path=T.unsafe(nil)); end
 end
 
-class Concurrent::Maybe
-  NONE = ::T.let(nil, ::T.untyped)
+module Bundler::Thor::Actions::ClassMethods
 end
 
-module Concurrent::Promises::InternalStates
-  PENDING = ::T.let(nil, ::T.untyped)
-  RESERVED = ::T.let(nil, ::T.untyped)
-  RESOLVED = ::T.let(nil, ::T.untyped)
-end
+class Bundler::Thor::Actions::CreateFile
+  def data(); end
 
-class Concurrent::ReadWriteLock
-  MAX_READERS = ::T.let(nil, ::T.untyped)
-  MAX_WRITERS = ::T.let(nil, ::T.untyped)
-  RUNNING_WRITER = ::T.let(nil, ::T.untyped)
-  WAITING_WRITER = ::T.let(nil, ::T.untyped)
-end
+  def force_on_collision?(); end
 
-class Concurrent::ReentrantReadWriteLock
-  MAX_READERS = ::T.let(nil, ::T.untyped)
-  MAX_WRITERS = ::T.let(nil, ::T.untyped)
-  READER_BITS = ::T.let(nil, ::T.untyped)
-  READ_LOCK_MASK = ::T.let(nil, ::T.untyped)
-  RUNNING_WRITER = ::T.let(nil, ::T.untyped)
-  WAITING_WRITER = ::T.let(nil, ::T.untyped)
-  WRITER_BITS = ::T.let(nil, ::T.untyped)
-  WRITE_LOCK_HELD = ::T.let(nil, ::T.untyped)
-  WRITE_LOCK_MASK = ::T.let(nil, ::T.untyped)
-end
+  def force_or_skip_or_conflict(force, skip, &block); end
 
-class Concurrent::RubyThreadPoolExecutor
-  DEFAULT_MAX_POOL_SIZE = ::T.let(nil, ::T.untyped)
-  DEFAULT_MAX_QUEUE_SIZE = ::T.let(nil, ::T.untyped)
-  DEFAULT_MIN_POOL_SIZE = ::T.let(nil, ::T.untyped)
-  DEFAULT_THREAD_IDLETIMEOUT = ::T.let(nil, ::T.untyped)
-end
+  def identical?(); end
 
-Concurrent::Synchronization::Volatile = Concurrent::Synchronization::MriAttrVolatile
+  def initialize(base, destination, data, config=T.unsafe(nil)); end
 
-module Concurrent::ThreadSafe::Util
-  CPU_COUNT = ::T.let(nil, ::T.untyped)
-  FIXNUM_BIT_SIZE = ::T.let(nil, ::T.untyped)
-  MAX_INT = ::T.let(nil, ::T.untyped)
+  def on_conflict_behavior(&block); end
+
+  def render(); end
 end
 
-class Concurrent::TimerTask
-  EXECUTION_INTERVAL = ::T.let(nil, ::T.untyped)
-  TIMEOUT_INTERVAL = ::T.let(nil, ::T.untyped)
+class Bundler::Thor::Actions::CreateFile
 end
 
-class Concurrent::Transaction
-  ABORTED = ::T.let(nil, ::T.untyped)
+class Bundler::Thor::Actions::CreateLink
 end
 
-module Concurrent::Utility::NativeInteger
-  MAX_VALUE = ::T.let(nil, ::T.untyped)
-  MIN_VALUE = ::T.let(nil, ::T.untyped)
+class Bundler::Thor::Actions::CreateLink
 end
 
-class Delegator
-  def !=(obj); end
+class Bundler::Thor::Actions::Directory
+  def execute!(); end
 
-  def ==(obj); end
+  def file_level_lookup(previous_lookup); end
 
-  def __getobj__(); end
+  def files(lookup); end
 
-  def __setobj__(obj); end
+  def initialize(base, source, destination=T.unsafe(nil), config=T.unsafe(nil), &block); end
 
-  def eql?(obj); end
+  def source(); end
+end
 
-  def initialize(obj); end
+class Bundler::Thor::Actions::Directory
+end
 
-  def marshal_dump(); end
+class Bundler::Thor::Actions::EmptyDirectory
+  def base(); end
 
-  def marshal_load(data); end
+  def config(); end
 
-  def method_missing(m, *args, &block); end
+  def convert_encoded_instructions(filename); end
 
-  def methods(all=T.unsafe(nil)); end
+  def destination(); end
 
-  def protected_methods(all=T.unsafe(nil)); end
+  def destination=(destination); end
 
-  def public_methods(all=T.unsafe(nil)); end
-end
+  def exists?(); end
 
-class Delegator
-  def self.const_missing(n); end
+  def given_destination(); end
 
-  def self.delegating_block(mid); end
+  def initialize(base, destination, config=T.unsafe(nil)); end
 
-  def self.public_api(); end
-end
+  def invoke!(); end
 
-class DidYouMean::ClassNameChecker
-  def class_name(); end
+  def invoke_with_conflict_check(&block); end
 
-  def class_names(); end
+  def on_conflict_behavior(); end
 
-  def corrections(); end
+  def on_file_clash_behavior(); end
 
-  def initialize(exception); end
+  def pretend?(); end
 
-  def scopes(); end
+  def relative_destination(); end
+
+  def revoke!(); end
+
+  def say_status(status, color); end
 end
 
-module DidYouMean::Correctable
-  def corrections(); end
+class Bundler::Thor::Actions::EmptyDirectory
+end
 
-  def original_message(); end
+class Bundler::Thor::Actions::InjectIntoFile
+  def behavior(); end
 
-  def spell_checker(); end
+  def flag(); end
 
-  def to_s(); end
-end
+  def initialize(base, destination, data, config); end
 
-module DidYouMean::Jaro
-  def self.distance(str1, str2); end
+  def replace!(regexp, string, force); end
+
+  def replacement(); end
+
+  def say_status(behavior, warning: T.unsafe(nil), color: T.unsafe(nil)); end
 end
 
-module DidYouMean::JaroWinkler
-  def self.distance(str1, str2); end
+class Bundler::Thor::Actions::InjectIntoFile
 end
 
-class DidYouMean::KeyErrorChecker
-  def corrections(); end
+module Bundler::Thor::Actions
+  def self.included(base); end
+end
 
-  def initialize(key_error); end
+class Bundler::Thor::AmbiguousCommandError
 end
 
-class DidYouMean::KeyErrorChecker
+class Bundler::Thor::AmbiguousCommandError
 end
 
-module DidYouMean::Levenshtein
-  def self.distance(str1, str2); end
+Bundler::Thor::AmbiguousTaskError = Bundler::Thor::AmbiguousCommandError
 
-  def self.min3(a, b, c); end
-end
+class Bundler::Thor::Argument
+  def banner(); end
 
-class DidYouMean::MethodNameChecker
-  def corrections(); end
+  def default(); end
 
-  def initialize(exception); end
+  def default_banner(); end
 
-  def method_name(); end
+  def description(); end
 
-  def method_names(); end
+  def enum(); end
 
-  def receiver(); end
-  RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped)
-end
+  def human_name(); end
 
-class DidYouMean::NullChecker
-  def corrections(); end
+  def initialize(name, options=T.unsafe(nil)); end
 
-  def initialize(*_); end
-end
+  def name(); end
 
-class DidYouMean::PlainFormatter
-  def message_for(corrections); end
-end
+  def required(); end
 
-class DidYouMean::PlainFormatter
-end
+  def required?(); end
 
-class DidYouMean::SpellChecker
-  def correct(input); end
+  def show_default?(); end
 
-  def initialize(dictionary:); end
-end
+  def type(); end
 
-class DidYouMean::VariableNameChecker
-  def corrections(); end
+  def usage(); end
 
-  def cvar_names(); end
+  def valid_type?(type); end
 
-  def initialize(exception); end
+  def validate!(); end
+  VALID_TYPES = ::T.let(nil, ::T.untyped)
+end
 
-  def ivar_names(); end
+class Bundler::Thor::Argument
+end
 
-  def lvar_names(); end
+class Bundler::Thor::Arguments
+  def initialize(arguments=T.unsafe(nil)); end
 
-  def method_names(); end
+  def parse(args); end
 
-  def name(); end
-  RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped)
+  def remaining(); end
+  NUMERIC = ::T.let(nil, ::T.untyped)
 end
 
-module DidYouMean
-  def self.formatter(); end
+class Bundler::Thor::Arguments
+  def self.parse(*args); end
 
-  def self.formatter=(formatter); end
+  def self.split(args); end
 end
 
-class Dir
-  def children(); end
-
-  def each_child(); end
-end
+module Bundler::Thor::Base
+  def args(); end
 
-class Dir
-  def self.children(*_); end
+  def args=(args); end
 
-  def self.each_child(*_); end
+  def initialize(args=T.unsafe(nil), local_options=T.unsafe(nil), config=T.unsafe(nil)); end
 
-  def self.empty?(_); end
+  def options(); end
 
-  def self.exists?(_); end
+  def options=(options); end
 
-  def self.tmpdir(); end
-end
+  def parent_options(); end
 
-class Encoding
-  def _dump(*_); end
+  def parent_options=(parent_options); end
 end
 
-class Encoding::Converter
-  def convert(_); end
+module Bundler::Thor::Base::ClassMethods
+  def all_commands(); end
 
-  def convpath(); end
+  def all_tasks(); end
 
-  def destination_encoding(); end
+  def allow_incompatible_default_type!(); end
 
-  def finish(); end
+  def argument(name, options=T.unsafe(nil)); end
 
-  def initialize(*_); end
+  def arguments(); end
 
-  def insert_output(_); end
+  def attr_accessor(*_); end
 
-  def last_error(); end
+  def attr_reader(*_); end
 
-  def primitive_convert(*_); end
+  def attr_writer(*_); end
 
-  def primitive_errinfo(); end
+  def baseclass(); end
 
-  def putback(*_); end
+  def basename(); end
 
-  def replacement(); end
+  def build_option(name, options, scope); end
 
-  def replacement=(replacement); end
+  def build_options(options, scope); end
 
-  def source_encoding(); end
-end
+  def check_default_type(); end
 
-class Encoding::Converter
-  def self.asciicompat_encoding(_); end
+  def check_default_type!(); end
 
-  def self.search_convpath(*_); end
-end
+  def check_unknown_options(); end
 
-class Encoding::InvalidByteSequenceError
-  def destination_encoding(); end
+  def check_unknown_options!(); end
 
-  def destination_encoding_name(); end
+  def check_unknown_options?(config); end
 
-  def error_bytes(); end
+  def class_option(name, options=T.unsafe(nil)); end
 
-  def incomplete_input?(); end
+  def class_options(options=T.unsafe(nil)); end
 
-  def readagain_bytes(); end
+  def class_options_help(shell, groups=T.unsafe(nil)); end
 
-  def source_encoding(); end
+  def commands(); end
 
-  def source_encoding_name(); end
-end
+  def create_command(meth); end
 
-class Encoding::UndefinedConversionError
-  def destination_encoding(); end
+  def create_task(meth); end
 
-  def destination_encoding_name(); end
+  def disable_required_check?(command_name); end
 
-  def error_char(); end
+  def dispatch(command, given_args, given_opts, config); end
 
-  def source_encoding(); end
+  def exit_on_failure?(); end
 
-  def source_encoding_name(); end
-end
+  def find_and_refresh_command(name); end
 
-class Encoding
-  def self._load(_); end
+  def find_and_refresh_task(name); end
 
-  def self.locale_charmap(); end
-end
+  def from_superclass(method, default=T.unsafe(nil)); end
 
-module Enumerable
-  def chain(*_); end
+  def group(name=T.unsafe(nil)); end
 
-  def chunk(); end
+  def handle_argument_error(command, error, args, arity); end
 
-  def chunk_while(); end
+  def handle_no_command_error(command, has_namespace=T.unsafe(nil)); end
 
-  def each_entry(*_); end
+  def handle_no_task_error(command, has_namespace=T.unsafe(nil)); end
 
-  def filter(); end
+  def inherited(klass); end
 
-  def grep_v(_); end
+  def initialize_added(); end
 
-  def slice_after(*_); end
+  def is_thor_reserved_word?(word, type); end
 
-  def slice_before(*_); end
+  def method_added(meth); end
 
-  def slice_when(); end
+  def namespace(name=T.unsafe(nil)); end
 
-  def sum(*_); end
+  def no_commands(&block); end
 
-  def to_set(klass=T.unsafe(nil), *args, &block); end
+  def no_commands?(); end
 
-  def uniq(); end
+  def no_commands_context(); end
 
-  def zip(*_); end
-end
+  def no_tasks(&block); end
 
-class Enumerator
-  def +(_); end
+  def print_options(shell, options, group_name=T.unsafe(nil)); end
 
-  def each_with_index(); end
-end
+  def public_command(*names); end
 
-class Enumerator::ArithmeticSequence
-  def begin(); end
+  def public_task(*names); end
 
-  def each(&blk); end
+  def remove_argument(*names); end
 
-  def end(); end
+  def remove_class_option(*names); end
 
-  def exclude_end?(); end
+  def remove_command(*names); end
 
-  def last(*_); end
+  def remove_task(*names); end
 
-  def step(); end
-end
+  def start(given_args=T.unsafe(nil), config=T.unsafe(nil)); end
 
-class Enumerator::ArithmeticSequence
-end
+  def stop_on_unknown_option?(command_name); end
 
-class Enumerator::Chain
-end
+  def strict_args_position(); end
 
-class Enumerator::Chain
-end
+  def strict_args_position!(); end
 
-class Enumerator::Generator
-  def each(*_, &blk); end
+  def strict_args_position?(config); end
 
-  def initialize(*_); end
+  def tasks(); end
 end
 
-class Enumerator::Lazy
-  def chunk(*_); end
+module Bundler::Thor::Base::ClassMethods
+end
 
-  def chunk_while(*_); end
+module Bundler::Thor::Base
+  def self.included(base); end
 
-  def force(*_); end
+  def self.register_klass_file(klass); end
 
-  def slice_when(*_); end
-end
+  def self.shell(); end
 
-Errno::EAUTH = Errno::NOERROR
+  def self.shell=(shell); end
 
-Errno::EBADARCH = Errno::NOERROR
+  def self.subclass_files(); end
 
-Errno::EBADEXEC = Errno::NOERROR
+  def self.subclasses(); end
+end
 
-Errno::EBADMACHO = Errno::NOERROR
+class Bundler::Thor::Command
+  def formatted_usage(klass, namespace=T.unsafe(nil), subcommand=T.unsafe(nil)); end
 
-Errno::EBADRPC = Errno::NOERROR
+  def handle_argument_error?(instance, error, caller); end
 
-Errno::ECAPMODE = Errno::NOERROR
+  def handle_no_method_error?(instance, error, caller); end
 
-Errno::EDEADLOCK = Errno::EDEADLK
+  def hidden?(); end
 
-Errno::EDEVERR = Errno::NOERROR
+  def initialize(name, description, long_description, usage, options=T.unsafe(nil)); end
 
-Errno::EDOOFUS = Errno::NOERROR
+  def local_method?(instance, name); end
 
-Errno::EFTYPE = Errno::NOERROR
+  def not_debugging?(instance); end
 
-Errno::EIPSEC = Errno::NOERROR
+  def private_method?(instance); end
 
-Errno::ELAST = Errno::NOERROR
+  def public_method?(instance); end
 
-Errno::ENEEDAUTH = Errno::NOERROR
+  def required_arguments_for(klass, usage); end
 
-Errno::ENOATTR = Errno::NOERROR
+  def required_options(); end
 
-Errno::ENOPOLICY = Errno::NOERROR
+  def run(instance, args=T.unsafe(nil)); end
 
-Errno::ENOTCAPABLE = Errno::NOERROR
+  def sans_backtrace(backtrace, caller); end
+  FILE_REGEXP = ::T.let(nil, ::T.untyped)
+end
 
-class Errno::ENOTSUP
-  Errno = ::T.let(nil, ::T.untyped)
+class Bundler::Thor::Command
 end
 
-class Errno::ENOTSUP
+module Bundler::Thor::CoreExt
 end
 
-Errno::EPROCLIM = Errno::NOERROR
+class Bundler::Thor::CoreExt::HashWithIndifferentAccess
+  def [](key); end
 
-Errno::EPROCUNAVAIL = Errno::NOERROR
+  def []=(key, value); end
 
-Errno::EPROGMISMATCH = Errno::NOERROR
+  def convert_key(key); end
 
-Errno::EPROGUNAVAIL = Errno::NOERROR
+  def delete(key); end
 
-Errno::EPWROFF = Errno::NOERROR
+  def fetch(key, *args); end
 
-Errno::EQFULL = Errno::NOERROR
+  def initialize(hash=T.unsafe(nil)); end
 
-Errno::ERPCMISMATCH = Errno::NOERROR
+  def key?(key); end
 
-Errno::ESHLIBVERS = Errno::NOERROR
+  def merge(other); end
 
-class Etc::Group
-  def gid(); end
+  def merge!(other); end
 
-  def gid=(_); end
+  def method_missing(method, *args); end
 
-  def mem(); end
+  def replace(other_hash); end
 
-  def mem=(_); end
+  def reverse_merge(other); end
 
-  def name(); end
+  def reverse_merge!(other_hash); end
 
-  def name=(_); end
+  def values_at(*indices); end
+end
 
-  def passwd(); end
+class Bundler::Thor::CoreExt::HashWithIndifferentAccess
+end
 
-  def passwd=(_); end
+module Bundler::Thor::CoreExt
 end
 
-class Etc::Group
-  extend ::Enumerable
-  def self.[](*_); end
+Bundler::Thor::Correctable = DidYouMean::Correctable
 
-  def self.each(&blk); end
+class Bundler::Thor::DynamicCommand
+  def initialize(name, options=T.unsafe(nil)); end
+end
 
-  def self.members(); end
+class Bundler::Thor::DynamicCommand
 end
 
-class Etc::Passwd
-  def dir(); end
+Bundler::Thor::DynamicTask = Bundler::Thor::DynamicCommand
 
-  def dir=(_); end
+class Bundler::Thor::Error
+end
 
-  def gecos(); end
+class Bundler::Thor::Error
+end
 
-  def gecos=(_); end
+class Bundler::Thor::Group
+  include ::Bundler::Thor::Base
+  include ::Bundler::Thor::Invocation
+  include ::Bundler::Thor::Shell
+  def _invoke_for_class_method(klass, command=T.unsafe(nil), *args, &block); end
+end
 
-  def gid(); end
+class Bundler::Thor::Group
+  extend ::Bundler::Thor::Base::ClassMethods
+  extend ::Bundler::Thor::Invocation::ClassMethods
+  def self.banner(); end
 
-  def gid=(_); end
+  def self.desc(description=T.unsafe(nil)); end
 
-  def name(); end
+  def self.get_options_from_invocations(group_options, base_options); end
 
-  def name=(_); end
+  def self.handle_argument_error(command, error, _args, arity); end
 
-  def passwd(); end
+  def self.help(shell); end
 
-  def passwd=(_); end
+  def self.invocation_blocks(); end
 
-  def shell(); end
+  def self.invocations(); end
 
-  def shell=(_); end
+  def self.invoke(*names, &block); end
 
-  def uid(); end
+  def self.invoke_from_option(*names, &block); end
 
-  def uid=(_); end
-end
+  def self.printable_commands(*_); end
 
-class Etc::Passwd
-  extend ::Enumerable
-  def self.[](*_); end
+  def self.printable_tasks(*_); end
 
-  def self.each(&blk); end
+  def self.remove_invocation(*names); end
 
-  def self.members(); end
+  def self.self_command(); end
+
+  def self.self_task(); end
 end
 
-module Etc
-  def self.confstr(_); end
+class Bundler::Thor::HiddenCommand
+end
 
-  def self.endgrent(); end
+class Bundler::Thor::HiddenCommand
+end
 
-  def self.endpwent(); end
+Bundler::Thor::HiddenTask = Bundler::Thor::HiddenCommand
 
-  def self.getgrent(); end
+module Bundler::Thor::Invocation
+  def _parse_initialization_options(args, opts, config); end
 
-  def self.getgrgid(*_); end
+  def _retrieve_class_and_command(name, sent_command=T.unsafe(nil)); end
 
-  def self.getgrnam(_); end
+  def _retrieve_class_and_task(name, sent_command=T.unsafe(nil)); end
 
-  def self.getlogin(); end
+  def _shared_configuration(); end
 
-  def self.getpwent(); end
+  def current_command_chain(); end
 
-  def self.getpwnam(_); end
+  def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil), &block); end
 
-  def self.getpwuid(*_); end
+  def invoke(name=T.unsafe(nil), *args); end
 
-  def self.group(); end
+  def invoke_all(); end
 
-  def self.nprocessors(); end
+  def invoke_command(command, *args); end
 
-  def self.passwd(); end
+  def invoke_task(command, *args); end
 
-  def self.setgrent(); end
+  def invoke_with_padding(*args); end
+end
 
-  def self.setpwent(); end
+module Bundler::Thor::Invocation::ClassMethods
+  def prepare_for_invocation(key, name); end
+end
 
-  def self.sysconf(_); end
+module Bundler::Thor::Invocation::ClassMethods
+end
 
-  def self.sysconfdir(); end
+module Bundler::Thor::Invocation
+  def self.included(base); end
+end
 
-  def self.systmpdir(); end
+class Bundler::Thor::InvocationError
+end
 
-  def self.uname(); end
+class Bundler::Thor::InvocationError
 end
 
-class Exception
-  def full_message(*_); end
+module Bundler::Thor::LineEditor
 end
 
-class Exception
-  def self.exception(*_); end
+class Bundler::Thor::LineEditor::Basic
+  def initialize(prompt, options); end
 
-  def self.to_tty?(); end
-end
+  def options(); end
 
-class ExitCalledError
-end
+  def prompt(); end
 
-class ExitCalledError
+  def readline(); end
 end
 
-class FalseClass
-  include ::JSON::Ext::Generator::GeneratorMethods::FalseClass
+class Bundler::Thor::LineEditor::Basic
+  def self.available?(); end
 end
 
-class Fiber
-  def resume(*_); end
+class Bundler::Thor::LineEditor::Readline
 end
 
-class Fiber
-  def self.yield(*_); end
-end
+class Bundler::Thor::LineEditor::Readline::PathCompletion
+  def initialize(text); end
 
-class File
-  Separator = ::T.let(nil, ::T.untyped)
+  def matches(); end
 end
 
-class File::Stat
-  def size?(); end
+class Bundler::Thor::LineEditor::Readline::PathCompletion
 end
 
-class File
-  def self.empty?(_); end
-
-  def self.exists?(_); end
+class Bundler::Thor::LineEditor::Readline
+end
 
-  def self.lutime(*_); end
+module Bundler::Thor::LineEditor
+  def self.best_available(); end
 
-  def self.mkfifo(*_); end
+  def self.readline(prompt, options=T.unsafe(nil)); end
 end
 
-module FileUtils
-  include ::FileUtils::StreamUtils_
+class Bundler::Thor::MalformattedArgumentError
 end
 
-module FileUtils::DryRun
-  include ::FileUtils
-  include ::FileUtils::StreamUtils_
-  include ::FileUtils::LowMethods
+class Bundler::Thor::MalformattedArgumentError
 end
 
-module FileUtils::DryRun
-  extend ::FileUtils::DryRun
-  extend ::FileUtils
-  extend ::FileUtils::StreamUtils_
-  extend ::FileUtils::LowMethods
-end
+class Bundler::Thor::NestedContext
+  def enter(); end
 
-module FileUtils::NoWrite
-  include ::FileUtils
-  include ::FileUtils::StreamUtils_
-  include ::FileUtils::LowMethods
+  def entered?(); end
 end
 
-module FileUtils::NoWrite
-  extend ::FileUtils::NoWrite
-  extend ::FileUtils
-  extend ::FileUtils::StreamUtils_
-  extend ::FileUtils::LowMethods
+class Bundler::Thor::NestedContext
 end
 
-module FileUtils::Verbose
-  include ::FileUtils
-  include ::FileUtils::StreamUtils_
+class Bundler::Thor::NoKwargSpellChecker
+  def initialize(dictionary); end
 end
 
-module FileUtils::Verbose
-  extend ::FileUtils::Verbose
-  extend ::FileUtils
-  extend ::FileUtils::StreamUtils_
+class Bundler::Thor::NoKwargSpellChecker
 end
 
-module FileUtils
-  extend ::FileUtils::StreamUtils_
-end
+class Bundler::Thor::Option
+  def aliases(); end
 
-class Float
-  include ::JSON::Ext::Generator::GeneratorMethods::Float
-end
+  def array?(); end
 
-module Forwardable
-  def def_delegator(accessor, method, ali=T.unsafe(nil)); end
+  def boolean?(); end
 
-  def def_delegators(accessor, *methods); end
+  def dasherize(str); end
 
-  def def_instance_delegator(accessor, method, ali=T.unsafe(nil)); end
+  def dasherized?(); end
 
-  def def_instance_delegators(accessor, *methods); end
+  def group(); end
 
-  def delegate(hash); end
+  def hash?(); end
 
-  def instance_delegate(hash); end
-  VERSION = ::T.let(nil, ::T.untyped)
-end
+  def hide(); end
 
-module Forwardable
-  def self._compile_method(src, file, line); end
+  def lazy_default(); end
 
-  def self._delegator_method(obj, accessor, method, ali); end
+  def numeric?(); end
 
-  def self._valid_method?(method); end
+  def repeatable(); end
 
-  def self.debug(); end
+  def string?(); end
 
-  def self.debug=(debug); end
-end
+  def switch_name(); end
 
-class FrozenError
-end
+  def undasherize(str); end
 
-class FrozenError
+  def usage(padding=T.unsafe(nil)); end
+
+  def validate_default_type!(); end
+  VALID_TYPES = ::T.let(nil, ::T.untyped)
 end
 
-module GC
-  def garbage_collect(*_); end
+class Bundler::Thor::Option
+  def self.parse(key, value); end
 end
 
-module GC
-  def self.latest_gc_info(*_); end
+class Bundler::Thor::Options
+  def assign_result!(option, result); end
 
-  def self.stress=(stress); end
+  def check_unknown!(); end
 
-  def self.verify_internal_consistency(); end
+  def current_is_switch?(); end
 
-  def self.verify_transient_heap_internal_consistency(); end
-end
+  def current_is_switch_formatted?(); end
 
-class Gem::Package::TarHeader
-  def self.oct_or_256based(str); end
-end
+  def initialize(hash_options=T.unsafe(nil), defaults=T.unsafe(nil), stop_on_unknown=T.unsafe(nil), disable_required_check=T.unsafe(nil)); end
 
-class Gem::RemoteFetcher
-  def s3_uri_signer(uri); end
-end
+  def normalize_switch(arg); end
 
-class Gem::Resolver::Molinillo::DependencyGraph::Log
-  extend ::Enumerable
+  def parse_boolean(switch); end
+
+  def parse_peek(switch, option); end
+
+  def parsing_options?(); end
+
+  def switch?(arg); end
+
+  def switch_option(arg); end
+  EQ_RE = ::T.let(nil, ::T.untyped)
+  LONG_RE = ::T.let(nil, ::T.untyped)
+  OPTS_END = ::T.let(nil, ::T.untyped)
+  SHORT_NUM = ::T.let(nil, ::T.untyped)
+  SHORT_RE = ::T.let(nil, ::T.untyped)
+  SHORT_SQ_RE = ::T.let(nil, ::T.untyped)
 end
 
-class Gem::S3URISigner
-  def initialize(uri); end
+class Bundler::Thor::Options
+  def self.to_switches(options); end
+end
 
-  def sign(expiration=T.unsafe(nil)); end
+module Bundler::Thor::RakeCompat
+  include ::Rake::DSL
+  include ::Rake::FileUtilsExt
+  include ::FileUtils
+  include ::FileUtils::StreamUtils_
+end
 
-  def uri(); end
+module Bundler::Thor::RakeCompat
+  def self.included(base); end
 
-  def uri=(uri); end
-  BASE64_URI_TRANSLATE = ::T.let(nil, ::T.untyped)
-  EC2_METADATA_CREDENTIALS = ::T.let(nil, ::T.untyped)
+  def self.rake_classes(); end
 end
 
-class Gem::S3URISigner::ConfigurationError
-  def initialize(message); end
+class Bundler::Thor::RequiredArgumentMissingError
 end
 
-class Gem::S3URISigner::ConfigurationError
+class Bundler::Thor::RequiredArgumentMissingError
 end
 
-class Gem::S3URISigner::InstanceProfileError
-  def initialize(message); end
+module Bundler::Thor::Sandbox
 end
 
-class Gem::S3URISigner::InstanceProfileError
+module Bundler::Thor::Sandbox
 end
 
-class Gem::S3URISigner::S3Config
-  def access_key_id(); end
+module Bundler::Thor::Shell
+  def _shared_configuration(); end
 
-  def access_key_id=(_); end
+  def ask(*args, &block); end
 
-  def region(); end
+  def error(*args, &block); end
 
-  def region=(_); end
+  def file_collision(*args, &block); end
 
-  def secret_access_key(); end
+  def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil)); end
 
-  def secret_access_key=(_); end
+  def no?(*args, &block); end
 
-  def security_token(); end
+  def print_in_columns(*args, &block); end
 
-  def security_token=(_); end
-end
+  def print_table(*args, &block); end
 
-class Gem::S3URISigner::S3Config
-  def self.[](*_); end
+  def print_wrapped(*args, &block); end
 
-  def self.members(); end
-end
+  def say(*args, &block); end
 
-class Gem::S3URISigner
-end
+  def say_status(*args, &block); end
 
-class Gem::Specification
-  extend ::Enumerable
-end
+  def set_color(*args, &block); end
 
-module Gem::Util
-  def self.correct_for_windows_path(path); end
-end
+  def shell(); end
 
-module Hamster
-  EmptyDeque = ::T.let(nil, ::T.untyped)
-  EmptyHash = ::T.let(nil, ::T.untyped)
-  EmptySet = ::T.let(nil, ::T.untyped)
-  EmptySortedSet = ::T.let(nil, ::T.untyped)
-  EmptyTrie = ::T.let(nil, ::T.untyped)
-  EmptyVector = ::T.let(nil, ::T.untyped)
-  VERSION = ::T.let(nil, ::T.untyped)
-end
+  def shell=(shell); end
 
-module Hamster::EmptyList
-  extend ::Hamster::List
-  extend ::Hamster::Enumerable
-  extend ::Enumerable
+  def terminal_width(*args, &block); end
+
+  def with_padding(); end
+
+  def yes?(*args, &block); end
+  SHELL_DELEGATED_METHODS = ::T.let(nil, ::T.untyped)
 end
 
-class Hamster::LazyList
-  MUTEX = ::T.let(nil, ::T.untyped)
-  QUEUE = ::T.let(nil, ::T.untyped)
+class Bundler::Thor::Shell::Basic
+  def answer_match(possibilities, answer, case_insensitive); end
+
+  def as_unicode(); end
+
+  def ask(statement, *args); end
+
+  def ask_filtered(statement, color, options); end
+
+  def ask_simply(statement, color, options); end
+
+  def base(); end
+
+  def base=(base); end
+
+  def can_display_colors?(); end
+
+  def dynamic_width(); end
+
+  def dynamic_width_stty(); end
+
+  def dynamic_width_tput(); end
+
+  def error(statement); end
+
+  def file_collision(destination); end
+
+  def file_collision_help(); end
+
+  def git_merge_tool(); end
+
+  def indent(count=T.unsafe(nil)); end
+
+  def is?(value); end
+
+  def lookup_color(color); end
+
+  def merge(destination, content); end
+
+  def merge_tool(); end
+
+  def mute(); end
+
+  def mute?(); end
+
+  def no?(statement, color=T.unsafe(nil)); end
+
+  def padding(); end
+
+  def padding=(value); end
+
+  def prepare_message(message, *color); end
+
+  def print_in_columns(array); end
+
+  def print_table(array, options=T.unsafe(nil)); end
+
+  def print_wrapped(message, options=T.unsafe(nil)); end
+
+  def quiet?(); end
+
+  def say(message=T.unsafe(nil), color=T.unsafe(nil), force_new_line=T.unsafe(nil)); end
+
+  def say_status(status, message, log_status=T.unsafe(nil)); end
+
+  def set_color(string, *_); end
+
+  def show_diff(destination, content); end
+
+  def stderr(); end
+
+  def stdout(); end
+
+  def terminal_width(); end
+
+  def truncate(string, width); end
+
+  def unix?(); end
+
+  def yes?(statement, color=T.unsafe(nil)); end
+  DEFAULT_TERMINAL_WIDTH = ::T.let(nil, ::T.untyped)
 end
 
-module Hamster::List
-  CADR = ::T.let(nil, ::T.untyped)
+class Bundler::Thor::Shell::Basic
 end
 
-class Hamster::SortedSet::PlainAVLNode
-  EmptyNode = ::T.let(nil, ::T.untyped)
+class Bundler::Thor::Shell::Color
+  def are_colors_disabled?(); end
+
+  def are_colors_supported?(); end
+
+  def diff_lcs_loaded?(); end
+
+  def output_diff_line(diff); end
+
+  def set_color(string, *colors); end
+  BLACK = ::T.let(nil, ::T.untyped)
+  BLUE = ::T.let(nil, ::T.untyped)
+  BOLD = ::T.let(nil, ::T.untyped)
+  CLEAR = ::T.let(nil, ::T.untyped)
+  CYAN = ::T.let(nil, ::T.untyped)
+  GREEN = ::T.let(nil, ::T.untyped)
+  MAGENTA = ::T.let(nil, ::T.untyped)
+  ON_BLACK = ::T.let(nil, ::T.untyped)
+  ON_BLUE = ::T.let(nil, ::T.untyped)
+  ON_CYAN = ::T.let(nil, ::T.untyped)
+  ON_GREEN = ::T.let(nil, ::T.untyped)
+  ON_MAGENTA = ::T.let(nil, ::T.untyped)
+  ON_RED = ::T.let(nil, ::T.untyped)
+  ON_WHITE = ::T.let(nil, ::T.untyped)
+  ON_YELLOW = ::T.let(nil, ::T.untyped)
+  RED = ::T.let(nil, ::T.untyped)
+  WHITE = ::T.let(nil, ::T.untyped)
+  YELLOW = ::T.let(nil, ::T.untyped)
 end
 
-class Hamster::Vector
-  BITS_PER_LEVEL = ::T.let(nil, ::T.untyped)
-  BLOCK_SIZE = ::T.let(nil, ::T.untyped)
-  INDEX_MASK = ::T.let(nil, ::T.untyped)
+class Bundler::Thor::Shell::Color
 end
 
-class Hash
-  include ::JSON::Ext::Generator::GeneratorMethods::Hash
-  def <(_); end
+class Bundler::Thor::Shell::HTML
+  def ask(statement, color=T.unsafe(nil)); end
+
+  def diff_lcs_loaded?(); end
 
-  def <=(_); end
+  def output_diff_line(diff); end
 
-  def >(_); end
+  def set_color(string, *colors); end
+  BLACK = ::T.let(nil, ::T.untyped)
+  BLUE = ::T.let(nil, ::T.untyped)
+  BOLD = ::T.let(nil, ::T.untyped)
+  CYAN = ::T.let(nil, ::T.untyped)
+  GREEN = ::T.let(nil, ::T.untyped)
+  MAGENTA = ::T.let(nil, ::T.untyped)
+  ON_BLACK = ::T.let(nil, ::T.untyped)
+  ON_BLUE = ::T.let(nil, ::T.untyped)
+  ON_CYAN = ::T.let(nil, ::T.untyped)
+  ON_GREEN = ::T.let(nil, ::T.untyped)
+  ON_MAGENTA = ::T.let(nil, ::T.untyped)
+  ON_RED = ::T.let(nil, ::T.untyped)
+  ON_WHITE = ::T.let(nil, ::T.untyped)
+  ON_YELLOW = ::T.let(nil, ::T.untyped)
+  RED = ::T.let(nil, ::T.untyped)
+  WHITE = ::T.let(nil, ::T.untyped)
+  YELLOW = ::T.let(nil, ::T.untyped)
+end
 
-  def >=(_); end
+class Bundler::Thor::Shell::HTML
+end
 
-  def compact(); end
+module Bundler::Thor::Shell
+end
 
-  def compact!(); end
+Bundler::Thor::Task = Bundler::Thor::Command
 
-  def default_proc(); end
+class Bundler::Thor::UndefinedCommandError
+  include ::DidYouMean::Correctable
+  def all_commands(); end
 
-  def default_proc=(default_proc); end
+  def command(); end
 
-  def dig(*_); end
+  def initialize(command, all_commands, namespace); end
+end
 
-  def fetch_values(*_); end
+class Bundler::Thor::UndefinedCommandError::SpellChecker
+  def corrections(); end
 
-  def filter!(); end
+  def error(); end
 
-  def flatten(*_); end
+  def initialize(error); end
 
-  def index(_); end
+  def spell_checker(); end
+end
 
-  def merge!(*_); end
+class Bundler::Thor::UndefinedCommandError::SpellChecker
+end
 
-  def replace(_); end
+class Bundler::Thor::UndefinedCommandError
+end
 
-  def slice(*_); end
+Bundler::Thor::UndefinedTaskError = Bundler::Thor::UndefinedCommandError
 
-  def to_h(); end
+class Bundler::Thor::UnknownArgumentError
+  include ::DidYouMean::Correctable
+  def initialize(switches, unknown); end
 
-  def to_proc(); end
+  def switches(); end
 
-  def transform_keys(); end
+  def unknown(); end
+end
 
-  def transform_keys!(); end
+class Bundler::Thor::UnknownArgumentError::SpellChecker
+  def corrections(); end
 
-  def transform_values(); end
+  def error(); end
 
-  def transform_values!(); end
+  def initialize(error); end
 
-  def update(*_); end
+  def spell_checker(); end
 end
 
-class Hash
-  def self.try_convert(_); end
+class Bundler::Thor::UnknownArgumentError::SpellChecker
 end
 
-class IO
-  def external_encoding(); end
+class Bundler::Thor::UnknownArgumentError
+end
 
-  def nonblock(*_); end
+module Bundler::Thor::Util
+end
 
-  def nonblock=(nonblock); end
+module Bundler::Thor::Util
+  def self.camel_case(str); end
 
-  def nonblock?(); end
+  def self.escape_globs(path); end
 
-  def nread(); end
+  def self.escape_html(string); end
 
-  def pathconf(_); end
+  def self.find_by_namespace(namespace); end
 
-  def pread(*_); end
+  def self.find_class_and_command_by_namespace(namespace, fallback=T.unsafe(nil)); end
 
-  def pwrite(_, _1); end
+  def self.find_class_and_task_by_namespace(namespace, fallback=T.unsafe(nil)); end
 
-  def ready?(); end
+  def self.globs_for(path); end
 
-  def wait(*_); end
+  def self.load_thorfile(path, content=T.unsafe(nil), debug=T.unsafe(nil)); end
 
-  def wait_readable(*_); end
+  def self.namespace_from_thor_class(constant); end
 
-  def wait_writable(*_); end
+  def self.namespaces_in_content(contents, file=T.unsafe(nil)); end
 
-  def write_nonblock(buf, exception: T.unsafe(nil)); end
-end
+  def self.ruby_command(); end
 
-IO::EWOULDBLOCKWaitReadable = IO::EAGAINWaitReadable
+  def self.snake_case(str); end
 
-IO::EWOULDBLOCKWaitWritable = IO::EAGAINWaitWritable
+  def self.thor_classes_in(klass); end
 
-class IO
-  def self.foreach(*_); end
+  def self.thor_root(); end
 
-  def self.pipe(*_); end
+  def self.thor_root_glob(); end
+
+  def self.user_home(); end
 end
 
-class IPAddr
-  include ::Comparable
-  def &(other); end
+class Bundler::Thor
+  extend ::Bundler::Thor::Base::ClassMethods
+  extend ::Bundler::Thor::Invocation::ClassMethods
+  def self.banner(command, namespace=T.unsafe(nil), subcommand=T.unsafe(nil)); end
 
-  def <<(num); end
+  def self.check_unknown_options!(options=T.unsafe(nil)); end
 
-  def ==(other); end
+  def self.command_help(shell, command_name); end
 
-  def ===(other); end
+  def self.default_command(meth=T.unsafe(nil)); end
 
-  def >>(num); end
+  def self.default_task(meth=T.unsafe(nil)); end
 
-  def eql?(other); end
+  def self.deprecation_warning(message); end
 
-  def family(); end
+  def self.desc(usage, description, options=T.unsafe(nil)); end
 
-  def hton(); end
+  def self.disable_required_check(); end
 
-  def include?(other); end
+  def self.disable_required_check!(*command_names); end
 
-  def initialize(addr=T.unsafe(nil), family=T.unsafe(nil)); end
+  def self.disable_required_check?(command); end
 
-  def ip6_arpa(); end
+  def self.dispatch(meth, given_args, given_opts, config); end
 
-  def ip6_int(); end
+  def self.dynamic_command_class(); end
 
-  def ipv4?(); end
+  def self.find_command_possibilities(meth); end
 
-  def ipv4_compat(); end
+  def self.find_task_possibilities(meth); end
 
-  def ipv4_compat?(); end
+  def self.help(shell, subcommand=T.unsafe(nil)); end
 
-  def ipv4_mapped(); end
+  def self.long_desc(long_description, options=T.unsafe(nil)); end
 
-  def ipv4_mapped?(); end
+  def self.map(mappings=T.unsafe(nil), **kw); end
 
-  def ipv6?(); end
+  def self.method_option(name, options=T.unsafe(nil)); end
 
-  def link_local?(); end
+  def self.method_options(options=T.unsafe(nil)); end
 
-  def loopback?(); end
+  def self.normalize_command_name(meth); end
 
-  def mask(prefixlen); end
+  def self.normalize_task_name(meth); end
 
-  def mask!(mask); end
+  def self.option(name, options=T.unsafe(nil)); end
 
-  def native(); end
+  def self.options(options=T.unsafe(nil)); end
 
-  def prefix(); end
+  def self.package_name(name, _=T.unsafe(nil)); end
 
-  def prefix=(prefix); end
+  def self.printable_commands(all=T.unsafe(nil), subcommand=T.unsafe(nil)); end
 
-  def private?(); end
+  def self.printable_tasks(all=T.unsafe(nil), subcommand=T.unsafe(nil)); end
+
+  def self.register(klass, subcommand_name, usage, description, options=T.unsafe(nil)); end
+
+  def self.retrieve_command_name(args); end
+
+  def self.retrieve_task_name(args); end
+
+  def self.stop_on_unknown_option(); end
+
+  def self.stop_on_unknown_option!(*command_names); end
+
+  def self.stop_on_unknown_option?(command); end
+
+  def self.subcommand(subcommand, subcommand_class); end
+
+  def self.subcommand_classes(); end
+
+  def self.subcommand_help(cmd); end
+
+  def self.subcommands(); end
+
+  def self.subtask(subcommand, subcommand_class); end
+
+  def self.subtask_help(cmd); end
 
-  def reverse(); end
+  def self.subtasks(); end
 
-  def set(addr, *family); end
+  def self.task_help(shell, command_name); end
+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), color=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 succ(); end
+  def shell=(shell); end
 
-  def to_i(); end
+  def silence(&blk); end
 
-  def to_range(); end
+  def trace(e, newline=T.unsafe(nil), force=T.unsafe(nil)); end
 
-  def to_string(); end
+  def unprinted_warnings(); end
 
-  def |(other); end
+  def warn(msg, newline=T.unsafe(nil), color=T.unsafe(nil)); 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)
+  def yes?(msg); end
+  LEVELS = ::T.let(nil, ::T.untyped)
 end
 
-class IPAddr::AddressFamilyError
+class Bundler::UI::Shell
 end
 
-class IPAddr::AddressFamilyError
+module Bundler::URI
+  include ::Bundler::URI::RFC2396_REGEXP
+  ABS_PATH = ::T.let(nil, ::T.untyped)
+  ABS_URI = ::T.let(nil, ::T.untyped)
+  ABS_URI_REF = ::T.let(nil, ::T.untyped)
+  DEFAULT_PARSER = ::T.let(nil, ::T.untyped)
+  ESCAPED = ::T.let(nil, ::T.untyped)
+  FRAGMENT = ::T.let(nil, ::T.untyped)
+  HOST = ::T.let(nil, ::T.untyped)
+  OPAQUE = ::T.let(nil, ::T.untyped)
+  PORT = ::T.let(nil, ::T.untyped)
+  QUERY = ::T.let(nil, ::T.untyped)
+  REGISTRY = ::T.let(nil, ::T.untyped)
+  REL_PATH = ::T.let(nil, ::T.untyped)
+  REL_URI = ::T.let(nil, ::T.untyped)
+  REL_URI_REF = ::T.let(nil, ::T.untyped)
+  RFC3986_PARSER = ::T.let(nil, ::T.untyped)
+  SCHEME = ::T.let(nil, ::T.untyped)
+  TBLDECWWWCOMP_ = ::T.let(nil, ::T.untyped)
+  TBLENCWWWCOMP_ = ::T.let(nil, ::T.untyped)
+  UNSAFE = ::T.let(nil, ::T.untyped)
+  URI_REF = ::T.let(nil, ::T.untyped)
+  USERINFO = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+  VERSION_CODE = ::T.let(nil, ::T.untyped)
+  WEB_ENCODINGS_ = ::T.let(nil, ::T.untyped)
 end
 
-class IPAddr::Error
+class Bundler::URI::BadURIError
 end
 
-class IPAddr::Error
+class Bundler::URI::BadURIError
 end
 
-class IPAddr::InvalidAddressError
+class Bundler::URI::Error
 end
 
-class IPAddr::InvalidAddressError
+class Bundler::URI::Error
 end
 
-class IPAddr::InvalidPrefixError
+module Bundler::URI::Escape
+  def decode(*arg); end
+
+  def encode(*arg); end
+
+  def escape(*arg); end
+
+  def unescape(*arg); end
 end
 
-class IPAddr::InvalidPrefixError
+module Bundler::URI::Escape
 end
 
-class IPAddr
-  def self.new_ntoh(addr); end
+class Bundler::URI::FTP
+  def set_typecode(v); end
+
+  def typecode(); end
 
-  def self.ntop(addr); end
+  def typecode=(typecode); end
+  COMPONENT = ::T.let(nil, ::T.untyped)
+  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
+  TYPECODE = ::T.let(nil, ::T.untyped)
+  TYPECODE_PREFIX = ::T.let(nil, ::T.untyped)
 end
 
-class Integer
-  include ::JSON::Ext::Generator::GeneratorMethods::Integer
-  def allbits?(_); end
+class Bundler::URI::FTP
+  def self.new2(user, password, host, port, path, typecode=T.unsafe(nil), arg_check=T.unsafe(nil)); end
+end
 
-  def anybits?(_); end
+class Bundler::URI::File
+  def check_password(user); end
 
-  def digits(*_); end
+  def check_user(user); end
 
-  def nobits?(_); end
+  def check_userinfo(user); end
 
-  def pow(*_); end
+  def set_userinfo(v); end
+  COMPONENT = ::T.let(nil, ::T.untyped)
+  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
+end
 
-  def to_bn(); end
-  GMP_VERSION = ::T.let(nil, ::T.untyped)
+class Bundler::URI::File
 end
 
-class Integer
-  def self.sqrt(_); end
+class Bundler::URI::Generic
+  include ::Bundler::URI
+  include ::Bundler::URI::RFC2396_REGEXP
+  def +(oth); end
+
+  def -(oth); end
+
+  def ==(oth); end
+
+  def absolute(); end
+
+  def absolute?(); end
+
+  def coerce(oth); end
+
+  def component(); end
+
+  def component_ary(); end
+
+  def default_port(); end
+
+  def eql?(oth); end
+
+  def find_proxy(env=T.unsafe(nil)); end
+
+  def fragment(); end
+
+  def fragment=(v); end
+
+  def hierarchical?(); end
+
+  def host(); end
+
+  def host=(v); end
+
+  def hostname(); end
+
+  def hostname=(v); end
+
+  def initialize(scheme, userinfo, host, port, registry, path, opaque, query, fragment, parser=T.unsafe(nil), arg_check=T.unsafe(nil)); end
+
+  def merge(oth); end
+
+  def merge!(oth); end
+
+  def normalize(); end
+
+  def normalize!(); end
+
+  def opaque(); end
+
+  def opaque=(v); end
+
+  def parser(); end
+
+  def password(); end
+
+  def password=(password); end
+
+  def path(); end
+
+  def path=(v); end
+
+  def port(); end
+
+  def port=(v); end
+
+  def query(); end
+
+  def query=(v); end
+
+  def registry(); end
+
+  def registry=(v); end
+
+  def relative?(); end
+
+  def route_from(oth); end
+
+  def route_to(oth); end
+
+  def scheme(); end
+
+  def scheme=(v); end
+
+  def select(*components); end
+
+  def set_host(v); end
+
+  def set_opaque(v); end
+
+  def set_password(v); end
+
+  def set_path(v); end
+
+  def set_port(v); end
+
+  def set_registry(v); end
+
+  def set_scheme(v); end
+
+  def set_user(v); end
+
+  def set_userinfo(user, password=T.unsafe(nil)); end
+
+  def user(); end
+
+  def user=(user); end
+
+  def userinfo(); end
+
+  def userinfo=(userinfo); end
+  COMPONENT = ::T.let(nil, ::T.untyped)
+  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
+  USE_REGISTRY = ::T.let(nil, ::T.untyped)
 end
 
-class JSON::Ext::Generator::State
-  def self.from_state(_); end
+class Bundler::URI::Generic
+  def self.build(args); end
+
+  def self.build2(args); end
+
+  def self.component(); end
+
+  def self.default_port(); end
+
+  def self.use_proxy?(hostname, addr, port, no_proxy); end
+
+  def self.use_registry(); end
 end
 
-class JSON::Ext::Parser
-  def initialize(*_); end
-end
+class Bundler::URI::HTTP
+  def request_uri(); end
+  COMPONENT = ::T.let(nil, ::T.untyped)
+  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::URI::HTTP
+end
+
+class Bundler::URI::HTTPS
+  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::URI::HTTPS
+end
+
+class Bundler::URI::InvalidComponentError
+end
+
+class Bundler::URI::InvalidComponentError
+end
+
+class Bundler::URI::InvalidURIError
+end
+
+class Bundler::URI::InvalidURIError
+end
+
+class Bundler::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
+  COMPONENT = ::T.let(nil, ::T.untyped)
+  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
+  SCOPE = ::T.let(nil, ::T.untyped)
+  SCOPE_BASE = ::T.let(nil, ::T.untyped)
+  SCOPE_ONE = ::T.let(nil, ::T.untyped)
+  SCOPE_SUB = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::URI::LDAP
+end
+
+class Bundler::URI::LDAPS
+  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::URI::LDAPS
+end
+
+class Bundler::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
+  COMPONENT = ::T.let(nil, ::T.untyped)
+  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
+  EMAIL_REGEXP = ::T.let(nil, ::T.untyped)
+  HEADER_REGEXP = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::URI::MailTo
+end
+
+Bundler::URI::Parser = Bundler::URI::RFC2396_Parser
+
+Bundler::URI::REGEXP = Bundler::URI::RFC2396_REGEXP
+
+class Bundler::URI::RFC2396_Parser
+  include ::Bundler::URI::RFC2396_REGEXP
+  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 Bundler::URI::RFC2396_Parser
+end
+
+module Bundler::URI::RFC2396_REGEXP
+end
+
+module Bundler::URI::RFC2396_REGEXP::PATTERN
+  ABS_PATH = ::T.let(nil, ::T.untyped)
+  ABS_URI = ::T.let(nil, ::T.untyped)
+  ALNUM = ::T.let(nil, ::T.untyped)
+  ALPHA = ::T.let(nil, ::T.untyped)
+  DOMLABEL = ::T.let(nil, ::T.untyped)
+  ESCAPED = ::T.let(nil, ::T.untyped)
+  FRAGMENT = ::T.let(nil, ::T.untyped)
+  HEX = ::T.let(nil, ::T.untyped)
+  HIER_PART = ::T.let(nil, ::T.untyped)
+  HOST = ::T.let(nil, ::T.untyped)
+  HOSTNAME = ::T.let(nil, ::T.untyped)
+  HOSTPORT = ::T.let(nil, ::T.untyped)
+  IPV4ADDR = ::T.let(nil, ::T.untyped)
+  IPV6ADDR = ::T.let(nil, ::T.untyped)
+  IPV6REF = ::T.let(nil, ::T.untyped)
+  NET_PATH = ::T.let(nil, ::T.untyped)
+  OPAQUE_PART = ::T.let(nil, ::T.untyped)
+  PATH_SEGMENTS = ::T.let(nil, ::T.untyped)
+  PORT = ::T.let(nil, ::T.untyped)
+  QUERY = ::T.let(nil, ::T.untyped)
+  REG_NAME = ::T.let(nil, ::T.untyped)
+  REL_PATH = ::T.let(nil, ::T.untyped)
+  REL_SEGMENT = ::T.let(nil, ::T.untyped)
+  REL_URI = ::T.let(nil, ::T.untyped)
+  RESERVED = ::T.let(nil, ::T.untyped)
+  SCHEME = ::T.let(nil, ::T.untyped)
+  TOPLABEL = ::T.let(nil, ::T.untyped)
+  UNRESERVED = ::T.let(nil, ::T.untyped)
+  URIC = ::T.let(nil, ::T.untyped)
+  URIC_NO_SLASH = ::T.let(nil, ::T.untyped)
+  URI_REF = ::T.let(nil, ::T.untyped)
+  USERINFO = ::T.let(nil, ::T.untyped)
+  X_ABS_URI = ::T.let(nil, ::T.untyped)
+  X_REL_URI = ::T.let(nil, ::T.untyped)
+end
+
+module Bundler::URI::RFC2396_REGEXP::PATTERN
+end
+
+module Bundler::URI::RFC2396_REGEXP
+end
+
+class Bundler::URI::RFC3986_Parser
+  def join(*uris); end
+
+  def parse(uri); end
+
+  def regexp(); end
+
+  def split(uri); end
+  RFC3986_URI = ::T.let(nil, ::T.untyped)
+  RFC3986_relative_ref = ::T.let(nil, ::T.untyped)
+end
+
+class Bundler::URI::RFC3986_Parser
+end
+
+module Bundler::URI::Util
+end
+
+module Bundler::URI::Util
+  def self.make_components_hash(klass, array_hash); end
+end
+
+module Bundler::URI
+  extend ::Bundler::URI::Escape
+  def self.decode_www_form(str, enc=T.unsafe(nil), separator: T.unsafe(nil), use__charset_: T.unsafe(nil), isindex: T.unsafe(nil)); end
+
+  def self.decode_www_form_component(str, enc=T.unsafe(nil)); end
+
+  def self.encode_www_form(enum, enc=T.unsafe(nil)); end
+
+  def self.encode_www_form_component(str, enc=T.unsafe(nil)); end
+
+  def self.extract(str, schemes=T.unsafe(nil), &block); end
+
+  def self.get_encoding(label); end
+
+  def self.join(*str); end
+
+  def self.parse(uri); end
+
+  def self.regexp(schemes=T.unsafe(nil)); end
+
+  def self.scheme_list(); end
+
+  def self.split(uri); end
+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 Bundler
+  def self.most_specific_locked_platform?(platform); end
+
+  def self.original_exec(*args); end
+
+  def self.original_system(*args); end
+
+  def self.preferred_gemfile_name(); end
+
+  def self.reset_settings_and_root!(); end
+
+  def self.unbundled_env(); end
+
+  def self.unbundled_exec(*args); end
+
+  def self.unbundled_system(*args); end
+end
+
+class Class
+  def json_creatable?(); end
+end
+
+module Concurrent
+  NULL = ::T.let(nil, ::T.untyped)
+  NULL_LOGGER = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+class Concurrent::AbstractExecutorService
+  FALLBACK_POLICIES = ::T.let(nil, ::T.untyped)
+end
+
+Concurrent::Collection::MapImplementation = Concurrent::Collection::MriMapBackend
+
+class Concurrent::ConcurrentUpdateError
+  CONC_UP_ERR_BACKTRACE = ::T.let(nil, ::T.untyped)
+end
+
+class Concurrent::LockFreeStack
+  EMPTY = ::T.let(nil, ::T.untyped)
+end
+
+class Concurrent::MVar
+  EMPTY = ::T.let(nil, ::T.untyped)
+  TIMEOUT = ::T.let(nil, ::T.untyped)
+end
+
+class Concurrent::Maybe
+  NONE = ::T.let(nil, ::T.untyped)
+end
+
+module Concurrent::Promises::InternalStates
+  PENDING = ::T.let(nil, ::T.untyped)
+  RESERVED = ::T.let(nil, ::T.untyped)
+  RESOLVED = ::T.let(nil, ::T.untyped)
+end
+
+class Concurrent::ReadWriteLock
+  MAX_READERS = ::T.let(nil, ::T.untyped)
+  MAX_WRITERS = ::T.let(nil, ::T.untyped)
+  RUNNING_WRITER = ::T.let(nil, ::T.untyped)
+  WAITING_WRITER = ::T.let(nil, ::T.untyped)
+end
+
+class Concurrent::ReentrantReadWriteLock
+  MAX_READERS = ::T.let(nil, ::T.untyped)
+  MAX_WRITERS = ::T.let(nil, ::T.untyped)
+  READER_BITS = ::T.let(nil, ::T.untyped)
+  READ_LOCK_MASK = ::T.let(nil, ::T.untyped)
+  RUNNING_WRITER = ::T.let(nil, ::T.untyped)
+  WAITING_WRITER = ::T.let(nil, ::T.untyped)
+  WRITER_BITS = ::T.let(nil, ::T.untyped)
+  WRITE_LOCK_HELD = ::T.let(nil, ::T.untyped)
+  WRITE_LOCK_MASK = ::T.let(nil, ::T.untyped)
+end
+
+class Concurrent::RubyThreadPoolExecutor
+  DEFAULT_MAX_POOL_SIZE = ::T.let(nil, ::T.untyped)
+  DEFAULT_MAX_QUEUE_SIZE = ::T.let(nil, ::T.untyped)
+  DEFAULT_MIN_POOL_SIZE = ::T.let(nil, ::T.untyped)
+  DEFAULT_SYNCHRONOUS = ::T.let(nil, ::T.untyped)
+  DEFAULT_THREAD_IDLETIMEOUT = ::T.let(nil, ::T.untyped)
+end
+
+class Concurrent::SerializedExecutionDelegator
+  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
+end
+
+Concurrent::Synchronization::Volatile = Concurrent::Synchronization::MriAttrVolatile
+
+class Concurrent::SynchronizedDelegator
+  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
+end
+
+module Concurrent::ThreadSafe::Util
+  CPU_COUNT = ::T.let(nil, ::T.untyped)
+  FIXNUM_BIT_SIZE = ::T.let(nil, ::T.untyped)
+  MAX_INT = ::T.let(nil, ::T.untyped)
+end
+
+class Concurrent::TimerTask
+  EXECUTION_INTERVAL = ::T.let(nil, ::T.untyped)
+  TIMEOUT_INTERVAL = ::T.let(nil, ::T.untyped)
+end
+
+class Concurrent::Transaction
+  ABORTED = ::T.let(nil, ::T.untyped)
+end
+
+module Concurrent::Utility::NativeInteger
+  MAX_VALUE = ::T.let(nil, ::T.untyped)
+  MIN_VALUE = ::T.let(nil, ::T.untyped)
+end
+
+class Delegator
+  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
+end
+
+class DidYouMean::ClassNameChecker
+  def class_name(); end
+
+  def class_names(); end
+
+  def corrections(); end
+
+  def initialize(exception); end
+
+  def scopes(); end
+end
+
+class DidYouMean::CorrectElement
+  def call(names, element); end
+end
+
+class DidYouMean::CorrectElement
+end
+
+module DidYouMean::Correctable
+  def corrections(); end
+
+  def original_message(); end
+
+  def spell_checker(); end
+
+  def to_s(); end
+end
+
+module DidYouMean::Jaro
+  def self.distance(str1, str2); end
+end
+
+module DidYouMean::JaroWinkler
+  def self.distance(str1, str2); end
+end
+
+class DidYouMean::KeyErrorChecker
+  def corrections(); end
+
+  def initialize(key_error); end
+end
+
+class DidYouMean::KeyErrorChecker
+end
+
+module DidYouMean::Levenshtein
+  def self.distance(str1, str2); end
+
+  def self.min3(a, b, c); end
+end
+
+class DidYouMean::MethodNameChecker
+  def corrections(); end
+
+  def initialize(exception); end
+
+  def method_name(); end
+
+  def method_names(); end
+
+  def names_to_exclude(); end
+
+  def receiver(); end
+  RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped)
+end
+
+class DidYouMean::NullChecker
+  def corrections(); end
+
+  def initialize(*_); end
+end
+
+class DidYouMean::ParseDimensions
+  def call(); end
+
+  def initialize(dictionary, separator); end
+end
+
+class DidYouMean::ParseDimensions
+end
+
+class DidYouMean::PlainFormatter
+  def message_for(corrections); end
+end
+
+class DidYouMean::PlainFormatter
+end
+
+class DidYouMean::TreeSpellChecker
+  def augment(); end
+
+  def correct(input); end
+
+  def dictionary(); end
+
+  def dimensions(); end
+
+  def initialize(dictionary:, separator: T.unsafe(nil), augment: T.unsafe(nil)); end
+
+  def separator(); end
+end
+
+class DidYouMean::TreeSpellChecker
+end
+
+class DidYouMean::VariableNameChecker
+  def corrections(); end
+
+  def cvar_names(); end
+
+  def initialize(exception); end
+
+  def ivar_names(); end
+
+  def lvar_names(); end
+
+  def method_names(); end
+
+  def name(); end
+  RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped)
+end
+
+module DidYouMean
+  def self.correct_error(error_class, spell_checker); end
+
+  def self.formatter(); end
+
+  def self.formatter=(formatter); end
+end
+
+class Dir
+  def children(); end
+
+  def each_child(); end
+end
+
+module Dir::Tmpname
+  UNUSABLE_CHARS = ::T.let(nil, ::T.untyped)
+end
+
+class Dir
+  def self.exists?(_); end
+end
+
+class ERB
+  def def_method(mod, methodname, fname=T.unsafe(nil)); end
+
+  def def_module(methodname=T.unsafe(nil)); end
+end
+
+class Encoding
+  def _dump(*_); end
+  CESU_8 = ::T.let(nil, ::T.untyped)
+end
+
+class Encoding::Converter
+  def initialize(*_); end
+end
+
+class Encoding
+  def self._load(_); end
+end
+
+module Enumerable
+  def sum(*_); 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 eager(); end
+end
+
+class Enumerator::Producer
+  def each(&blk); end
+end
+
+class Enumerator::Producer
+end
+
+class Enumerator::Yielder
+  def to_proc(); end
+end
+
+class Enumerator
+  def self.produce(*_); 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
+
+module Etc
+  VERSION = ::T.let(nil, ::T.untyped)
+end
+
+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 ExitCalledError
+end
+
+class ExitCalledError
+end
+
+class FalseClass
+  include ::JSON::Ext::Generator::GeneratorMethods::FalseClass
+end
+
+class Fiber
+  def initialize(*_); end
+end
+
+class File
+  def self.absolute_path?(_); end
+
+  def self.exists?(_); end
+end
+
+module FileUtils
+  include ::FileUtils::StreamUtils_
+  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
+
+class Float
+  include ::JSON::Ext::Generator::GeneratorMethods::Float
+end
+
+module Forwardable
+  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
+
+class FrozenError
+  def receiver(); end
+end
+
+module GC
+  def garbage_collect(full_mark: T.unsafe(nil), immediate_mark: T.unsafe(nil), immediate_sweep: T.unsafe(nil)); end
+end
+
+module GC
+  def self.verify_transient_heap_internal_consistency(); end
+end
+
+module Gem
+  ConfigMap = ::T.let(nil, ::T.untyped)
+  RbConfigPriorities = ::T.let(nil, ::T.untyped)
+  RubyGemsVersion = ::T.let(nil, ::T.untyped)
+  UNTAINT = ::T.let(nil, ::T.untyped)
+end
+
+class Gem::Dependency
+  def pretty_print(q); end
+end
+
+class Gem::Exception
+  extend ::Gem::Deprecate
+end
+
+class Gem::Ext::BuildError
+end
+
+class Gem::Ext::BuildError
+end
+
+class Gem::Ext::ExtConfBuilder
+end
+
+Gem::Ext::ExtConfBuilder::FileEntry = FileUtils::Entry_
+
+class Gem::Ext::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
+
+Gem::Installer::ExtensionBuildError = Gem::Ext::BuildError
+
+class Gem::Installer::FakePackage
+  def copy_to(path); end
+
+  def data_mode(); end
+
+  def data_mode=(data_mode); end
+
+  def dir_mode(); end
+
+  def dir_mode=(dir_mode); end
+
+  def extract_files(destination_dir, pattern=T.unsafe(nil)); end
+
+  def initialize(spec); end
+
+  def prog_mode(); end
+
+  def prog_mode=(prog_mode); end
+
+  def spec(); end
+
+  def spec=(spec); end
+end
+
+class Gem::Installer::FakePackage
+end
+
+class Gem::List
+  def pretty_print(q); end
+end
+
+class Gem::Package
+  def gem(); end
+end
+
+class Gem::Package::DigestIO
+  def digests(); end
+
+  def initialize(io, digests); end
+
+  def write(data); end
+end
+
+class Gem::Package::DigestIO
+  def self.wrap(io, digests); end
+end
+
+class Gem::Package::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 Gem::Package::FileSource
+end
+
+class Gem::Package::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 Gem::Package::IOSource
+end
+
+class Gem::Package::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 Gem::Package::Old
+end
+
+class Gem::Package::Source
+end
+
+class Gem::Package::Source
+end
+
+class Gem::Package::TarHeader
+  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
+  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)
+end
+
+class Gem::Package::TarHeader
+  def self.from(stream); end
+
+  def self.oct_or_256based(str); end
+
+  def self.strict_oct(str); end
+end
+
+class Gem::Package::TarReader::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
 
-JSON::Parser = JSON::Ext::Parser
+  def initialize(header, io); end
 
-JSON::State = JSON::Ext::Generator::State
+  def length(); end
 
-JSON::UnparserError = JSON::GeneratorError
+  def pos(); end
 
-module Kernel
-  def gem(dep, *reqs); end
+  def read(len=T.unsafe(nil)); end
 
-  def itself(); end
+  def readpartial(maxlen=T.unsafe(nil), outbuf=T.unsafe(nil)); end
 
-  def object_id(); end
+  def rewind(); end
 
-  def respond_to?(*_); end
+  def size(); end
 
-  def then(); end
+  def symlink?(); end
+end
 
-  def yield_self(); end
+class Gem::Package::TarReader::Entry
 end
 
-module Kernel
-  def self.at_exit(); end
+class Gem::Package::TarReader
+  def self.new(io); end
 end
 
-class KeyError
-  include ::DidYouMean::Correctable
-  def key(); end
+class Gem::Package::TarWriter
+  def self.new(io); end
+end
 
-  def receiver(); end
+class Gem::Package
+  def self.new(gem, security_policy=T.unsafe(nil)); end
+
+  def self.raw_spec(path, security_policy=T.unsafe(nil)); end
 end
 
-class LoadError
+class Gem::PathSupport
+  def home(); end
+
+  def initialize(env); end
+
   def path(); end
+
+  def spec_cache_dir(); end
 end
 
-class LocalJumpError
-  def exit_value(); end
+class Gem::RemoteFetcher::FetchError
+  include ::Gem::UriParsing
+  def initialize(message, uri); end
 
-  def reason(); end
-end
+  def uri(); end
 
-class Logger
-  SEV_LABEL = ::T.let(nil, ::T.untyped)
+  def uri=(uri); end
 end
 
-class Logger::Formatter
-  Format = ::T.let(nil, ::T.untyped)
+class Gem::RemoteFetcher::FetchError
 end
 
-class Logger::LogDevice
-  include ::MonitorMixin
+class Gem::RemoteFetcher::UnknownHostError
 end
 
-module Logger::Period
-  SiD = ::T.let(nil, ::T.untyped)
+class Gem::RemoteFetcher::UnknownHostError
 end
 
-module Marshal
-  def self.restore(*_); end
+class Gem::Request
+  extend ::Gem::UserInteraction
+  extend ::Gem::DefaultUserInteraction
+  extend ::Gem::Text
 end
 
-class Module
-  def deprecate_constant(*_); end
-
-  def undef_method(*_); end
+class Gem::RequestSet
+  def pretty_print(q); end
 end
 
-class Module
-  def self.used_modules(); end
+class Gem::Requirement
+  include ::Gem::Requirement::OrderIndependentComparison
+  include ::Gem::Requirement::CorrectHashForLambdaOperator
+  def pretty_print(q); end
 end
 
-class Monitor
-  def enter(); end
-
-  def exit(); end
-
-  def try_enter(); end
+module Gem::Requirement::CorrectHashForLambdaOperator
+  def hash(); end
 end
 
-module MonitorMixin
-  def initialize(*args); end
-
-  def mon_enter(); end
+module Gem::Requirement::CorrectHashForLambdaOperator
+end
 
-  def mon_exit(); end
+module Gem::Requirement::OrderIndependentComparison
+  def ==(other); end
 
-  def mon_locked?(); end
+  def _requirements_sorted?(); end
 
-  def mon_owned?(); end
+  def _with_sorted_requirements(); end
+end
 
-  def mon_synchronize(); end
+module Gem::Requirement::OrderIndependentComparison
+end
 
-  def mon_try_enter(); end
+class Gem::Resolver::APISet
+  def pretty_print(q); end
+end
 
-  def new_cond(); end
+class Gem::Resolver::APISpecification
+  def pretty_print(q); end
+end
 
-  def synchronize(); end
+class Gem::Resolver::ActivationRequest
+  def pretty_print(q); end
+end
 
-  def try_mon_enter(); end
-  EXCEPTION_IMMEDIATE = ::T.let(nil, ::T.untyped)
-  EXCEPTION_NEVER = ::T.let(nil, ::T.untyped)
+class Gem::Resolver::BestSet
+  def pretty_print(q); end
 end
 
-class MonitorMixin::ConditionVariable
-  def broadcast(); end
+class Gem::Resolver::Conflict
+  def pretty_print(q); end
+end
 
-  def initialize(monitor); end
+class Gem::Resolver::CurrentSet
+end
 
-  def signal(); end
+class Gem::Resolver::CurrentSet
+end
 
-  def wait(timeout=T.unsafe(nil)); end
+class Gem::Resolver::DependencyRequest
+  def pretty_print(q); end
+end
 
-  def wait_until(); end
+class Gem::Resolver::GitSet
+  def pretty_print(q); end
+end
 
-  def wait_while(); end
+class Gem::Resolver::GitSpecification
+  def pretty_print(q); end
 end
 
-module MonitorMixin
-  def self.extend_object(obj); end
+class Gem::Resolver::IndexSet
+  def pretty_print(q); end
 end
 
-class NameError
-  include ::DidYouMean::Correctable
-  def name(); end
+class Gem::Resolver::IndexSpecification
+  def pretty_print(q); end
+end
 
-  def receiver(); end
+class Gem::Resolver::InstalledSpecification
+  def pretty_print(q); end
 end
 
-class NilClass
-  include ::JSON::Ext::Generator::GeneratorMethods::NilClass
-  def to_i(); end
+class Gem::Resolver::InstallerSet
+  def pretty_print(q); end
 end
 
-class NoMethodError
-  def args(); end
+class Gem::Resolver::LocalSpecification
+  def pretty_print(q); end
+end
 
-  def private_call?(); end
+class Gem::Resolver::LocalSpecification
 end
 
-class Object
-  include ::JSON::Ext::Generator::GeneratorMethods::Object
-  include ::Persistent💎
-  include ::Persistent💎::JRubyWorkaround
-  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)
+class Gem::Resolver::LockSet
+  def pretty_print(q); end
 end
 
-class ObjectSpace::WeakMap
-  def [](_); end
+class Gem::Resolver::LockSpecification
+  def pretty_print(q); end
+end
 
-  def []=(_, _1); end
+class Gem::Resolver::Molinillo::DependencyGraph::Log
+  def add_edge_no_circular(graph, origin, destination, requirement); end
 
-  def each(&blk); end
+  def add_vertex(graph, name, payload, root); end
 
-  def each_key(); end
+  def delete_edge(graph, origin_name, destination_name, requirement); end
 
-  def each_pair(); end
+  def detach_vertex_named(graph, name); end
 
-  def each_value(); end
+  def each(&blk); end
 
-  def key?(_); end
+  def pop!(graph); end
 
-  def keys(); end
+  def reverse_each(); end
 
-  def length(); end
+  def rewind_to(graph, tag); end
 
-  def size(); end
+  def set_payload(graph, name, payload); end
 
-  def values(); end
+  def tag(graph, tag); end
 end
 
-module ObjectSpace
-  def self.count_objects(*_); end
-
-  def self.define_finalizer(*_); end
-
-  def self.garbage_collect(*_); end
+class Gem::Resolver::Molinillo::DependencyGraph::Log
+  extend ::Enumerable
+end
 
-  def self.undefine_finalizer(_); end
+class Gem::Resolver::VendorSet
+  def pretty_print(q); end
 end
 
-class Pathname
-  def empty?(); end
+class Gem::RuntimeRequirementNotMetError
+  def suggestion(); end
 
-  def fnmatch?(*_); end
+  def suggestion=(suggestion); end
+end
 
-  def glob(*_); end
+class Gem::RuntimeRequirementNotMetError
+end
 
-  def make_symlink(_); end
+class Gem::Security::Exception
 end
 
-class Proc
-  def <<(_); end
+class Gem::Security::Exception
+end
 
-  def ===(*_); end
+class Gem::Security::KEY_ALGORITHM
+  def d(); end
 
-  def >>(_); end
+  def dmp1(); end
 
-  def clone(); end
+  def dmq1(); end
 
-  def yield(*_); end
-end
+  def e(); end
 
-module Process::Sys
-  def self.getegid(); end
-end
+  def export(*_); end
 
-class Process::Tms
-  def cstime(); end
+  def initialize(*_); end
 
-  def cstime=(_); end
+  def iqmp(); end
 
-  def cutime(); end
+  def n(); end
 
-  def cutime=(_); end
+  def p(); end
 
-  def stime(); end
+  def params(); end
 
-  def stime=(_); end
+  def private?(); end
 
-  def utime(); end
+  def private_decrypt(*_); end
 
-  def utime=(_); end
-end
+  def private_encrypt(*_); end
 
-class Process::Tms
-  def self.[](*_); end
+  def public?(); end
 
-  def self.members(); end
-end
+  def public_decrypt(*_); end
 
-module Process
-  def self.last_status(); end
+  def public_encrypt(*_); end
 
-  def self.setpgrp(); end
-end
+  def public_key(); end
 
-module Random::Formatter
-  def alphanumeric(n=T.unsafe(nil)); end
-  ALPHANUMERIC = ::T.let(nil, ::T.untyped)
-end
+  def q(); end
 
-class Random
-  extend ::Random::Formatter
-  def self.bytes(_); end
+  def set_crt_params(_, _1, _2); end
 
-  def self.urandom(_); end
-end
+  def set_factors(_, _1); end
 
-class Range
-  def %(_); end
+  def set_key(_, _1, _2); end
 
-  def entries(); end
+  def sign_pss(*_); end
 
-  def to_a(); end
-end
+  def to_der(); end
 
-module RbConfig
-  def self.expand(val, config=T.unsafe(nil)); end
+  def to_pem(*_); end
 
-  def self.fire_update!(key, val, mkconf=T.unsafe(nil), conf=T.unsafe(nil)); end
+  def to_s(*_); end
 
-  def self.ruby(); end
-end
+  def to_text(); end
 
-class Regexp
-  def match?(*_); end
+  def verify_pss(*_); end
+  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)
 end
 
-class Regexp
-  def self.union(*_); end
+class Gem::Security::KEY_ALGORITHM
+  def self.generate(*_); end
 end
 
-module RubyVM::AbstractSyntaxTree
-end
+class Gem::Security::Policy
+  include ::Gem::UserInteraction
+  include ::Gem::DefaultUserInteraction
+  include ::Gem::Text
+  def check_cert(signer, issuer, time); end
 
-class RubyVM::AbstractSyntaxTree::Node
-  def children(); end
+  def check_chain(chain, time); end
 
-  def first_column(); end
+  def check_data(public_key, digest, signature, data); end
 
-  def first_lineno(); end
+  def check_key(signer, key); end
 
-  def last_column(); end
+  def check_root(chain, time); end
 
-  def last_lineno(); end
+  def check_trust(chain, digester, trust_dir); end
 
-  def type(); end
-end
+  def initialize(name, policy=T.unsafe(nil), opt=T.unsafe(nil)); end
 
-class RubyVM::AbstractSyntaxTree::Node
-end
+  def name(); end
 
-module RubyVM::AbstractSyntaxTree
-  def self.of(_); end
+  def only_signed(); end
 
-  def self.parse(_); end
+  def only_signed=(only_signed); end
 
-  def self.parse_file(_); end
-end
+  def only_trusted(); end
 
-class RubyVM::InstructionSequence
-  def absolute_path(); end
+  def only_trusted=(only_trusted); end
 
-  def base_label(); end
+  def subject(certificate); end
 
-  def disasm(); end
+  def verify(chain, key=T.unsafe(nil), digests=T.unsafe(nil), signatures=T.unsafe(nil), full_name=T.unsafe(nil)); end
 
-  def disassemble(); end
+  def verify_chain(); end
 
-  def each_child(); end
+  def verify_chain=(verify_chain); end
 
-  def eval(); end
+  def verify_data(); end
 
-  def first_lineno(); end
+  def verify_data=(verify_data); end
 
-  def label(); end
+  def verify_root(); end
 
-  def path(); end
+  def verify_root=(verify_root); end
 
-  def to_a(); end
+  def verify_signatures(spec, digests, signatures); end
 
-  def to_binary(*_); end
+  def verify_signer(); end
 
-  def trace_points(); end
+  def verify_signer=(verify_signer); end
 end
 
-class RubyVM::InstructionSequence
-  def self.compile(*_); end
+class Gem::Security::Policy
+end
 
-  def self.compile_file(*_); end
+class Gem::Security::Signer
+  include ::Gem::UserInteraction
+  include ::Gem::DefaultUserInteraction
+  include ::Gem::Text
+  def cert_chain(); end
 
-  def self.compile_option(); end
+  def cert_chain=(cert_chain); end
 
-  def self.compile_option=(compile_option); end
+  def digest_algorithm(); end
 
-  def self.disasm(_); end
+  def digest_name(); end
 
-  def self.disassemble(_); end
+  def extract_name(cert); end
 
-  def self.load_from_binary(_); end
+  def initialize(key, cert_chain, passphrase=T.unsafe(nil), options=T.unsafe(nil)); end
 
-  def self.load_from_binary_extra_data(_); end
+  def key(); end
 
-  def self.of(_); end
-end
+  def key=(key); end
 
-module RubyVM::MJIT
-end
+  def load_cert_chain(); end
 
-module RubyVM::MJIT
-  def self.enabled?(); end
+  def options(); end
 
-  def self.pause(*_); end
+  def re_sign_key(expiration_length: T.unsafe(nil)); end
 
-  def self.resume(); end
+  def sign(data); end
 end
 
-class RubyVM
-  def self.resolve_feature_path(_); end
-
-  def self.stat(*_); end
+class Gem::Security::Signer
+  def self.re_sign_cert(expired_cert, expired_cert_path, private_key); end
 end
 
-class Set
-  def ===(o); end
+class Gem::Security::TrustDir
+  def cert_path(certificate); end
 
-  def compare_by_identity(); end
+  def dir(); end
 
-  def compare_by_identity?(); end
+  def each_certificate(); end
 
-  def divide(&func); end
+  def initialize(dir, permissions=T.unsafe(nil)); end
 
-  def eql?(o); end
+  def issuer_of(certificate); end
 
-  def filter!(&block); end
+  def load_certificate(certificate_file); end
 
-  def pretty_print(pp); end
+  def name_path(name); end
 
-  def pretty_print_cycle(pp); end
+  def trust_cert(certificate); end
 
-  def reset(); end
-  InspectKey = ::T.let(nil, ::T.untyped)
+  def verify(); end
 end
 
-class SignalException
-  def signm(); end
-
-  def signo(); end
-end
+module Gem::Security
+  def self.alt_name_or_x509_entry(certificate, x509_entry); end
 
-module SingleForwardable
-  def def_delegator(accessor, method, ali=T.unsafe(nil)); end
+  def self.create_cert(subject, key, age=T.unsafe(nil), extensions=T.unsafe(nil), serial=T.unsafe(nil)); end
 
-  def def_delegators(accessor, *methods); end
+  def self.create_cert_email(email, key, age=T.unsafe(nil), extensions=T.unsafe(nil)); end
 
-  def def_single_delegator(accessor, method, ali=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 def_single_delegators(accessor, *methods); end
+  def self.create_key(length=T.unsafe(nil), algorithm=T.unsafe(nil)); end
 
-  def delegate(hash); end
+  def self.email_to_name(email_address); end
 
-  def single_delegate(hash); end
-end
+  def self.re_sign(expired_certificate, private_key, age=T.unsafe(nil), extensions=T.unsafe(nil)); end
 
-class Sorbet::Private::ConstantLookupCache
-  def all_module_aliases(); end
+  def self.reset(); end
 
-  def all_module_names(); end
+  def self.sign(certificate, signing_key, signing_cert, age=T.unsafe(nil), extensions=T.unsafe(nil), serial=T.unsafe(nil)); end
 
-  def all_named_modules(); end
+  def self.trust_dir(); end
 
-  def class_by_name(name); end
+  def self.trusted_certificates(&block); end
 
-  def name_by_class(klass); end
-  DEPRECATED_CONSTANTS = ::T.let(nil, ::T.untyped)
+  def self.write(pemmable, path, permissions=T.unsafe(nil), passphrase=T.unsafe(nil), cipher=T.unsafe(nil)); end
 end
 
-class Sorbet::Private::ConstantLookupCache::ConstantEntry
-  def aliases(); end
+class Gem::Source
+  def pretty_print(q); end
+end
 
-  def aliases=(_); end
+class Gem::SpecFetcher
+  include ::Gem::UserInteraction
+  include ::Gem::DefaultUserInteraction
+  include ::Gem::Text
+  def available_specs(type); end
 
-  def const(); end
+  def detect(type=T.unsafe(nil)); end
 
-  def const=(_); end
+  def initialize(sources=T.unsafe(nil)); end
 
-  def const_name(); end
+  def latest_specs(); end
 
-  def const_name=(_); end
+  def prerelease_specs(); end
 
-  def found_name(); end
+  def search_for_dependency(dependency, matching_platform=T.unsafe(nil)); end
 
-  def found_name=(_); end
+  def sources(); end
 
-  def owner(); end
+  def spec_for_dependency(dependency, matching_platform=T.unsafe(nil)); end
 
-  def owner=(_); end
+  def specs(); end
 
-  def primary_name(); end
+  def suggest_gems_from_name(gem_name, type=T.unsafe(nil)); end
 
-  def primary_name=(_); end
+  def tuples_for(source, type, gracefully_ignore=T.unsafe(nil)); end
 end
 
-class Sorbet::Private::ConstantLookupCache::ConstantEntry
-  def self.[](*_); end
-
-  def self.members(); end
-end
+class Gem::SpecFetcher
+  def self.fetcher(); end
 
-class Sorbet::Private::ConstantLookupCache
+  def self.fetcher=(fetcher); end
 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 Gem::Specification
+  include ::Bundler::MatchPlatform
+  include ::Bundler::GemHelpers
+  def pretty_print(q); end
 
-class Sorbet::Private::CreateConfig
-  def self.main(); end
+  def removed_method_calls(); end
 
-  def self.output_file(); end
+  def to_ruby(); end
+  REMOVED_METHODS = ::T.let(nil, ::T.untyped)
 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)
+class Gem::Specification
+  extend ::Gem::Deprecate
+  extend ::Enumerable
 end
 
-class Sorbet::Private::FetchRBIs
-  def self.fetch_sorbet_typed(); end
+class Gem::SpecificationPolicy
+  include ::Gem::UserInteraction
+  include ::Gem::DefaultUserInteraction
+  include ::Gem::Text
+  def initialize(specification); end
 
-  def self.main(); end
+  def packaging(); end
 
-  def self.matching_version_directories(root, version); end
+  def packaging=(packaging); end
 
-  def self.output_file(); end
+  def validate(strict=T.unsafe(nil)); end
 
-  def self.paths_for_gem_version(gemspec); end
+  def validate_dependencies(); end
 
-  def self.paths_for_ruby_version(ruby_version); end
+  def validate_metadata(); end
 
-  def self.vendor_rbis_within_paths(vendor_paths); end
+  def validate_permissions(); end
+  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)
 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)
+class Gem::SpecificationPolicy
 end
 
-class Sorbet::Private::FindGemRBIs
-  def self.main(); end
+class Gem::StreamUI
+  def _deprecated_debug(statement); end
+end
 
-  def self.output_file(); end
+class Gem::StubSpecification
+  def build_extensions(); end
 
-  def self.paths_within_gem_sources(gemspec); end
-end
+  def extensions(); end
 
-module Sorbet::Private::GemGeneratorTracepoint
-  include ::Sorbet::Private::StepInterface
-  OUTPUT = ::T.let(nil, ::T.untyped)
-end
+  def initialize(filename, base_dir, gems_dir, default_gem); end
 
-class Sorbet::Private::GemGeneratorTracepoint::ClassDefinition
-  def defs(); end
+  def missing_extensions?(); end
 
-  def defs=(_); end
+  def valid?(); end
+end
 
-  def id(); end
+class Gem::StubSpecification::StubLine
+  def extensions(); end
 
-  def id=(_); end
+  def full_name(); end
 
-  def klass(); end
+  def initialize(data, extensions); end
 
-  def klass=(_); end
-end
+  def name(); end
 
-class Sorbet::Private::GemGeneratorTracepoint::ClassDefinition
-  def self.[](*_); end
+  def platform(); end
 
-  def self.members(); end
+  def require_paths(); end
+
+  def version(); end
 end
 
-class Sorbet::Private::GemGeneratorTracepoint::TracepointSerializer
-  def initialize(files:, delegate_classes:); end
+class Gem::StubSpecification
+  def self.default_gemspec_stub(filename, base_dir, gems_dir); 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)
+  def self.gemspec_stub(filename, base_dir, gems_dir); end
 end
 
-class Sorbet::Private::GemGeneratorTracepoint::TracepointSerializer
+class Gem::UninstallError
+  def spec(); end
+
+  def spec=(spec); end
 end
 
-class Sorbet::Private::GemGeneratorTracepoint::Tracer
+class Gem::UninstallError
 end
 
-class Sorbet::Private::GemGeneratorTracepoint::Tracer
-  def self.add_to_context(item); end
+Gem::UnsatisfiableDepedencyError = Gem::UnsatisfiableDependencyError
 
-  def self.disable_tracepoints(); end
+class Gem::Version
+  def pretty_print(q); end
+end
 
-  def self.finish(); end
+Gem::Version::Requirement = Gem::Requirement
 
-  def self.install_tracepoints(); end
+module Hamster
+  EmptyDeque = ::T.let(nil, ::T.untyped)
+  EmptyHash = ::T.let(nil, ::T.untyped)
+  EmptySet = ::T.let(nil, ::T.untyped)
+  EmptySortedSet = ::T.let(nil, ::T.untyped)
+  EmptyTrie = ::T.let(nil, ::T.untyped)
+  EmptyVector = ::T.let(nil, ::T.untyped)
+  VERSION = ::T.let(nil, ::T.untyped)
+end
 
-  def self.on_method_added(mod, method, singleton); end
+module Hamster::EmptyList
+  extend ::Hamster::List
+  extend ::Hamster::Enumerable
+  extend ::Enumerable
+end
 
-  def self.on_module_created(mod); end
+class Hamster::LazyList
+  MUTEX = ::T.let(nil, ::T.untyped)
+  QUEUE = ::T.let(nil, ::T.untyped)
+end
 
-  def self.on_module_extended(extended, extender); end
+module Hamster::List
+  CADR = ::T.let(nil, ::T.untyped)
+end
 
-  def self.on_module_included(included, includer); end
+class Hamster::SortedSet::PlainAVLNode
+  EmptyNode = ::T.let(nil, ::T.untyped)
+end
 
-  def self.pre_cache_module_methods(); end
+class Hamster::Vector
+  BITS_PER_LEVEL = ::T.let(nil, ::T.untyped)
+  BLOCK_SIZE = ::T.let(nil, ::T.untyped)
+  INDEX_MASK = ::T.let(nil, ::T.untyped)
+end
 
-  def self.register_delegate_class(klass, delegate); end
+class Hash
+  include ::JSON::Ext::Generator::GeneratorMethods::Hash
+  def deconstruct_keys(_); end
+end
 
-  def self.start(); end
+class Hash
+  def self.ruby2_keywords_hash(_); end
 
-  def self.trace(); end
+  def self.ruby2_keywords_hash?(_); end
 
-  def self.trace_results(); end
+  def self.try_convert(_); end
 end
 
-module Sorbet::Private::GemGeneratorTracepoint
-  def self.main(output_dir=T.unsafe(nil)); end
+class IO
+  def nonblock(*_); end
 
-  def self.output_file(); end
-end
+  def nonblock=(nonblock); end
 
-class Sorbet::Private::GemLoader
-  GEM_LOADER = ::T.let(nil, ::T.untyped)
-  NO_GEM = ::T.let(nil, ::T.untyped)
-end
+  def nonblock?(); end
+
+  def nread(); end
 
-class Sorbet::Private::GemLoader
-  def self.my_require(gem); end
+  def pathconf(_); end
 
-  def self.require_all_gems(); end
+  def ready?(); end
 
-  def self.require_gem(gem); end
-end
+  def set_encoding_by_bom(); end
 
-class Sorbet::Private::HiddenMethodFinder
-  include ::Sorbet::Private::StepInterface
-  def all_modules_and_aliases(); end
+  def wait(*_); end
 
-  def capture_stderr(); end
+  def wait_readable(*_); end
 
-  def constant_cache(); end
+  def wait_writable(*_); end
+end
 
-  def gen_source_rbi(classes, aliases); end
+IO::EWOULDBLOCKWaitReadable = IO::EAGAINWaitReadable
 
-  def looks_like_stub_name(name); end
+IO::EWOULDBLOCKWaitWritable = IO::EAGAINWaitWritable
 
-  def main(); end
+class IPAddr
+  def ==(other); end
 
-  def mk_dir(); end
+  def initialize(addr=T.unsafe(nil), family=T.unsafe(nil)); end
+end
 
-  def read_constants(); end
+class Integer
+  include ::JSON::Ext::Generator::GeneratorMethods::Integer
+  def to_bn(); end
+  GMP_VERSION = ::T.let(nil, ::T.untyped)
+end
 
-  def real_name(mod); end
+class JSON::Ext::Generator::State
+  def self.from_state(_); end
+end
 
-  def require_everything(); end
+class JSON::Ext::Parser
+  def initialize(*_); end
+end
 
-  def rm_dir(); end
+JSON::Parser = JSON::Ext::Parser
 
-  def serialize_alias(source_entry, rbi_entry, my_klass, source_symbols, rbi_symbols); end
+JSON::State = JSON::Ext::Generator::State
 
-  def serialize_class(source_entry, rbi_entry, klass, source_symbols, rbi_symbols, source_by_name); end
+JSON::UnparserError = JSON::GeneratorError
 
-  def serialize_constants(source, rbi, klass, is_singleton, source_symbols, rbi_symbols); end
+module Kernel
+  def itself(); end
 
-  def symbols_id_to_name(entry, prefix); end
+  def object_id(); end
 
-  def write_constants(); end
+  def then(); 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)
+  def yield_self(); end
 end
 
-class Sorbet::Private::HiddenMethodFinder
-  def self.main(); end
-
-  def self.output_file(); end
+module Kernel
+  def self.at_exit(); end
 end
 
-module Sorbet::Private::Main
+class KeyError
+  include ::DidYouMean::Correctable
 end
 
-module Sorbet::Private::Main
-  def self.cyan(msg); end
-
-  def self.emojify(emoji, msg); end
+class Logger
+  def debug!(); end
 
-  def self.init(); end
+  def error!(); end
 
-  def self.main(argv); end
+  def fatal!(); end
 
-  def self.make_step(step); end
+  def info!(); end
 
-  def self.usage(); end
+  def warn!(); end
+  SEV_LABEL = ::T.let(nil, ::T.untyped)
+end
 
-  def self.yellow(msg); end
+class Logger::Formatter
+  Format = ::T.let(nil, ::T.untyped)
 end
 
-module Sorbet::Private::RealStdlib
+class Logger::LogDevice
+  include ::MonitorMixin
 end
 
-module Sorbet::Private::RealStdlib
-  def self.real_ancestors(mod); end
+module Logger::Period
+  SiD = ::T.let(nil, ::T.untyped)
+end
 
-  def self.real_autoload?(o, klass); end
+class Monitor
+  def enter(); end
 
-  def self.real_const_get(obj, const, arg); end
+  def exit(); end
 
-  def self.real_constants(mod); end
+  def mon_check_owner(); end
 
-  def self.real_eqeq(obj, other); end
+  def mon_enter(); end
 
-  def self.real_hash(o); end
+  def mon_exit(); end
 
-  def self.real_instance_methods(mod, arg); end
+  def mon_locked?(); end
 
-  def self.real_is_a?(o, klass); end
+  def mon_owned?(); end
 
-  def self.real_name(o); end
+  def mon_synchronize(); end
 
-  def self.real_object_id(o); end
+  def mon_try_enter(); end
 
-  def self.real_private_instance_methods(mod, arg); end
+  def new_cond(); end
 
-  def self.real_singleton_class(obj); end
+  def synchronize(); end
 
-  def self.real_singleton_methods(mod, arg); end
+  def try_enter(); end
 
-  def self.real_spaceship(obj, arg); end
+  def try_mon_enter(); end
 
-  def self.real_superclass(o); end
+  def wait_for_cond(_, _1); end
 end
 
-class Sorbet::Private::RequireEverything
+module MonitorMixin
+  def initialize(*args); end
 end
 
-class Sorbet::Private::RequireEverything
-  def self.excluded_rails_files(); end
+class MonitorMixin::ConditionVariable
+  def initialize(monitor); end
+end
 
-  def self.load_bundler(); end
+class NameError
+  include ::DidYouMean::Correctable
+end
 
-  def self.load_rails(); end
+class NilClass
+  include ::JSON::Ext::Generator::GeneratorMethods::NilClass
+end
 
-  def self.my_require(abs_path, numerator, denominator); end
+class NoMatchingPatternError
+end
 
-  def self.patch_kernel(); end
+class NoMatchingPatternError
+end
 
-  def self.rails?(); end
+class Object
+  include ::JSON::Ext::Generator::GeneratorMethods::Object
+  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
 
-  def self.rails_load_paths(); end
+class OpenStruct
+  VERSION = ::T.let(nil, ::T.untyped)
+end
 
-  def self.rb_file_paths(); end
+class Pathname
+  def fnmatch?(*_); end
 
-  def self.require_all_files(); end
+  def glob(*_); end
 
-  def self.require_everything(); end
+  def make_symlink(_); end
 end
 
-class Sorbet::Private::Serialize
-  def alias(base, other_name); end
+class Proc
+  def <<(_); end
 
-  def ancestor_has_method(method, klass); end
+  def >>(_); end
 
-  def blacklisted_method(method); end
+  def clone(); end
+end
 
-  def class_or_module(class_name); end
+module Process
+  CLOCK_TAI = ::T.let(nil, ::T.untyped)
+end
 
-  def comparable?(value); end
+module Rake::DSL
+  include ::FileUtils::StreamUtils_
+end
 
-  def constant(const, value); end
+module Rake::FileUtilsExt
+  include ::FileUtils::StreamUtils_
+  def rake_merge_option(args, defaults); end
+  DEFAULT = ::T.let(nil, ::T.untyped)
+end
 
-  def from_method(method); end
+module Rake::FileUtilsExt
+  extend ::FileUtils::StreamUtils_
+end
 
-  def initialize(constant_cache); end
+class Random
+  def self.bytes(_); end
+end
 
-  def serialize_method(method, static=T.unsafe(nil), with_sig: T.unsafe(nil)); end
+class Range
+  def %(_); end
 
-  def serialize_sig(parameters); end
+  def entries(); end
 
-  def to_sig(kind, name); end
+  def to_a(); end
+end
 
-  def valid_class_name(name); end
+module RbConfig
+  def self.expand(val, config=T.unsafe(nil)); 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
+  def self.fire_update!(key, val, mkconf=T.unsafe(nil), conf=T.unsafe(nil)); end
 
-class Sorbet::Private::Serialize
-  def self.header(typed=T.unsafe(nil), subcommand=T.unsafe(nil)); end
+  def self.ruby(); end
 end
 
-module Sorbet::Private::Status
+module RubyVM::MJIT
 end
 
-module Sorbet::Private::Status
-  def self.done(); end
+module RubyVM::MJIT
+  def self.enabled?(); end
 
-  def self.say(message, print_without_tty: T.unsafe(nil)); end
-end
+  def self.pause(*_); end
 
-module Sorbet::Private::StepInterface
+  def self.resume(); end
 end
 
-module Sorbet::Private::StepInterface
-  def self.main(); end
+class Set
+  def ===(o); end
 
-  def self.output_file(); end
-end
+  def compare_by_identity(); end
 
-class Sorbet::Private::SuggestTyped
-  include ::Sorbet::Private::StepInterface
-end
+  def compare_by_identity?(); end
 
-class Sorbet::Private::SuggestTyped
-  def self.main(); end
+  def divide(&func); end
 
-  def self.output_file(); end
+  def eql?(o); end
 
-  def self.suggest_typed(); end
-end
+  def pretty_print(pp); end
 
-class Sorbet::Private::TodoRBI
-  include ::Sorbet::Private::StepInterface
-  HEADER = ::T.let(nil, ::T.untyped)
-  OUTPUT = ::T.let(nil, ::T.untyped)
-end
+  def pretty_print_cycle(pp); end
 
-class Sorbet::Private::TodoRBI
-  def self.main(); end
+  def reset(); end
+  InspectKey = ::T.let(nil, ::T.untyped)
+end
 
-  def self.output_file(); end
+class SimpleDelegator
+  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
 end
 
 class SortedSet
@@ -2588,83 +4038,23 @@ class SortedSet
   def self.setup(); end
 end
 
-class StopIteration
-  def result(); end
-end
-
 class String
   include ::JSON::Ext::Generator::GeneratorMethods::String
-  def +@(); end
-
-  def -@(); end
-
-  def []=(*_); end
-
-  def casecmp?(_); end
-
-  def each_grapheme_cluster(); end
-
-  def encode(*_); end
-
-  def encode!(*_); end
-
-  def grapheme_clusters(); 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 Struct
-  def [](_); end
-
-  def []=(_, _1); end
+  def deconstruct(); end
 
-  def dig(*_); end
-
-  def each_pair(); end
+  def deconstruct_keys(_); 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
@@ -2673,28 +4063,18 @@ Struct::Passwd = Etc::Passwd
 
 Struct::Tms = Process::Tms
 
-class SystemCallError
-  def errno(); end
-end
-
-class SystemExit
-  def status(); end
-
-  def success?(); end
-end
-
 class TracePoint
-  def __enable(_, _1); end
-
   def eval_script(); end
 
-  def event(); end
-
   def instruction_sequence(); end
 
   def parameters(); end
 end
 
+class TracePoint
+  def self.new(*events); end
+end
+
 class TrueClass
   include ::JSON::Ext::Generator::GeneratorMethods::TrueClass
 end
@@ -2703,24 +4083,6 @@ 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
@@ -2740,10 +4102,6 @@ end
 class URI::File
 end
 
-class URI::HTTP
-  def request_uri(); end
-end
-
 class URI::LDAP
   def attributes(); end
 
@@ -2779,23 +4137,7 @@ class URI::LDAP
 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
@@ -2803,25 +4145,7 @@ 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
@@ -2841,37 +4165,16 @@ end
 
 module URI
   extend ::URI::Escape
-  def self.decode_www_form(str, enc=T.unsafe(nil), separator: T.unsafe(nil), use__charset_: T.unsafe(nil), isindex: T.unsafe(nil)); end
-
-  def self.encode_www_form(enum, enc=T.unsafe(nil)); end
-
-  def self.encode_www_form_component(str, enc=T.unsafe(nil)); end
-
   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 UnicodeNormalize
 end
 
 module UnicodeNormalize
 end
 
-module Warning
-  def warn(_); end
-end
-
 module Warning
   extend ::Warning
 end
+