RubyGems - persistent-dmnd - Versions diffs - 2.0.4 → 2.0.6 - Mend

persistent-dmnd 2.0.4 → 2.0.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (26) hide show

checksums.yaml +4 -4
data/.gitlab-ci.yml +54 -137
data/.standard.yml +4 -0
data/CODE_OF_CONDUCT.adoc +99 -45
data/README.adoc +1 -1
data/Rakefile +4 -3
data/lib/persistent_dmnd/array.rb +3 -3
data/lib/persistent_dmnd/concurrent_ruby_support.rb +1 -1
data/lib/persistent_dmnd/dmndifier.rb +10 -11
data/lib/persistent_dmnd/everywhere.rb +1 -1
data/lib/persistent_dmnd/hash.rb +3 -3
data/lib/persistent_dmnd/jruby_9_2_set_workaround.rb +31 -28
data/lib/persistent_dmnd/jruby_workaround.rb +3 -3
data/lib/persistent_dmnd/set.rb +7 -5
data/lib/persistent_dmnd/version.rb +1 -1
data/persistent-dmnd.gemspec +1 -5
metadata +16 -52
data/.ruby-version +0 -1
data/sorbet/config +0 -2
data/sorbet/rbi/gems/concurrent-ruby.rbi +0 -1660
data/sorbet/rbi/gems/hamster.rbi +0 -683
data/sorbet/rbi/hidden-definitions/errors.txt +0 -2552
data/sorbet/rbi/hidden-definitions/hidden.rbi +0 -4180
data/sorbet/rbi/sorbet-typed/lib/rake/all/rake.rbi +0 -645
data/sorbet/rbi/sorbet-typed/lib/rspec-core/all/rspec-core.rbi +0 -1891
data/sorbet/rbi/todo.rbi +0 -10

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

@@ -1,4180 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi hidden-definitions
-# typed: autogenerated
-class Array
-  include ::JSON::Ext::Generator::GeneratorMethods::Array
-  def deconstruct(); end
-  def shelljoin(); end
-  def to_h(); end
-end
-class Array
-  def self.try_convert(_); end
-end
-BasicObject::BasicObject = BasicObject
-class BasicSocket
-  def read_nonblock(len, str=T.unsafe(nil), exception: T.unsafe(nil)); end
-end
-class BigDecimal
-  def clone(); end
-  EXCEPTION_NaN = ::T.let(nil, ::T.untyped)
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-class BigDecimal
-  def self.interpret_loosely(_); end
-end
-class Binding
-  def clone(); end
-  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
-end
-class Bundler::Env
-  def self.environment(); end
-  def self.report(options=T.unsafe(nil)); end
-  def self.write(io); end
-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
-  def fetch_spec(spec); end
-  def fetchers(); end
-  def http_proxy(); end
-  def initialize(remote); end
-  def specs(gem_names, source); end
-  def specs_with_retry(gem_names, source); end
-  def uri(); end
-  def use_api(); end
-  def user_agent(); end
-  FAIL_ERRORS = ::T.let(nil, ::T.untyped)
-  FETCHERS = ::T.let(nil, ::T.untyped)
-  HTTP_ERRORS = ::T.let(nil, ::T.untyped)
-  NET_ERRORS = ::T.let(nil, ::T.untyped)
-end
-class Bundler::Fetcher::AuthenticationRequiredError
-  def initialize(remote_uri); end
-end
-class Bundler::Fetcher::BadAuthenticationError
-  def initialize(remote_uri); end
-end
-class Bundler::Fetcher::Base
-  def api_fetcher?(); end
-  def available?(); end
-  def display_uri(); end
-  def downloader(); end
-  def fetch_uri(); end
-  def initialize(downloader, remote, display_uri); end
-  def remote(); end
-  def remote_uri(); end
-end
-class Bundler::Fetcher::Base
-end
-class Bundler::Fetcher::CertificateFailureError
-  def initialize(remote_uri); end
-end
-class Bundler::Fetcher::CompactIndex
-  def available?(*args, &blk); end
-  def fetch_spec(*args, &blk); end
-  def specs(*args, &blk); end
-  def specs_for_names(gem_names); end
-end
-class Bundler::Fetcher::CompactIndex::ClientFetcher
-  def call(path, headers); end
-  def fetcher(); end
-  def fetcher=(_); end
-  def ui(); end
-  def ui=(_); end
-end
-class Bundler::Fetcher::CompactIndex::ClientFetcher
-  def self.[](*_); end
-  def self.members(); end
-end
-class Bundler::Fetcher::CompactIndex
-  def self.compact_index_request(method_name); end
-end
-class Bundler::Fetcher::Dependency
-  def dependency_api_uri(gem_names=T.unsafe(nil)); end
-  def dependency_specs(gem_names); end
-  def get_formatted_specs_and_deps(gem_list); end
-  def specs(gem_names, full_dependency_list=T.unsafe(nil), last_spec_list=T.unsafe(nil)); end
-  def unmarshalled_dep_gems(gem_names); end
-end
-class Bundler::Fetcher::Dependency
-end
-class Bundler::Fetcher::Downloader
-  def connection(); end
-  def fetch(uri, headers=T.unsafe(nil), counter=T.unsafe(nil)); end
-  def initialize(connection, redirect_limit); end
-  def redirect_limit(); end
-  def request(uri, headers); end
-end
-class Bundler::Fetcher::Downloader
-end
-class Bundler::Fetcher::Index
-  def fetch_spec(spec); end
-  def specs(_gem_names); end
-end
-class Bundler::Fetcher::Index
-end
-class Bundler::Fetcher::SSLError
-  def initialize(msg=T.unsafe(nil)); end
-end
-class Bundler::Fetcher::TooManyRequestsError
-end
-class Bundler::Fetcher::TooManyRequestsError
-end
-class Bundler::Fetcher
-  def self.api_timeout(); end
-  def self.api_timeout=(api_timeout); end
-  def self.disable_endpoint(); end
-  def self.disable_endpoint=(disable_endpoint); end
-  def self.max_retries(); end
-  def self.max_retries=(max_retries); end
-  def self.redirect_limit(); end
-  def self.redirect_limit=(redirect_limit); end
-end
-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
-  def already_tagged?(); end
-  def base(); end
-  def build_gem(); end
-  def built_gem_path(); end
-  def clean?(); end
-  def committed?(); end
-  def current_branch(); end
-  def default_remote(); end
-  def gem_command(); end
-  def gem_key(); end
-  def gem_push?(); end
-  def gem_push_host(); end
-  def gemspec(); end
-  def git_push(remote=T.unsafe(nil)); end
-  def guard_clean(); end
-  def initialize(base=T.unsafe(nil), name=T.unsafe(nil)); end
-  def install(); end
-  def install_gem(built_gem_path=T.unsafe(nil), local=T.unsafe(nil)); end
-  def name(); end
-  def perform_git_push(options=T.unsafe(nil)); end
-  def rubygem_push(path); end
-  def sh(cmd, &block); end
-  def sh_with_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
-  def version_tag(); end
-end
-class Bundler::GemHelper
-  def self.gemspec(&block); end
-  def self.install_tasks(opts=T.unsafe(nil)); end
-  def self.instance(); end
-  def self.instance=(instance); end
-  def self.tag_prefix=(prefix); end
-end
-class Bundler::GemHelpers::PlatformMatch
-  def self.specificity_score(spec_platform, user_platform); end
-end
-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
-  def initialize(locked_specs=T.unsafe(nil), unlock_gems=T.unsafe(nil)); end
-  def level(); end
-  def level=(value); end
-  def locked_specs(); end
-  def major?(); end
-  def minor?(); end
-  def prerelease_specified(); end
-  def prerelease_specified=(prerelease_specified); end
-  def sort_versions(dep, spec_groups); end
-  def strict(); end
-  def strict=(strict); end
-  def unlock_gems(); end
-  DEBUG = ::T.let(nil, ::T.untyped)
-end
-class Bundler::GemVersionPromoter
-end
-class Bundler::Graph
-  def edge_options(); end
-  def groups(); end
-  def initialize(env, output_file, show_version=T.unsafe(nil), show_requirements=T.unsafe(nil), output_format=T.unsafe(nil), without=T.unsafe(nil)); end
-  def node_options(); end
-  def output_file(); end
-  def output_format(); end
-  def relations(); end
-  def viz(); end
-  GRAPH_NAME = ::T.let(nil, ::T.untyped)
-end
-class Bundler::Graph::GraphVizClient
-  def g(); end
-  def initialize(graph_instance); end
-  def run(); end
-end
-class Bundler::Graph::GraphVizClient
-end
-class Bundler::Graph
-end
-class Bundler::Index
-  include ::Enumerable
-end
-class Bundler::Injector
-  def initialize(deps, options=T.unsafe(nil)); end
-  def inject(gemfile_path, lockfile_path); end
-  def remove(gemfile_path, lockfile_path); end
-  INJECTED_GEMS = ::T.let(nil, ::T.untyped)
-end
-class Bundler::Injector
-  def self.inject(new_deps, options=T.unsafe(nil)); end
-  def self.remove(gems, options=T.unsafe(nil)); end
-end
-class Bundler::Installer
-  def generate_bundler_executable_stubs(spec, options=T.unsafe(nil)); end
-  def generate_standalone_bundler_executable_stubs(spec, options=T.unsafe(nil)); end
-  def initialize(root, definition); end
-  def post_install_messages(); end
-  def run(options); end
-end
-class Bundler::Installer
-  def self.ambiguous_gems(); end
-  def self.ambiguous_gems=(ambiguous_gems); end
-  def self.install(root, definition, options=T.unsafe(nil)); end
-end
-class Bundler::LazySpecification
-  def eql?(other); end
-  def platform_string(); end
-end
-module Bundler::Molinillo::SpecificationProvider
-  def dependencies_equal?(dependencies, other_dependencies); end
-end
-module Bundler::Plugin::API::Source
-  def ==(other); end
-  def app_cache_dirname(); end
-  def app_cache_path(custom_path=T.unsafe(nil)); end
-  def bundler_plugin_api_source?(); end
-  def cache(spec, custom_path=T.unsafe(nil)); end
-  def cached!(); end
-  def can_lock?(spec); end
-  def dependency_names(); end
-  def dependency_names=(dependency_names); end
-  def double_check_for(*_); end
-  def eql?(other); end
-  def fetch_gemspec_files(); end
-  def gem_install_dir(); end
-  def hash(); end
-  def include?(other); end
-  def initialize(opts); end
-  def install(spec, opts); end
-  def install_path(); end
-  def installed?(); end
-  def name(); end
-  def options(); end
-  def options_to_lock(); end
-  def post_install(spec, disable_exts=T.unsafe(nil)); end
-  def remote!(); end
-  def root(); end
-  def specs(); end
-  def to_lock(); end
-  def to_s(); end
-  def unlock!(); end
-  def unmet_deps(); end
-  def uri(); end
-  def uri_hash(); end
-end
-module Bundler::Plugin::API::Source
-end
-module Bundler::Plugin::Events
-  GEM_AFTER_INSTALL = ::T.let(nil, ::T.untyped)
-  GEM_AFTER_INSTALL_ALL = ::T.let(nil, ::T.untyped)
-  GEM_BEFORE_INSTALL = ::T.let(nil, ::T.untyped)
-  GEM_BEFORE_INSTALL_ALL = ::T.let(nil, ::T.untyped)
-end
-class Bundler::Plugin::Index
-  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
-class Bundler::Plugin::Index::CommandConflict
-end
-class Bundler::Plugin::Index::SourceConflict
-  def initialize(plugin, sources); end
-end
-class Bundler::Plugin::Index::SourceConflict
-end
-class Bundler::Plugin::Installer
-  def install(names, options); end
-  def install_definition(definition); end
-end
-class Bundler::Plugin::Installer::Git
-  def generate_bin(spec, disable_extensions=T.unsafe(nil)); end
-end
-class Bundler::Plugin::Installer::Git
-end
-class Bundler::Plugin::Installer::Rubygems
-end
-class Bundler::Plugin::Installer::Rubygems
-end
-class Bundler::Plugin::Installer
-end
-class Bundler::Plugin::SourceList
-end
-class Bundler::Plugin::SourceList
-end
-module Bundler::Plugin
-  def self.list(); end
-  def self.uninstall(names, options); end
-end
-class Bundler::ProcessLock
-end
-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
-  def attempts(&block); end
-  def current_run(); end
-  def current_run=(current_run); end
-  def initialize(name, exceptions=T.unsafe(nil), retries=T.unsafe(nil)); end
-  def name(); end
-  def name=(name); end
-  def total_runs(); end
-  def total_runs=(total_runs); end
-end
-class Bundler::Retry
-  def self.attempts(); end
-  def self.default_attempts(); end
-  def self.default_retries(); end
-end
-class Bundler::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
-  def use_gemdeps(gemfile); end
-end
-class Bundler::Settings::Mirror
-  def ==(other); end
-  def fallback_timeout(); end
-  def fallback_timeout=(timeout); end
-  def initialize(uri=T.unsafe(nil), fallback_timeout=T.unsafe(nil)); end
-  def uri(); end
-  def uri=(uri); end
-  def valid?(); end
-  def validate!(probe=T.unsafe(nil)); end
-  DEFAULT_FALLBACK_TIMEOUT = ::T.let(nil, ::T.untyped)
-end
-class Bundler::Settings::Mirror
-end
-class Bundler::Settings::Mirrors
-  def each(&blk); end
-  def for(uri); end
-  def initialize(prober=T.unsafe(nil)); end
-  def parse(key, value); end
-end
-class Bundler::Settings::Mirrors
-end
-class Bundler::Settings::Validator
-end
-class Bundler::Settings::Validator::Rule
-  def description(); end
-  def fail!(key, value, *reasons); end
-  def initialize(keys, description, &validate); end
-  def k(key); end
-  def set(settings, key, value, *reasons); end
-  def validate!(key, value, settings); end
-end
-class Bundler::Settings::Validator::Rule
-end
-class Bundler::Settings::Validator
-  def self.validate!(key, value, settings); end
-end
-class Bundler::Source::Git
-  def glob(); end
-  def local?(); end
-end
-class Bundler::SpecSet
-  include ::Enumerable
-end
-class Bundler::StubSpecification
-  def default_gem?(); end
-  def extensions(); end
-  def gem_build_complete_path(); end
-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
-module Bundler::Thor::Actions
-  def _cleanup_options_and_set(options, key); end
-  def _shared_configuration(); end
-  def action(instance); end
-  def add_file(destination, *args, &block); end
-  def add_link(destination, *args); end
-  def append_file(path, *args, &block); end
-  def append_to_file(path, *args, &block); end
-  def apply(path, config=T.unsafe(nil)); end
-  def behavior(); end
-  def behavior=(behavior); end
-  def chmod(path, mode, config=T.unsafe(nil)); end
-  def comment_lines(path, flag, *args); end
-  def copy_file(source, *args, &block); end
-  def create_file(destination, *args, &block); end
-  def create_link(destination, *args); end
-  def destination_root(); end
-  def destination_root=(root); end
-  def directory(source, *args, &block); end
-  def empty_directory(destination, config=T.unsafe(nil)); end
-  def find_in_source_paths(file); end
-  def get(source, *args, &block); end
-  def gsub_file(path, flag, *args, &block); end
-  def in_root(); end
-  def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil)); end
-  def inject_into_class(path, klass, *args, &block); end
-  def inject_into_file(destination, *args, &block); end
-  def inject_into_module(path, module_name, *args, &block); end
-  def insert_into_file(destination, *args, &block); end
-  def inside(dir=T.unsafe(nil), config=T.unsafe(nil), &block); end
-  def link_file(source, *args); end
-  def prepend_file(path, *args, &block); end
-  def prepend_to_file(path, *args, &block); end
-  def relative_to_original_destination_root(path, remove_dot=T.unsafe(nil)); end
-  def remove_dir(path, config=T.unsafe(nil)); end
-  def remove_file(path, config=T.unsafe(nil)); end
-  def run(command, config=T.unsafe(nil)); end
-  def run_ruby_script(command, config=T.unsafe(nil)); end
-  def source_paths(); end
-  def template(source, *args, &block); end
-  def thor(command, *args); end
-  def uncomment_lines(path, flag, *args); end
-  WARNINGS = ::T.let(nil, ::T.untyped)
-end
-class Bundler::Thor::Actions::CapturableERB
-end
-class Bundler::Thor::Actions::CapturableERB
-end
-module Bundler::Thor::Actions::ClassMethods
-  def add_runtime_options!(); end
-  def source_paths(); end
-  def source_paths_for_search(); end
-  def source_root(path=T.unsafe(nil)); end
-end
-module Bundler::Thor::Actions::ClassMethods
-end
-class Bundler::Thor::Actions::CreateFile
-  def data(); end
-  def force_on_collision?(); end
-  def force_or_skip_or_conflict(force, skip, &block); end
-  def identical?(); end
-  def initialize(base, destination, data, config=T.unsafe(nil)); end
-  def on_conflict_behavior(&block); end
-  def render(); end
-end
-class Bundler::Thor::Actions::CreateFile
-end
-class Bundler::Thor::Actions::CreateLink
-end
-class Bundler::Thor::Actions::CreateLink
-end
-class Bundler::Thor::Actions::Directory
-  def execute!(); end
-  def file_level_lookup(previous_lookup); end
-  def files(lookup); end
-  def initialize(base, source, destination=T.unsafe(nil), config=T.unsafe(nil), &block); end
-  def source(); end
-end
-class Bundler::Thor::Actions::Directory
-end
-class Bundler::Thor::Actions::EmptyDirectory
-  def base(); end
-  def config(); end
-  def convert_encoded_instructions(filename); end
-  def destination(); end
-  def destination=(destination); end
-  def exists?(); end
-  def given_destination(); end
-  def initialize(base, destination, config=T.unsafe(nil)); end
-  def invoke!(); end
-  def invoke_with_conflict_check(&block); end
-  def on_conflict_behavior(); end
-  def on_file_clash_behavior(); end
-  def pretend?(); end
-  def relative_destination(); end
-  def revoke!(); end
-  def say_status(status, color); end
-end
-class Bundler::Thor::Actions::EmptyDirectory
-end
-class Bundler::Thor::Actions::InjectIntoFile
-  def behavior(); end
-  def flag(); end
-  def initialize(base, destination, data, config); end
-  def replace!(regexp, string, force); end
-  def replacement(); end
-  def say_status(behavior, warning: T.unsafe(nil), color: T.unsafe(nil)); end
-end
-class Bundler::Thor::Actions::InjectIntoFile
-end
-module Bundler::Thor::Actions
-  def self.included(base); end
-end
-class Bundler::Thor::AmbiguousCommandError
-end
-class Bundler::Thor::AmbiguousCommandError
-end
-Bundler::Thor::AmbiguousTaskError = Bundler::Thor::AmbiguousCommandError
-class Bundler::Thor::Argument
-  def banner(); end
-  def default(); end
-  def default_banner(); end
-  def description(); end
-  def enum(); end
-  def human_name(); end
-  def initialize(name, options=T.unsafe(nil)); end
-  def name(); end
-  def required(); end
-  def required?(); end
-  def show_default?(); end
-  def type(); end
-  def usage(); end
-  def valid_type?(type); end
-  def validate!(); end
-  VALID_TYPES = ::T.let(nil, ::T.untyped)
-end
-class Bundler::Thor::Argument
-end
-class Bundler::Thor::Arguments
-  def initialize(arguments=T.unsafe(nil)); end
-  def parse(args); end
-  def remaining(); end
-  NUMERIC = ::T.let(nil, ::T.untyped)
-end
-class Bundler::Thor::Arguments
-  def self.parse(*args); end
-  def self.split(args); end
-end
-module Bundler::Thor::Base
-  def args(); end
-  def args=(args); end
-  def initialize(args=T.unsafe(nil), local_options=T.unsafe(nil), config=T.unsafe(nil)); end
-  def options(); end
-  def options=(options); end
-  def parent_options(); end
-  def parent_options=(parent_options); end
-end
-module Bundler::Thor::Base::ClassMethods
-  def all_commands(); end
-  def all_tasks(); end
-  def allow_incompatible_default_type!(); end
-  def argument(name, options=T.unsafe(nil)); end
-  def arguments(); end
-  def attr_accessor(*_); end
-  def attr_reader(*_); end
-  def attr_writer(*_); end
-  def baseclass(); end
-  def basename(); end
-  def build_option(name, options, scope); end
-  def build_options(options, scope); end
-  def check_default_type(); end
-  def check_default_type!(); end
-  def check_unknown_options(); end
-  def check_unknown_options!(); end
-  def check_unknown_options?(config); end
-  def class_option(name, options=T.unsafe(nil)); end
-  def class_options(options=T.unsafe(nil)); end
-  def class_options_help(shell, groups=T.unsafe(nil)); end
-  def commands(); end
-  def create_command(meth); end
-  def create_task(meth); end
-  def disable_required_check?(command_name); end
-  def dispatch(command, given_args, given_opts, config); end
-  def exit_on_failure?(); end
-  def find_and_refresh_command(name); end
-  def find_and_refresh_task(name); end
-  def from_superclass(method, default=T.unsafe(nil)); end
-  def group(name=T.unsafe(nil)); end
-  def handle_argument_error(command, error, args, arity); end
-  def handle_no_command_error(command, has_namespace=T.unsafe(nil)); end
-  def handle_no_task_error(command, has_namespace=T.unsafe(nil)); end
-  def inherited(klass); end
-  def initialize_added(); end
-  def is_thor_reserved_word?(word, type); end
-  def method_added(meth); end
-  def namespace(name=T.unsafe(nil)); end
-  def no_commands(&block); end
-  def no_commands?(); end
-  def no_commands_context(); end
-  def no_tasks(&block); end
-  def print_options(shell, options, group_name=T.unsafe(nil)); end
-  def public_command(*names); end
-  def public_task(*names); end
-  def remove_argument(*names); end
-  def remove_class_option(*names); end
-  def remove_command(*names); end
-  def remove_task(*names); end
-  def start(given_args=T.unsafe(nil), config=T.unsafe(nil)); end
-  def stop_on_unknown_option?(command_name); end
-  def strict_args_position(); end
-  def strict_args_position!(); end
-  def strict_args_position?(config); end
-  def tasks(); end
-end
-module Bundler::Thor::Base::ClassMethods
-end
-module Bundler::Thor::Base
-  def self.included(base); end
-  def self.register_klass_file(klass); end
-  def self.shell(); end
-  def self.shell=(shell); end
-  def self.subclass_files(); end
-  def self.subclasses(); end
-end
-class Bundler::Thor::Command
-  def formatted_usage(klass, namespace=T.unsafe(nil), subcommand=T.unsafe(nil)); end
-  def handle_argument_error?(instance, error, caller); end
-  def handle_no_method_error?(instance, error, caller); end
-  def hidden?(); end
-  def initialize(name, description, long_description, usage, options=T.unsafe(nil)); end
-  def local_method?(instance, name); end
-  def not_debugging?(instance); end
-  def private_method?(instance); end
-  def public_method?(instance); end
-  def required_arguments_for(klass, usage); end
-  def required_options(); end
-  def run(instance, args=T.unsafe(nil)); end
-  def sans_backtrace(backtrace, caller); end
-  FILE_REGEXP = ::T.let(nil, ::T.untyped)
-end
-class Bundler::Thor::Command
-end
-module Bundler::Thor::CoreExt
-end
-class Bundler::Thor::CoreExt::HashWithIndifferentAccess
-  def [](key); end
-  def []=(key, value); end
-  def convert_key(key); end
-  def delete(key); end
-  def fetch(key, *args); end
-  def initialize(hash=T.unsafe(nil)); end
-  def key?(key); end
-  def merge(other); end
-  def merge!(other); end
-  def method_missing(method, *args); end
-  def replace(other_hash); end
-  def reverse_merge(other); end
-  def reverse_merge!(other_hash); end
-  def values_at(*indices); end
-end
-class Bundler::Thor::CoreExt::HashWithIndifferentAccess
-end
-module Bundler::Thor::CoreExt
-end
-Bundler::Thor::Correctable = DidYouMean::Correctable
-class Bundler::Thor::DynamicCommand
-  def initialize(name, options=T.unsafe(nil)); end
-end
-class Bundler::Thor::DynamicCommand
-end
-Bundler::Thor::DynamicTask = Bundler::Thor::DynamicCommand
-class Bundler::Thor::Error
-end
-class Bundler::Thor::Error
-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
-class Bundler::Thor::Group
-  extend ::Bundler::Thor::Base::ClassMethods
-  extend ::Bundler::Thor::Invocation::ClassMethods
-  def self.banner(); end
-  def self.desc(description=T.unsafe(nil)); end
-  def self.get_options_from_invocations(group_options, base_options); end
-  def self.handle_argument_error(command, error, _args, arity); end
-  def self.help(shell); end
-  def self.invocation_blocks(); end
-  def self.invocations(); end
-  def self.invoke(*names, &block); end
-  def self.invoke_from_option(*names, &block); end
-  def self.printable_commands(*_); end
-  def self.printable_tasks(*_); end
-  def self.remove_invocation(*names); end
-  def self.self_command(); end
-  def self.self_task(); end
-end
-class Bundler::Thor::HiddenCommand
-end
-class Bundler::Thor::HiddenCommand
-end
-Bundler::Thor::HiddenTask = Bundler::Thor::HiddenCommand
-module Bundler::Thor::Invocation
-  def _parse_initialization_options(args, opts, config); end
-  def _retrieve_class_and_command(name, sent_command=T.unsafe(nil)); end
-  def _retrieve_class_and_task(name, sent_command=T.unsafe(nil)); end
-  def _shared_configuration(); end
-  def current_command_chain(); end
-  def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil), &block); end
-  def invoke(name=T.unsafe(nil), *args); end
-  def invoke_all(); end
-  def invoke_command(command, *args); end
-  def invoke_task(command, *args); end
-  def invoke_with_padding(*args); end
-end
-module Bundler::Thor::Invocation::ClassMethods
-  def prepare_for_invocation(key, name); end
-end
-module Bundler::Thor::Invocation::ClassMethods
-end
-module Bundler::Thor::Invocation
-  def self.included(base); end
-end
-class Bundler::Thor::InvocationError
-end
-class Bundler::Thor::InvocationError
-end
-module Bundler::Thor::LineEditor
-end
-class Bundler::Thor::LineEditor::Basic
-  def initialize(prompt, options); end
-  def options(); end
-  def prompt(); end
-  def readline(); end
-end
-class Bundler::Thor::LineEditor::Basic
-  def self.available?(); end
-end
-class Bundler::Thor::LineEditor::Readline
-end
-class Bundler::Thor::LineEditor::Readline::PathCompletion
-  def initialize(text); end
-  def matches(); end
-end
-class Bundler::Thor::LineEditor::Readline::PathCompletion
-end
-class Bundler::Thor::LineEditor::Readline
-end
-module Bundler::Thor::LineEditor
-  def self.best_available(); end
-  def self.readline(prompt, options=T.unsafe(nil)); end
-end
-class Bundler::Thor::MalformattedArgumentError
-end
-class Bundler::Thor::MalformattedArgumentError
-end
-class Bundler::Thor::NestedContext
-  def enter(); end
-  def entered?(); end
-end
-class Bundler::Thor::NestedContext
-end
-class Bundler::Thor::NoKwargSpellChecker
-  def initialize(dictionary); end
-end
-class Bundler::Thor::NoKwargSpellChecker
-end
-class Bundler::Thor::Option
-  def aliases(); end
-  def array?(); end
-  def boolean?(); end
-  def dasherize(str); end
-  def dasherized?(); end
-  def group(); end
-  def hash?(); end
-  def hide(); end
-  def lazy_default(); end
-  def numeric?(); end
-  def repeatable(); end
-  def string?(); end
-  def switch_name(); end
-  def undasherize(str); end
-  def usage(padding=T.unsafe(nil)); end
-  def validate_default_type!(); end
-  VALID_TYPES = ::T.let(nil, ::T.untyped)
-end
-class Bundler::Thor::Option
-  def self.parse(key, value); end
-end
-class Bundler::Thor::Options
-  def assign_result!(option, result); end
-  def check_unknown!(); end
-  def current_is_switch?(); end
-  def current_is_switch_formatted?(); 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
-  def normalize_switch(arg); end
-  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 Bundler::Thor::Options
-  def self.to_switches(options); end
-end
-module Bundler::Thor::RakeCompat
-  include ::Rake::DSL
-  include ::Rake::FileUtilsExt
-  include ::FileUtils
-  include ::FileUtils::StreamUtils_
-end
-module Bundler::Thor::RakeCompat
-  def self.included(base); end
-  def self.rake_classes(); end
-end
-class Bundler::Thor::RequiredArgumentMissingError
-end
-class Bundler::Thor::RequiredArgumentMissingError
-end
-module Bundler::Thor::Sandbox
-end
-module Bundler::Thor::Sandbox
-end
-module Bundler::Thor::Shell
-  def _shared_configuration(); end
-  def ask(*args, &block); end
-  def error(*args, &block); end
-  def file_collision(*args, &block); end
-  def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil)); end
-  def no?(*args, &block); end
-  def print_in_columns(*args, &block); end
-  def print_table(*args, &block); end
-  def print_wrapped(*args, &block); end
-  def say(*args, &block); end
-  def say_status(*args, &block); end
-  def set_color(*args, &block); end
-  def shell(); end
-  def shell=(shell); end
-  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 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
-class Bundler::Thor::Shell::Basic
-end
-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 Bundler::Thor::Shell::Color
-end
-class Bundler::Thor::Shell::HTML
-  def ask(statement, color=T.unsafe(nil)); 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)
-  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 Bundler::Thor::Shell::HTML
-end
-module Bundler::Thor::Shell
-end
-Bundler::Thor::Task = Bundler::Thor::Command
-class Bundler::Thor::UndefinedCommandError
-  include ::DidYouMean::Correctable
-  def all_commands(); end
-  def command(); end
-  def initialize(command, all_commands, namespace); end
-end
-class Bundler::Thor::UndefinedCommandError::SpellChecker
-  def corrections(); end
-  def error(); end
-  def initialize(error); end
-  def spell_checker(); end
-end
-class Bundler::Thor::UndefinedCommandError::SpellChecker
-end
-class Bundler::Thor::UndefinedCommandError
-end
-Bundler::Thor::UndefinedTaskError = Bundler::Thor::UndefinedCommandError
-class Bundler::Thor::UnknownArgumentError
-  include ::DidYouMean::Correctable
-  def initialize(switches, unknown); end
-  def switches(); end
-  def unknown(); end
-end
-class Bundler::Thor::UnknownArgumentError::SpellChecker
-  def corrections(); end
-  def error(); end
-  def initialize(error); end
-  def spell_checker(); end
-end
-class Bundler::Thor::UnknownArgumentError::SpellChecker
-end
-class Bundler::Thor::UnknownArgumentError
-end
-module Bundler::Thor::Util
-end
-module Bundler::Thor::Util
-  def self.camel_case(str); end
-  def self.escape_globs(path); end
-  def self.escape_html(string); end
-  def self.find_by_namespace(namespace); end
-  def self.find_class_and_command_by_namespace(namespace, fallback=T.unsafe(nil)); end
-  def self.find_class_and_task_by_namespace(namespace, fallback=T.unsafe(nil)); end
-  def self.globs_for(path); end
-  def self.load_thorfile(path, content=T.unsafe(nil), debug=T.unsafe(nil)); end
-  def self.namespace_from_thor_class(constant); end
-  def self.namespaces_in_content(contents, file=T.unsafe(nil)); end
-  def self.ruby_command(); end
-  def self.snake_case(str); end
-  def self.thor_classes_in(klass); end
-  def self.thor_root(); end
-  def self.thor_root_glob(); end
-  def self.user_home(); end
-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 self.check_unknown_options!(options=T.unsafe(nil)); end
-  def self.command_help(shell, command_name); end
-  def self.default_command(meth=T.unsafe(nil)); end
-  def self.default_task(meth=T.unsafe(nil)); end
-  def self.deprecation_warning(message); end
-  def self.desc(usage, description, options=T.unsafe(nil)); end
-  def self.disable_required_check(); end
-  def self.disable_required_check!(*command_names); end
-  def self.disable_required_check?(command); end
-  def self.dispatch(meth, given_args, given_opts, config); end
-  def self.dynamic_command_class(); end
-  def self.find_command_possibilities(meth); end
-  def self.find_task_possibilities(meth); end
-  def self.help(shell, subcommand=T.unsafe(nil)); end
-  def self.long_desc(long_description, options=T.unsafe(nil)); end
-  def self.map(mappings=T.unsafe(nil), **kw); end
-  def self.method_option(name, options=T.unsafe(nil)); end
-  def self.method_options(options=T.unsafe(nil)); end
-  def self.normalize_command_name(meth); end
-  def self.normalize_task_name(meth); end
-  def self.option(name, options=T.unsafe(nil)); end
-  def self.options(options=T.unsafe(nil)); end
-  def self.package_name(name, _=T.unsafe(nil)); end
-  def self.printable_commands(all=T.unsafe(nil), subcommand=T.unsafe(nil)); 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 self.subtasks(); 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 shell=(shell); end
-  def silence(&blk); end
-  def trace(e, newline=T.unsafe(nil), force=T.unsafe(nil)); end
-  def unprinted_warnings(); end
-  def warn(msg, newline=T.unsafe(nil), color=T.unsafe(nil)); end
-  def yes?(msg); end
-  LEVELS = ::T.let(nil, ::T.untyped)
-end
-class Bundler::UI::Shell
-end
-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 Bundler::URI::BadURIError
-end
-class Bundler::URI::BadURIError
-end
-class Bundler::URI::Error
-end
-class Bundler::URI::Error
-end
-module Bundler::URI::Escape
-  def decode(*arg); end
-  def encode(*arg); end
-  def escape(*arg); end
-  def unescape(*arg); end
-end
-module Bundler::URI::Escape
-end
-class Bundler::URI::FTP
-  def set_typecode(v); end
-  def typecode(); 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 Bundler::URI::FTP
-  def self.new2(user, password, host, port, path, typecode=T.unsafe(nil), arg_check=T.unsafe(nil)); end
-end
-class Bundler::URI::File
-  def check_password(user); end
-  def check_user(user); end
-  def check_userinfo(user); end
-  def set_userinfo(v); end
-  COMPONENT = ::T.let(nil, ::T.untyped)
-  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
-end
-class Bundler::URI::File
-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 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 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
-  def initialize(header, io); end
-  def length(); end
-  def pos(); end
-  def read(len=T.unsafe(nil)); end
-  def readpartial(maxlen=T.unsafe(nil), outbuf=T.unsafe(nil)); end
-  def rewind(); end
-  def size(); end
-  def symlink?(); end
-end
-class Gem::Package::TarReader::Entry
-end
-class Gem::Package::TarReader
-  def self.new(io); end
-end
-class Gem::Package::TarWriter
-  def self.new(io); end
-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 Gem::PathSupport
-  def home(); end
-  def initialize(env); end
-  def path(); end
-  def spec_cache_dir(); end
-end
-class Gem::RemoteFetcher::FetchError
-  include ::Gem::UriParsing
-  def initialize(message, uri); end
-  def uri(); end
-  def uri=(uri); end
-end
-class Gem::RemoteFetcher::FetchError
-end
-class Gem::RemoteFetcher::UnknownHostError
-end
-class Gem::RemoteFetcher::UnknownHostError
-end
-class Gem::Request
-  extend ::Gem::UserInteraction
-  extend ::Gem::DefaultUserInteraction
-  extend ::Gem::Text
-end
-class Gem::RequestSet
-  def pretty_print(q); end
-end
-class Gem::Requirement
-  include ::Gem::Requirement::OrderIndependentComparison
-  include ::Gem::Requirement::CorrectHashForLambdaOperator
-  def pretty_print(q); end
-end
-module Gem::Requirement::CorrectHashForLambdaOperator
-  def hash(); end
-end
-module Gem::Requirement::CorrectHashForLambdaOperator
-end
-module Gem::Requirement::OrderIndependentComparison
-  def ==(other); end
-  def _requirements_sorted?(); end
-  def _with_sorted_requirements(); end
-end
-module Gem::Requirement::OrderIndependentComparison
-end
-class Gem::Resolver::APISet
-  def pretty_print(q); end
-end
-class Gem::Resolver::APISpecification
-  def pretty_print(q); end
-end
-class Gem::Resolver::ActivationRequest
-  def pretty_print(q); end
-end
-class Gem::Resolver::BestSet
-  def pretty_print(q); end
-end
-class Gem::Resolver::Conflict
-  def pretty_print(q); end
-end
-class Gem::Resolver::CurrentSet
-end
-class Gem::Resolver::CurrentSet
-end
-class Gem::Resolver::DependencyRequest
-  def pretty_print(q); end
-end
-class Gem::Resolver::GitSet
-  def pretty_print(q); end
-end
-class Gem::Resolver::GitSpecification
-  def pretty_print(q); end
-end
-class Gem::Resolver::IndexSet
-  def pretty_print(q); end
-end
-class Gem::Resolver::IndexSpecification
-  def pretty_print(q); end
-end
-class Gem::Resolver::InstalledSpecification
-  def pretty_print(q); end
-end
-class Gem::Resolver::InstallerSet
-  def pretty_print(q); end
-end
-class Gem::Resolver::LocalSpecification
-  def pretty_print(q); end
-end
-class Gem::Resolver::LocalSpecification
-end
-class Gem::Resolver::LockSet
-  def pretty_print(q); end
-end
-class Gem::Resolver::LockSpecification
-  def pretty_print(q); end
-end
-class Gem::Resolver::Molinillo::DependencyGraph::Log
-  def add_edge_no_circular(graph, origin, destination, requirement); end
-  def add_vertex(graph, name, payload, root); end
-  def delete_edge(graph, origin_name, destination_name, requirement); end
-  def detach_vertex_named(graph, name); end
-  def each(&blk); end
-  def pop!(graph); end
-  def reverse_each(); end
-  def rewind_to(graph, tag); end
-  def set_payload(graph, name, payload); end
-  def tag(graph, tag); end
-end
-class Gem::Resolver::Molinillo::DependencyGraph::Log
-  extend ::Enumerable
-end
-class Gem::Resolver::VendorSet
-  def pretty_print(q); end
-end
-class Gem::RuntimeRequirementNotMetError
-  def suggestion(); end
-  def suggestion=(suggestion); end
-end
-class Gem::RuntimeRequirementNotMetError
-end
-class Gem::Security::Exception
-end
-class Gem::Security::Exception
-end
-class Gem::Security::KEY_ALGORITHM
-  def d(); end
-  def dmp1(); end
-  def dmq1(); end
-  def e(); end
-  def export(*_); end
-  def initialize(*_); end
-  def iqmp(); end
-  def n(); end
-  def p(); end
-  def params(); end
-  def private?(); end
-  def private_decrypt(*_); end
-  def private_encrypt(*_); end
-  def public?(); end
-  def public_decrypt(*_); end
-  def public_encrypt(*_); end
-  def public_key(); end
-  def q(); end
-  def set_crt_params(_, _1, _2); end
-  def set_factors(_, _1); end
-  def set_key(_, _1, _2); end
-  def sign_pss(*_); end
-  def to_der(); end
-  def to_pem(*_); end
-  def to_s(*_); end
-  def to_text(); end
-  def verify_pss(*_); end
-  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 Gem::Security::KEY_ALGORITHM
-  def self.generate(*_); end
-end
-class Gem::Security::Policy
-  include ::Gem::UserInteraction
-  include ::Gem::DefaultUserInteraction
-  include ::Gem::Text
-  def check_cert(signer, issuer, time); end
-  def check_chain(chain, time); end
-  def check_data(public_key, digest, signature, data); end
-  def check_key(signer, key); end
-  def check_root(chain, time); end
-  def check_trust(chain, digester, trust_dir); end
-  def initialize(name, policy=T.unsafe(nil), opt=T.unsafe(nil)); end
-  def name(); end
-  def only_signed(); end
-  def only_signed=(only_signed); end
-  def only_trusted(); end
-  def only_trusted=(only_trusted); end
-  def subject(certificate); end
-  def verify(chain, key=T.unsafe(nil), digests=T.unsafe(nil), signatures=T.unsafe(nil), full_name=T.unsafe(nil)); end
-  def verify_chain(); end
-  def verify_chain=(verify_chain); end
-  def verify_data(); end
-  def verify_data=(verify_data); end
-  def verify_root(); end
-  def verify_root=(verify_root); end
-  def verify_signatures(spec, digests, signatures); end
-  def verify_signer(); end
-  def verify_signer=(verify_signer); end
-end
-class Gem::Security::Policy
-end
-class Gem::Security::Signer
-  include ::Gem::UserInteraction
-  include ::Gem::DefaultUserInteraction
-  include ::Gem::Text
-  def cert_chain(); end
-  def cert_chain=(cert_chain); end
-  def digest_algorithm(); end
-  def digest_name(); end
-  def extract_name(cert); end
-  def initialize(key, cert_chain, passphrase=T.unsafe(nil), options=T.unsafe(nil)); end
-  def key(); end
-  def key=(key); end
-  def load_cert_chain(); end
-  def options(); end
-  def re_sign_key(expiration_length: T.unsafe(nil)); end
-  def sign(data); end
-end
-class Gem::Security::Signer
-  def self.re_sign_cert(expired_cert, expired_cert_path, private_key); end
-end
-class Gem::Security::TrustDir
-  def cert_path(certificate); end
-  def dir(); end
-  def each_certificate(); end
-  def initialize(dir, permissions=T.unsafe(nil)); end
-  def issuer_of(certificate); end
-  def load_certificate(certificate_file); end
-  def name_path(name); end
-  def trust_cert(certificate); end
-  def verify(); end
-end
-module Gem::Security
-  def self.alt_name_or_x509_entry(certificate, x509_entry); end
-  def self.create_cert(subject, key, age=T.unsafe(nil), extensions=T.unsafe(nil), serial=T.unsafe(nil)); end
-  def self.create_cert_email(email, key, age=T.unsafe(nil), extensions=T.unsafe(nil)); end
-  def self.create_cert_self_signed(subject, key, age=T.unsafe(nil), extensions=T.unsafe(nil), serial=T.unsafe(nil)); end
-  def self.create_key(length=T.unsafe(nil), algorithm=T.unsafe(nil)); end
-  def self.email_to_name(email_address); end
-  def self.re_sign(expired_certificate, private_key, age=T.unsafe(nil), extensions=T.unsafe(nil)); end
-  def self.reset(); end
-  def self.sign(certificate, signing_key, signing_cert, age=T.unsafe(nil), extensions=T.unsafe(nil), serial=T.unsafe(nil)); end
-  def self.trust_dir(); end
-  def self.trusted_certificates(&block); end
-  def self.write(pemmable, path, permissions=T.unsafe(nil), passphrase=T.unsafe(nil), cipher=T.unsafe(nil)); end
-end
-class Gem::Source
-  def pretty_print(q); end
-end
-class Gem::SpecFetcher
-  include ::Gem::UserInteraction
-  include ::Gem::DefaultUserInteraction
-  include ::Gem::Text
-  def available_specs(type); end
-  def detect(type=T.unsafe(nil)); end
-  def initialize(sources=T.unsafe(nil)); end
-  def latest_specs(); end
-  def prerelease_specs(); end
-  def search_for_dependency(dependency, matching_platform=T.unsafe(nil)); end
-  def sources(); end
-  def spec_for_dependency(dependency, matching_platform=T.unsafe(nil)); end
-  def specs(); end
-  def suggest_gems_from_name(gem_name, type=T.unsafe(nil)); end
-  def tuples_for(source, type, gracefully_ignore=T.unsafe(nil)); end
-end
-class Gem::SpecFetcher
-  def self.fetcher(); end
-  def self.fetcher=(fetcher); end
-end
-class Gem::Specification
-  include ::Bundler::MatchPlatform
-  include ::Bundler::GemHelpers
-  def pretty_print(q); end
-  def removed_method_calls(); end
-  def to_ruby(); end
-  REMOVED_METHODS = ::T.let(nil, ::T.untyped)
-end
-class Gem::Specification
-  extend ::Gem::Deprecate
-  extend ::Enumerable
-end
-class Gem::SpecificationPolicy
-  include ::Gem::UserInteraction
-  include ::Gem::DefaultUserInteraction
-  include ::Gem::Text
-  def initialize(specification); end
-  def packaging(); end
-  def packaging=(packaging); end
-  def validate(strict=T.unsafe(nil)); end
-  def validate_dependencies(); end
-  def validate_metadata(); end
-  def validate_permissions(); end
-  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 Gem::SpecificationPolicy
-end
-class Gem::StreamUI
-  def _deprecated_debug(statement); end
-end
-class Gem::StubSpecification
-  def build_extensions(); end
-  def extensions(); end
-  def initialize(filename, base_dir, gems_dir, default_gem); end
-  def missing_extensions?(); end
-  def valid?(); end
-end
-class Gem::StubSpecification::StubLine
-  def extensions(); end
-  def full_name(); end
-  def initialize(data, extensions); end
-  def name(); end
-  def platform(); end
-  def require_paths(); end
-  def version(); end
-end
-class Gem::StubSpecification
-  def self.default_gemspec_stub(filename, base_dir, gems_dir); end
-  def self.gemspec_stub(filename, base_dir, gems_dir); end
-end
-class Gem::UninstallError
-  def spec(); end
-  def spec=(spec); end
-end
-class Gem::UninstallError
-end
-Gem::UnsatisfiableDepedencyError = Gem::UnsatisfiableDependencyError
-class Gem::Version
-  def pretty_print(q); end
-end
-Gem::Version::Requirement = Gem::Requirement
-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
-module Hamster::EmptyList
-  extend ::Hamster::List
-  extend ::Hamster::Enumerable
-  extend ::Enumerable
-end
-class Hamster::LazyList
-  MUTEX = ::T.let(nil, ::T.untyped)
-  QUEUE = ::T.let(nil, ::T.untyped)
-end
-module Hamster::List
-  CADR = ::T.let(nil, ::T.untyped)
-end
-class Hamster::SortedSet::PlainAVLNode
-  EmptyNode = ::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)
-end
-class Hash
-  include ::JSON::Ext::Generator::GeneratorMethods::Hash
-  def deconstruct_keys(_); end
-end
-class Hash
-  def self.ruby2_keywords_hash(_); end
-  def self.ruby2_keywords_hash?(_); end
-  def self.try_convert(_); end
-end
-class IO
-  def nonblock(*_); end
-  def nonblock=(nonblock); end
-  def nonblock?(); end
-  def nread(); end
-  def pathconf(_); end
-  def ready?(); end
-  def set_encoding_by_bom(); end
-  def wait(*_); end
-  def wait_readable(*_); end
-  def wait_writable(*_); end
-end
-IO::EWOULDBLOCKWaitReadable = IO::EAGAINWaitReadable
-IO::EWOULDBLOCKWaitWritable = IO::EAGAINWaitWritable
-class IPAddr
-  def ==(other); end
-  def initialize(addr=T.unsafe(nil), family=T.unsafe(nil)); end
-end
-class Integer
-  include ::JSON::Ext::Generator::GeneratorMethods::Integer
-  def to_bn(); end
-  GMP_VERSION = ::T.let(nil, ::T.untyped)
-end
-class JSON::Ext::Generator::State
-  def self.from_state(_); end
-end
-class JSON::Ext::Parser
-  def initialize(*_); end
-end
-JSON::Parser = JSON::Ext::Parser
-JSON::State = JSON::Ext::Generator::State
-JSON::UnparserError = JSON::GeneratorError
-module Kernel
-  def itself(); end
-  def object_id(); end
-  def then(); end
-  def yield_self(); end
-end
-module Kernel
-  def self.at_exit(); end
-end
-class KeyError
-  include ::DidYouMean::Correctable
-end
-class Logger
-  def debug!(); end
-  def error!(); end
-  def fatal!(); end
-  def info!(); end
-  def warn!(); end
-  SEV_LABEL = ::T.let(nil, ::T.untyped)
-end
-class Logger::Formatter
-  Format = ::T.let(nil, ::T.untyped)
-end
-class Logger::LogDevice
-  include ::MonitorMixin
-end
-module Logger::Period
-  SiD = ::T.let(nil, ::T.untyped)
-end
-class Monitor
-  def enter(); end
-  def exit(); end
-  def mon_check_owner(); end
-  def mon_enter(); end
-  def mon_exit(); end
-  def mon_locked?(); end
-  def mon_owned?(); end
-  def mon_synchronize(); end
-  def mon_try_enter(); end
-  def new_cond(); end
-  def synchronize(); end
-  def try_enter(); end
-  def try_mon_enter(); end
-  def wait_for_cond(_, _1); end
-end
-module MonitorMixin
-  def initialize(*args); end
-end
-class MonitorMixin::ConditionVariable
-  def initialize(monitor); end
-end
-class NameError
-  include ::DidYouMean::Correctable
-end
-class NilClass
-  include ::JSON::Ext::Generator::GeneratorMethods::NilClass
-end
-class NoMatchingPatternError
-end
-class NoMatchingPatternError
-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
-class OpenStruct
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-class Pathname
-  def fnmatch?(*_); end
-  def glob(*_); end
-  def make_symlink(_); end
-end
-class Proc
-  def <<(_); end
-  def >>(_); end
-  def clone(); end
-end
-module Process
-  CLOCK_TAI = ::T.let(nil, ::T.untyped)
-end
-module Rake::DSL
-  include ::FileUtils::StreamUtils_
-end
-module Rake::FileUtilsExt
-  include ::FileUtils::StreamUtils_
-  def rake_merge_option(args, defaults); end
-  DEFAULT = ::T.let(nil, ::T.untyped)
-end
-module Rake::FileUtilsExt
-  extend ::FileUtils::StreamUtils_
-end
-class Random
-  def self.bytes(_); end
-end
-class Range
-  def %(_); end
-  def entries(); end
-  def to_a(); end
-end
-module RbConfig
-  def self.expand(val, config=T.unsafe(nil)); end
-  def self.fire_update!(key, val, mkconf=T.unsafe(nil), conf=T.unsafe(nil)); end
-  def self.ruby(); end
-end
-module RubyVM::MJIT
-end
-module RubyVM::MJIT
-  def self.enabled?(); end
-  def self.pause(*_); end
-  def self.resume(); end
-end
-class Set
-  def ===(o); end
-  def compare_by_identity(); end
-  def compare_by_identity?(); end
-  def divide(&func); end
-  def eql?(o); end
-  def pretty_print(pp); end
-  def pretty_print_cycle(pp); end
-  def reset(); end
-  InspectKey = ::T.let(nil, ::T.untyped)
-end
-class SimpleDelegator
-  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
-end
-class SortedSet
-  def initialize(*args, &block); end
-end
-class SortedSet
-  def self.setup(); end
-end
-class String
-  include ::JSON::Ext::Generator::GeneratorMethods::String
-  def shellescape(); end
-  def shellsplit(); end
-end
-class String
-  extend ::JSON::Ext::Generator::GeneratorMethods::String::Extend
-end
-class Struct
-  def deconstruct(); end
-  def deconstruct_keys(_); end
-  def filter(*_); end
-end
-Struct::Group = Etc::Group
-Struct::Passwd = Etc::Passwd
-Struct::Tms = Process::Tms
-class TracePoint
-  def eval_script(); 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
-module URI
-  include ::URI::RFC2396_REGEXP
-end
-class URI::FTP
-  def self.new2(user, password, host, port, path, typecode=T.unsafe(nil), arg_check=T.unsafe(nil)); end
-end
-class URI::File
-  def check_password(user); end
-  def check_user(user); end
-  def check_userinfo(user); end
-  def set_userinfo(v); end
-  COMPONENT = ::T.let(nil, ::T.untyped)
-  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
-end
-class URI::File
-end
-class URI::LDAP
-  def attributes(); end
-  def attributes=(val); end
-  def dn(); end
-  def dn=(val); end
-  def extensions(); end
-  def extensions=(val); end
-  def filter(); end
-  def filter=(val); end
-  def initialize(*arg); end
-  def scope(); end
-  def scope=(val); end
-  def set_attributes(val); end
-  def set_dn(val); end
-  def set_extensions(val); end
-  def set_filter(val); end
-  def set_scope(val); end
-end
-class URI::MailTo
-  def initialize(*arg); end
-end
-URI::Parser = URI::RFC2396_Parser
-URI::REGEXP = URI::RFC2396_REGEXP
-class URI::RFC2396_Parser
-  def initialize(opts=T.unsafe(nil)); end
-end
-class URI::RFC3986_Parser
-  def join(*uris); end
-  def parse(uri); end
-  def regexp(); end
-  def split(uri); end
-  RFC3986_relative_ref = ::T.let(nil, ::T.untyped)
-end
-module URI::Util
-  def self.make_components_hash(klass, array_hash); end
-end
-module URI
-  extend ::URI::Escape
-  def self.get_encoding(label); end
-end
-module UnicodeNormalize
-end
-module UnicodeNormalize
-end
-module Warning
-  extend ::Warning
-end