RubyGems - yard-sorbet - Versions diffs - 0.0.1 → 0.1.0 - Mend

yard-sorbet 0.0.1 → 0.1.0

Files changed (54) hide show

checksums.yaml +4 -4
data/.rspec +2 -0
data/.rubocop.yml +16 -1
data/.travis.yml +2 -1
data/.yardopts +2 -0
data/CHANGELOG.md +25 -5
data/Gemfile +3 -9
data/Rakefile +9 -1
data/lib/yard-sorbet.rb +3 -2
data/lib/yard-sorbet/directives.rb +1 -1
data/lib/yard-sorbet/sig_handler.rb +31 -15
data/lib/yard-sorbet/sig_to_yard.rb +20 -5
data/lib/yard-sorbet/struct_handler.rb +1 -2
data/lib/yard-sorbet/version.rb +1 -1
data/yard-sorbet.gemspec +25 -13
metadata +56 -62
data/sorbet/config +0 -2
data/sorbet/rbi/gems/ast.rbi +0 -47
data/sorbet/rbi/gems/byebug.rbi +0 -1039
data/sorbet/rbi/gems/codecov.rbi +0 -19
data/sorbet/rbi/gems/coderay.rbi +0 -91
data/sorbet/rbi/gems/docile.rbi +0 -31
data/sorbet/rbi/gems/jaro_winkler.rbi +0 -14
data/sorbet/rbi/gems/method_source.rbi +0 -63
data/sorbet/rbi/gems/parallel.rbi +0 -81
data/sorbet/rbi/gems/parser.rbi +0 -920
data/sorbet/rbi/gems/pry-byebug.rbi +0 -149
data/sorbet/rbi/gems/pry.rbi +0 -1964
data/sorbet/rbi/gems/rainbow.rbi +0 -117
data/sorbet/rbi/gems/rake.rbi +0 -635
data/sorbet/rbi/gems/rspec-core.rbi +0 -1686
data/sorbet/rbi/gems/rspec-expectations.rbi +0 -387
data/sorbet/rbi/gems/rspec-mocks.rbi +0 -819
data/sorbet/rbi/gems/rspec-support.rbi +0 -270
data/sorbet/rbi/gems/rspec.rbi +0 -14
data/sorbet/rbi/gems/rubocop-rspec.rbi +0 -889
data/sorbet/rbi/gems/rubocop.rbi +0 -7139
data/sorbet/rbi/gems/ruby-progressbar.rbi +0 -304
data/sorbet/rbi/gems/simplecov-html.rbi +0 -30
data/sorbet/rbi/gems/simplecov.rbi +0 -225
data/sorbet/rbi/gems/site_ruby.rbi +0 -114
data/sorbet/rbi/gems/unicode-display_width.rbi +0 -16
data/sorbet/rbi/gems/yard.rbi +0 -1181
data/sorbet/rbi/hidden-definitions/errors.txt +0 -3045
data/sorbet/rbi/hidden-definitions/hidden.rbi +0 -4469
data/sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi +0 -8684
data/sorbet/rbi/sorbet-typed/lib/ruby/all/gem.rbi +0 -4222
data/sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi +0 -111
data/sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi +0 -543
data/spec/data/sig_handler.rb.txt +0 -196
data/spec/data/struct_handler.rb.txt +0 -25
data/spec/spec_helper.rb +0 -111
data/spec/yard_sorbet/sig_handler_spec.rb +0 -233
data/spec/yard_sorbet/struct_handler_spec.rb +0 -48

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

@@ -1,4469 +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 bsearch(); end
-  def bsearch_index(); end
-  def collect!(); end
-  def deconstruct(); end
-  def dig(*_); end
-  def flatten!(*_); end
-  def intersection(*_); end
-  def pack(fmt, buffer: T.unsafe(nil)); end
-  def replace(_); end
-  def shelljoin(); end
-  def to_h(); end
-end
-class Array
-  def self.try_convert(_); end
-end
-BasicObject::BasicObject = BasicObject
-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.interpret_loosely(_); end
-end
-class Binding
-  def clone(); end
-  def irb(); 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::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 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_version(); end
-  def version(); end
-  def version_tag(); end
-end
-class Bundler::GemHelper
-  def self.gemspec(&block); end
-  def self.install_tasks(opts=T.unsafe(nil)); end
-  def self.instance(); end
-  def self.instance=(instance); end
-end
-class Bundler::GemVersionPromoter
-  def initialize(locked_specs=T.unsafe(nil), unlock_gems=T.unsafe(nil)); end
-  def level(); end
-  def level=(value); end
-  def locked_specs(); end
-  def major?(); end
-  def minor?(); end
-  def prerelease_specified(); end
-  def prerelease_specified=(prerelease_specified); end
-  def sort_versions(dep, spec_groups); end
-  def strict(); end
-  def strict=(strict); end
-  def unlock_gems(); end
-  DEBUG = ::T.let(nil, ::T.untyped)
-end
-class Bundler::GemVersionPromoter
-end
-class Bundler::Graph
-  def edge_options(); end
-  def groups(); end
-  def initialize(env, output_file, show_version=T.unsafe(nil), show_requirements=T.unsafe(nil), output_format=T.unsafe(nil), without=T.unsafe(nil)); end
-  def node_options(); end
-  def output_file(); end
-  def output_format(); end
-  def relations(); end
-  def viz(); end
-  GRAPH_NAME = ::T.let(nil, ::T.untyped)
-end
-class Bundler::Graph::GraphVizClient
-  def g(); end
-  def initialize(graph_instance); end
-  def run(); end
-end
-class Bundler::Graph::GraphVizClient
-end
-class Bundler::Graph
-end
-class Bundler::Index
-  include ::Enumerable
-end
-class Bundler::Injector
-  def initialize(deps, options=T.unsafe(nil)); end
-  def inject(gemfile_path, lockfile_path); end
-  def remove(gemfile_path, lockfile_path); end
-  INJECTED_GEMS = ::T.let(nil, ::T.untyped)
-end
-class Bundler::Injector
-  def self.inject(new_deps, options=T.unsafe(nil)); end
-  def self.remove(gems, options=T.unsafe(nil)); end
-end
-class Bundler::Installer
-  def generate_bundler_executable_stubs(spec, options=T.unsafe(nil)); end
-  def generate_standalone_bundler_executable_stubs(spec); end
-  def initialize(root, definition); end
-  def post_install_messages(); end
-  def run(options); end
-end
-class Bundler::Installer
-  def self.ambiguous_gems(); end
-  def self.ambiguous_gems=(ambiguous_gems); end
-  def self.install(root, definition, options=T.unsafe(nil)); end
-end
-class Bundler::Molinillo::DependencyGraph
-  include ::Enumerable
-end
-class Bundler::Molinillo::DependencyGraph::Log
-  extend ::Enumerable
-end
-class Bundler::Molinillo::DependencyGraph::Vertex
-  def _recursive_predecessors(vertices=T.unsafe(nil)); end
-  def _recursive_successors(vertices=T.unsafe(nil)); 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
-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
-end
-class Bundler::ProcessLock
-end
-class Bundler::ProcessLock
-  def self.lock(bundle_path=T.unsafe(nil)); end
-end
-class Bundler::Retry
-  def attempt(&block); end
-  def attempts(&block); end
-  def current_run(); end
-  def current_run=(current_run); end
-  def initialize(name, exceptions=T.unsafe(nil), retries=T.unsafe(nil)); end
-  def name(); end
-  def name=(name); end
-  def total_runs(); end
-  def total_runs=(total_runs); end
-end
-class Bundler::Retry
-  def self.attempts(); end
-  def self.default_attempts(); end
-  def self.default_retries(); end
-end
-class Bundler::RubyGemsGemInstaller
-end
-class Bundler::RubyGemsGemInstaller
-end
-class Bundler::RubygemsIntegration
-  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 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
-end
-class Bundler::SpecSet
-  include ::Enumerable
-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
-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 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)); end
-  def info(msg, newline=T.unsafe(nil)); end
-  def initialize(options=T.unsafe(nil)); end
-  def level(name=T.unsafe(nil)); end
-  def level=(level); end
-  def no?(); end
-  def quiet?(); end
-  def shell=(shell); end
-  def silence(&blk); end
-  def trace(e, newline=T.unsafe(nil), force=T.unsafe(nil)); end
-  def unprinted_warnings(); end
-  def warn(msg, newline=T.unsafe(nil)); end
-  def yes?(msg); end
-  LEVELS = ::T.let(nil, ::T.untyped)
-end
-class Bundler::UI::Shell
-end
-module Bundler::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.original_exec(*args); end
-  def self.original_system(*args); end
-  def self.unbundled_env(); end
-  def self.unbundled_exec(*args); end
-  def self.unbundled_system(*args); end
-  def self.with_unbundled_env(); end
-end
-class Class
-  def json_creatable?(); end
-end
-class Complex
-  def self.polar(*_); end
-  def self.rect(*_); end
-  def self.rectangular(*_); end
-end
-class Delegator
-  def !=(obj); end
-  def ==(obj); end
-  def __getobj__(); end
-  def __setobj__(obj); end
-  def eql?(obj); end
-  def initialize(obj); end
-  def marshal_dump(); end
-  def marshal_load(data); end
-  def method_missing(m, *args, &block); end
-  def methods(all=T.unsafe(nil)); end
-  def protected_methods(all=T.unsafe(nil)); end
-  def public_methods(all=T.unsafe(nil)); end
-  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
-end
-class Delegator
-  def self.const_missing(n); end
-  def self.delegating_block(mid); end
-  def self.public_api(); end
-end
-class DidYouMean::ClassNameChecker
-  def class_name(); end
-  def class_names(); end
-  def corrections(); end
-  def initialize(exception); end
-  def scopes(); end
-end
-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::SpellChecker
-  def correct(input); end
-  def initialize(dictionary:); end
-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.children(*_); end
-  def self.each_child(*_); end
-  def self.empty?(_); end
-  def self.exists?(_); end
-  def self.tmpdir(); end
-end
-class ERB
-  def def_method(mod, methodname, fname=T.unsafe(nil)); end
-  def def_module(methodname=T.unsafe(nil)); end
-  def result_with_hash(hash); end
-end
-class Encoding
-  def _dump(*_); end
-  CESU_8 = ::T.let(nil, ::T.untyped)
-end
-class Encoding::Converter
-  def convert(_); end
-  def convpath(); end
-  def destination_encoding(); end
-  def finish(); end
-  def initialize(*_); end
-  def insert_output(_); end
-  def last_error(); end
-  def primitive_convert(*_); end
-  def primitive_errinfo(); end
-  def putback(*_); end
-  def replacement(); end
-  def replacement=(replacement); end
-  def source_encoding(); end
-end
-class Encoding::Converter
-  def self.asciicompat_encoding(_); end
-  def self.search_convpath(*_); end
-end
-class Encoding::InvalidByteSequenceError
-  def destination_encoding(); end
-  def destination_encoding_name(); end
-  def error_bytes(); end
-  def incomplete_input?(); end
-  def readagain_bytes(); end
-  def source_encoding(); end
-  def source_encoding_name(); end
-end
-class Encoding::UndefinedConversionError
-  def destination_encoding(); end
-  def destination_encoding_name(); end
-  def error_char(); end
-  def source_encoding(); end
-  def source_encoding_name(); end
-end
-class Encoding
-  def self._load(_); end
-  def self.locale_charmap(); end
-end
-module Enumerable
-  def chain(*_); end
-  def chunk(); end
-  def chunk_while(); end
-  def each_entry(*_); end
-  def filter_map(); end
-  def grep_v(_); end
-  def slice_after(*_); end
-  def slice_before(*_); end
-  def slice_when(); end
-  def sum(*_); end
-  def tally(); end
-  def to_set(klass=T.unsafe(nil), *args, &block); end
-  def uniq(); end
-  def zip(*_); end
-end
-class Enumerator
-  def +(_); end
-  def each_with_index(); end
-end
-class Enumerator::ArithmeticSequence
-  def begin(); end
-  def each(&blk); end
-  def end(); end
-  def exclude_end?(); end
-  def last(*_); end
-  def step(); end
-end
-class Enumerator::ArithmeticSequence
-end
-class Enumerator::Chain
-end
-class Enumerator::Chain
-end
-class Enumerator::Generator
-  def each(*_, &blk); end
-  def initialize(*_); end
-end
-class Enumerator::Lazy
-  def chunk(*_); end
-  def chunk_while(*_); end
-  def eager(); end
-  def force(*_); end
-  def slice_when(*_); 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
-class Errno::EAUTH
-  Errno = ::T.let(nil, ::T.untyped)
-end
-class Errno::EAUTH
-end
-class Errno::EBADARCH
-  Errno = ::T.let(nil, ::T.untyped)
-end
-class Errno::EBADARCH
-end
-class Errno::EBADEXEC
-  Errno = ::T.let(nil, ::T.untyped)
-end
-class Errno::EBADEXEC
-end
-class Errno::EBADMACHO
-  Errno = ::T.let(nil, ::T.untyped)
-end
-class Errno::EBADMACHO
-end
-class Errno::EBADRPC
-  Errno = ::T.let(nil, ::T.untyped)
-end
-class Errno::EBADRPC
-end
-Errno::ECAPMODE = Errno::NOERROR
-Errno::EDEADLOCK = Errno::NOERROR
-class Errno::EDEVERR
-  Errno = ::T.let(nil, ::T.untyped)
-end
-class Errno::EDEVERR
-end
-Errno::EDOOFUS = Errno::NOERROR
-class Errno::EFTYPE
-  Errno = ::T.let(nil, ::T.untyped)
-end
-class Errno::EFTYPE
-end
-Errno::EIPSEC = Errno::NOERROR
-class Errno::ELAST
-  Errno = ::T.let(nil, ::T.untyped)
-end
-class Errno::ELAST
-end
-class Errno::ENEEDAUTH
-  Errno = ::T.let(nil, ::T.untyped)
-end
-class Errno::ENEEDAUTH
-end
-class Errno::ENOATTR
-  Errno = ::T.let(nil, ::T.untyped)
-end
-class Errno::ENOATTR
-end
-class Errno::ENOPOLICY
-  Errno = ::T.let(nil, ::T.untyped)
-end
-class Errno::ENOPOLICY
-end
-Errno::ENOTCAPABLE = Errno::NOERROR
-class Errno::ENOTSUP
-  Errno = ::T.let(nil, ::T.untyped)
-end
-class Errno::ENOTSUP
-end
-class Errno::EPROCLIM
-  Errno = ::T.let(nil, ::T.untyped)
-end
-class Errno::EPROCLIM
-end
-class Errno::EPROCUNAVAIL
-  Errno = ::T.let(nil, ::T.untyped)
-end
-class Errno::EPROCUNAVAIL
-end
-class Errno::EPROGMISMATCH
-  Errno = ::T.let(nil, ::T.untyped)
-end
-class Errno::EPROGMISMATCH
-end
-class Errno::EPROGUNAVAIL
-  Errno = ::T.let(nil, ::T.untyped)
-end
-class Errno::EPROGUNAVAIL
-end
-class Errno::EPWROFF
-  Errno = ::T.let(nil, ::T.untyped)
-end
-class Errno::EPWROFF
-end
-Errno::EQFULL = Errno::ELAST
-class Errno::ERPCMISMATCH
-  Errno = ::T.let(nil, ::T.untyped)
-end
-class Errno::ERPCMISMATCH
-end
-class Errno::ESHLIBVERS
-  Errno = ::T.let(nil, ::T.untyped)
-end
-class Errno::ESHLIBVERS
-end
-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 change(); end
-  def change=(_); end
-  def dir=(_); end
-  def expire(); end
-  def expire=(_); end
-  def gecos(); end
-  def gecos=(_); end
-  def gid=(_); end
-  def name=(_); end
-  def passwd=(_); end
-  def shell=(_); end
-  def uclass(); end
-  def uclass=(_); end
-  def uid=(_); end
-end
-class Etc::Passwd
-  extend ::Enumerable
-  def self.[](*_); end
-  def self.each(&blk); end
-  def self.members(); end
-end
-class Exception
-  def full_message(*_); end
-end
-class Exception
-  def self.exception(*_); end
-  def self.to_tty?(); end
-end
-class ExitCalledError
-end
-class ExitCalledError
-end
-class FalseClass
-  include ::JSON::Ext::Generator::GeneratorMethods::FalseClass
-end
-class Fiber
-  def initialize(*_); end
-  def resume(*_); end
-end
-class Fiber
-  def self.yield(*_); end
-end
-class File
-  Separator = ::T.let(nil, ::T.untyped)
-end
-class File::Stat
-  def size?(); end
-end
-class File
-  def self.absolute_path?(_); end
-  def self.empty?(_); end
-  def self.exists?(_); end
-  def self.lutime(*_); end
-  def self.mkfifo(*_); end
-end
-module FileUtils
-  include ::FileUtils::StreamUtils_
-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
-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.compact(); end
-  def self.latest_gc_info(hash_or_key=T.unsafe(nil)); end
-  def self.stress=(flag); end
-  def self.verify_compaction_references(*_); end
-  def self.verify_internal_consistency(); end
-  def self.verify_transient_heap_internal_consistency(); end
-end
-module Gem
-  UNTAINT = ::T.let(nil, ::T.untyped)
-end
-class Gem::BasicSpecification
-  def self._deprecated_default_specifications_dir(); end
-end
-class Gem::Command
-  def check_deprecated_options(options); end
-  def deprecate_option(name, version: T.unsafe(nil), extra_msg: T.unsafe(nil)); end
-end
-class Gem::Dependency
-  def identity(); end
-end
-class Gem::DependencyInstaller
-  def _deprecated_available_set_for(dep_or_name, version); end
-  def _deprecated_find_gems_with_sources(dep, best_only=T.unsafe(nil)); end
-  def _deprecated_find_spec_by_name_and_version(gem_name, version=T.unsafe(nil), prerelease=T.unsafe(nil)); end
-end
-class Gem::Installer
-  def _deprecated_unpack(directory); end
-  def package(); end
-end
-class Gem::Package
-  def gem(); end
-end
-class Gem::Package::TarHeader
-  def self.oct_or_256based(str); end
-end
-class Gem::Package
-  def self.raw_spec(path, security_policy=T.unsafe(nil)); end
-end
-class Gem::RemoteFetcher
-  include ::Gem::UriParsing
-  def _deprecated_fetch_size(uri); end
-  def s3_uri_signer(uri); 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::RemoteFetcher
-  extend ::Gem::Deprecate
-end
-class Gem::Requirement
-  DefaultPrereleaseRequirement = ::T.let(nil, ::T.untyped)
-end
-class Gem::Requirement
-  def self.default_prerelease(); end
-end
-class Gem::Resolver::ActivationRequest
-  def platform(); end
-end
-class Gem::Resolver::Molinillo::DependencyGraph::Log
-  extend ::Enumerable
-end
-class Gem::S3URISigner
-  def initialize(uri); end
-  def sign(expiration=T.unsafe(nil)); end
-  def uri(); end
-  def uri=(uri); end
-  BASE64_URI_TRANSLATE = ::T.let(nil, ::T.untyped)
-  EC2_IAM_INFO = ::T.let(nil, ::T.untyped)
-  EC2_IAM_SECURITY_CREDENTIALS = ::T.let(nil, ::T.untyped)
-end
-class Gem::S3URISigner::ConfigurationError
-  def initialize(message); end
-end
-class Gem::S3URISigner::ConfigurationError
-end
-class Gem::S3URISigner::InstanceProfileError
-  def initialize(message); end
-end
-class Gem::S3URISigner::InstanceProfileError
-end
-class Gem::S3URISigner::S3Config
-  def access_key_id(); end
-  def access_key_id=(_); end
-  def region(); end
-  def region=(_); end
-  def secret_access_key(); end
-  def secret_access_key=(_); end
-  def security_token(); end
-  def security_token=(_); end
-end
-class Gem::S3URISigner::S3Config
-  def self.[](*_); end
-  def self.members(); end
-end
-class Gem::S3URISigner
-end
-class Gem::Source
-  include ::Gem::Text
-  def typo_squatting?(host, distance_threshold=T.unsafe(nil)); end
-end
-class Gem::Specification
-  def _deprecated_rubyforge_project=(_deprecated_rubyforge_project); end
-  LOAD_CACHE_MUTEX = ::T.let(nil, ::T.untyped)
-end
-class Gem::Specification
-  extend ::Enumerable
-  def self.default_stubs(pattern=T.unsafe(nil)); end
-end
-class Gem::SpecificationPolicy
-  include ::Gem::UserInteraction
-  include ::Gem::DefaultUserInteraction
-  include ::Gem::Text
-end
-class Gem::UriParser
-  def parse(uri); end
-  def parse!(uri); end
-end
-class Gem::UriParser
-end
-module Gem::UriParsing
-end
-module Gem::UriParsing
-end
-module Gem::Util
-  def self.correct_for_windows_path(path); end
-end
-module Gem
-  def self.add_to_load_path(*paths); end
-  def self.default_specifications_dir(); end
-  def self.java_platform?(); end
-  def self.source_date_epoch(); end
-  def self.suffix_regexp(); end
-end
-class Hash
-  include ::JSON::Ext::Generator::GeneratorMethods::Hash
-  def <(_); end
-  def <=(_); end
-  def >(_); end
-  def >=(_); end
-  def compact(); end
-  def compact!(); end
-  def deconstruct_keys(_); end
-  def default_proc(); end
-  def default_proc=(default_proc); end
-  def fetch_values(*_); end
-  def flatten(*_); end
-  def index(_); end
-  def replace(_); end
-  def slice(*_); end
-  def to_h(); end
-  def to_proc(); end
-  def transform_keys(); end
-  def transform_keys!(); end
-  def transform_values(); end
-  def transform_values!(); end
-  def update(*_); end
-end
-class Hash
-  def self.try_convert(_); end
-end
-class IO
-  def external_encoding(); end
-  def nonblock(*_); end
-  def nonblock=(nonblock); end
-  def nonblock?(); end
-  def nread(); end
-  def pathconf(_); end
-  def pread(*_); end
-  def pwrite(_, _1); end
-  def ready?(); end
-  def set_encoding_by_bom(); end
-  def wait(*_); end
-  def wait_readable(*_); end
-  def wait_writable(*_); end
-  def write_nonblock(buf, exception: T.unsafe(nil)); end
-end
-IO::EWOULDBLOCKWaitReadable = IO::EAGAINWaitReadable
-IO::EWOULDBLOCKWaitWritable = IO::EAGAINWaitWritable
-class IO
-  def self.foreach(*_); end
-end
-class IPAddr
-  include ::Comparable
-  def &(other); end
-  def <<(num); end
-  def ==(other); end
-  def ===(other); end
-  def >>(num); end
-  def eql?(other); end
-  def family(); end
-  def hton(); end
-  def include?(other); end
-  def initialize(addr=T.unsafe(nil), family=T.unsafe(nil)); end
-  def ip6_arpa(); end
-  def ip6_int(); end
-  def ipv4?(); end
-  def ipv4_compat(); end
-  def ipv4_compat?(); end
-  def ipv4_mapped(); end
-  def ipv4_mapped?(); end
-  def ipv6?(); end
-  def link_local?(); end
-  def loopback?(); end
-  def mask(prefixlen); end
-  def mask!(mask); end
-  def native(); end
-  def prefix(); end
-  def prefix=(prefix); end
-  def private?(); end
-  def reverse(); end
-  def set(addr, *family); end
-  def succ(); end
-  def to_i(); end
-  def to_range(); end
-  def to_string(); end
-  def |(other); end
-  def ~(); end
-  IN4MASK = ::T.let(nil, ::T.untyped)
-  IN6FORMAT = ::T.let(nil, ::T.untyped)
-  IN6MASK = ::T.let(nil, ::T.untyped)
-  RE_IPV4ADDRLIKE = ::T.let(nil, ::T.untyped)
-  RE_IPV6ADDRLIKE_COMPRESSED = ::T.let(nil, ::T.untyped)
-  RE_IPV6ADDRLIKE_FULL = ::T.let(nil, ::T.untyped)
-end
-class IPAddr::AddressFamilyError
-end
-class IPAddr::AddressFamilyError
-end
-class IPAddr::Error
-end
-class IPAddr::Error
-end
-class IPAddr::InvalidAddressError
-end
-class IPAddr::InvalidAddressError
-end
-class IPAddr::InvalidPrefixError
-end
-class IPAddr::InvalidPrefixError
-end
-class IPAddr
-  def self.new_ntoh(addr); end
-  def self.ntop(addr); end
-end
-class Integer
-  include ::JSON::Ext::Generator::GeneratorMethods::Integer
-  def allbits?(_); end
-  def anybits?(_); end
-  def digits(*_); end
-  def nobits?(_); end
-  def pow(*_); end
-  def to_bn(); end
-end
-class Integer
-  def self.sqrt(_); end
-end
-class JSON::Ext::Generator::State
-  def self.from_state(_); end
-end
-class JSON::Ext::Parser
-  def initialize(*_); end
-end
-JSON::Parser = JSON::Ext::Parser
-JSON::State = JSON::Ext::Generator::State
-JSON::UnparserError = JSON::GeneratorError
-module Kernel
-  def gem(dep, *reqs); end
-  def itself(); end
-  def object_id(); end
-  def respond_to?(*_); end
-  def then(); end
-  def yield_self(); end
-end
-module Kernel
-  def self.at_exit(); end
-end
-class KeyError
-  include ::DidYouMean::Correctable
-  def key(); end
-  def receiver(); end
-end
-class LoadError
-  def path(); end
-end
-class LocalJumpError
-  def exit_value(); end
-  def reason(); end
-end
-module Marshal
-  def self.restore(*_); end
-end
-class Module
-  def const_source_location(*_); end
-  def deprecate_constant(*_); end
-  def undef_method(*_); end
-end
-class Module
-  def self.used_modules(); end
-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
-  def mon_enter(); end
-  def mon_exit(); end
-  def mon_locked?(); end
-  def mon_owned?(); end
-  def mon_synchronize(&b); end
-  def mon_try_enter(); end
-  def new_cond(); end
-  def synchronize(&b); end
-  def try_mon_enter(); end
-end
-class MonitorMixin::ConditionVariable
-  def broadcast(); end
-  def initialize(monitor); end
-  def signal(); end
-  def wait(timeout=T.unsafe(nil)); end
-  def wait_until(); end
-  def wait_while(); end
-end
-module MonitorMixin
-  def self.extend_object(obj); end
-end
-class NameError
-  include ::DidYouMean::Correctable
-  def name(); end
-  def receiver(); end
-end
-class NilClass
-  include ::JSON::Ext::Generator::GeneratorMethods::NilClass
-  def to_i(); end
-end
-class NoMatchingPatternError
-end
-class NoMatchingPatternError
-end
-class NoMethodError
-  def args(); end
-  def private_call?(); end
-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 ObjectSpace::WeakMap
-  def [](_); end
-  def []=(_, _1); end
-  def each(&blk); end
-  def each_key(); end
-  def each_pair(); end
-  def each_value(); end
-  def key?(_); end
-  def keys(); end
-  def length(); end
-  def size(); end
-  def values(); end
-end
-module ObjectSpace
-  def self.count_objects(*_); end
-  def self.define_finalizer(*_); end
-  def self.garbage_collect(full_mark: T.unsafe(nil), immediate_mark: T.unsafe(nil), immediate_sweep: T.unsafe(nil)); end
-  def self.undefine_finalizer(_); end
-end
-class OpenStruct
-  VERSION = ::T.let(nil, ::T.untyped)
-end
-class Pathname
-  def empty?(); end
-  def fnmatch?(*_); end
-  def glob(*_); end
-  def make_symlink(_); end
-end
-class Proc
-  def <<(_); end
-  def ===(*_); end
-  def >>(_); end
-  def clone(); end
-  def ruby2_keywords(); end
-  def yield(*_); end
-end
-module Process
-  CLOCK_MONOTONIC_RAW_APPROX = ::T.let(nil, ::T.untyped)
-  CLOCK_UPTIME_RAW = ::T.let(nil, ::T.untyped)
-  CLOCK_UPTIME_RAW_APPROX = ::T.let(nil, ::T.untyped)
-end
-module Process::Sys
-  def self.getegid(); end
-end
-class Process::Tms
-  def cstime(); end
-  def cstime=(_); end
-  def cutime(); end
-  def cutime=(_); end
-  def stime(); end
-  def stime=(_); end
-  def utime(); end
-  def utime=(_); end
-end
-class Process::Tms
-  def self.[](*_); end
-  def self.members(); end
-end
-module Process
-  def self.last_status(); end
-  def self.setpgrp(); end
-end
-module Random::Formatter
-  def alphanumeric(n=T.unsafe(nil)); end
-  ALPHANUMERIC = ::T.let(nil, ::T.untyped)
-end
-class Random
-  extend ::Random::Formatter
-  def self.bytes(_); end
-  def self.urandom(_); end
-end
-class Range
-  def %(_); end
-  def entries(); end
-  def to_a(); end
-end
-module RbConfig
-  def self.expand(val, config=T.unsafe(nil)); end
-  def self.fire_update!(key, val, mkconf=T.unsafe(nil), conf=T.unsafe(nil)); end
-  def self.ruby(); end
-end
-class Regexp
-  def match?(*_); end
-end
-module RubyVM::AbstractSyntaxTree
-end
-class RubyVM::AbstractSyntaxTree::Node
-  def children(); end
-  def first_column(); end
-  def first_lineno(); end
-  def last_column(); end
-  def last_lineno(); end
-  def type(); end
-end
-class RubyVM::AbstractSyntaxTree::Node
-end
-module RubyVM::AbstractSyntaxTree
-  def self.of(body); end
-  def self.parse(string); end
-  def self.parse_file(pathname); end
-end
-class RubyVM::InstructionSequence
-  def absolute_path(); end
-  def base_label(); end
-  def disasm(); end
-  def disassemble(); end
-  def each_child(); end
-  def eval(); end
-  def first_lineno(); end
-  def label(); end
-  def path(); end
-  def to_a(); end
-  def to_binary(*_); end
-  def trace_points(); end
-end
-class RubyVM::InstructionSequence
-  def self.compile(*_); end
-  def self.compile_file(*_); end
-  def self.compile_option(); end
-  def self.compile_option=(compile_option); end
-  def self.disasm(_); end
-  def self.disassemble(_); end
-  def self.load_from_binary(_); end
-  def self.load_from_binary_extra_data(_); end
-  def self.of(_); end
-end
-module RubyVM::MJIT
-end
-module RubyVM::MJIT
-  def self.enabled?(); end
-  def self.pause(*_); end
-  def self.resume(); end
-end
-class RubyVM
-  def self.stat(*_); end
-end
-class Set
-  def ==(other); end
-  def ===(o); end
-  def compare_by_identity(); end
-  def compare_by_identity?(); end
-  def divide(&func); end
-  def eql?(o); end
-  def flatten_merge(set, seen=T.unsafe(nil)); end
-  def pretty_print(pp); end
-  def pretty_print_cycle(pp); end
-  def reset(); end
-  InspectKey = ::T.let(nil, ::T.untyped)
-end
-class SignalException
-  def signm(); end
-  def signo(); end
-end
-class SimpleDelegator
-  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
-end
-class Sorbet::Private::ConstantLookupCache
-  def all_module_aliases(); end
-  def all_module_names(); end
-  def all_named_modules(); end
-  def class_by_name(name); end
-  def name_by_class(klass); end
-  DEPRECATED_CONSTANTS = ::T.let(nil, ::T.untyped)
-end
-class Sorbet::Private::ConstantLookupCache::ConstantEntry
-  def aliases(); end
-  def aliases=(_); end
-  def const(); end
-  def const=(_); end
-  def const_name(); end
-  def const_name=(_); end
-  def found_name(); end
-  def found_name=(_); end
-  def owner(); end
-  def owner=(_); end
-  def primary_name(); end
-  def primary_name=(_); end
-end
-class Sorbet::Private::ConstantLookupCache::ConstantEntry
-  def self.[](*_); end
-  def self.members(); end
-end
-class Sorbet::Private::ConstantLookupCache
-end
-class Sorbet::Private::CreateConfig
-  include ::Sorbet::Private::StepInterface
-  SORBET_CONFIG_FILE = ::T.let(nil, ::T.untyped)
-  SORBET_DIR = ::T.let(nil, ::T.untyped)
-end
-class Sorbet::Private::CreateConfig
-  def self.main(); end
-  def self.output_file(); end
-end
-class Sorbet::Private::FetchRBIs
-  include ::Sorbet::Private::StepInterface
-  HEADER = ::T.let(nil, ::T.untyped)
-  RBI_CACHE_DIR = ::T.let(nil, ::T.untyped)
-  SORBET_CONFIG_FILE = ::T.let(nil, ::T.untyped)
-  SORBET_DIR = ::T.let(nil, ::T.untyped)
-  SORBET_RBI_LIST = ::T.let(nil, ::T.untyped)
-  SORBET_RBI_SORBET_TYPED = ::T.let(nil, ::T.untyped)
-  SORBET_TYPED_REPO = ::T.let(nil, ::T.untyped)
-  SORBET_TYPED_REVISION = ::T.let(nil, ::T.untyped)
-  XDG_CACHE_HOME = ::T.let(nil, ::T.untyped)
-end
-class Sorbet::Private::FetchRBIs
-  def self.fetch_sorbet_typed(); end
-  def self.main(); end
-  def self.matching_version_directories(root, version); end
-  def self.output_file(); end
-  def self.paths_for_gem_version(gemspec); end
-  def self.paths_for_ruby_version(ruby_version); end
-  def self.vendor_rbis_within_paths(vendor_paths); end
-end
-class Sorbet::Private::FindGemRBIs
-  include ::Sorbet::Private::StepInterface
-  GEM_DIR = ::T.let(nil, ::T.untyped)
-  HEADER = ::T.let(nil, ::T.untyped)
-  RBI_CACHE_DIR = ::T.let(nil, ::T.untyped)
-  XDG_CACHE_HOME = ::T.let(nil, ::T.untyped)
-end
-class Sorbet::Private::FindGemRBIs
-  def self.main(); end
-  def self.output_file(); end
-  def self.paths_within_gem_sources(gemspec); end
-end
-module Sorbet::Private::GemGeneratorTracepoint
-  include ::Sorbet::Private::StepInterface
-  OUTPUT = ::T.let(nil, ::T.untyped)
-end
-class Sorbet::Private::GemGeneratorTracepoint::ClassDefinition
-  def defs(); end
-  def defs=(_); end
-  def id(); end
-  def id=(_); end
-  def klass(); end
-  def klass=(_); end
-end
-class Sorbet::Private::GemGeneratorTracepoint::ClassDefinition
-  def self.[](*_); end
-  def self.members(); end
-end
-class Sorbet::Private::GemGeneratorTracepoint::TracepointSerializer
-  def initialize(files:, delegate_classes:); end
-  def serialize(output_dir); end
-  BAD_METHODS = ::T.let(nil, ::T.untyped)
-  HEADER = ::T.let(nil, ::T.untyped)
-  SPECIAL_METHOD_NAMES = ::T.let(nil, ::T.untyped)
-end
-class Sorbet::Private::GemGeneratorTracepoint::TracepointSerializer
-end
-class Sorbet::Private::GemGeneratorTracepoint::Tracer
-end
-class Sorbet::Private::GemGeneratorTracepoint::Tracer
-  def self.add_to_context(item); end
-  def self.disable_tracepoints(); end
-  def self.finish(); end
-  def self.install_tracepoints(); end
-  def self.on_method_added(mod, method, singleton); end
-  def self.on_module_created(mod); end
-  def self.on_module_extended(extended, extender); end
-  def self.on_module_included(included, includer); end
-  def self.pre_cache_module_methods(); end
-  def self.register_delegate_class(klass, delegate); end
-  def self.start(); end
-  def self.trace(); end
-  def self.trace_results(); end
-end
-module Sorbet::Private::GemGeneratorTracepoint
-  def self.main(output_dir=T.unsafe(nil)); end
-  def self.output_file(); end
-end
-class Sorbet::Private::GemLoader
-  GEM_LOADER = ::T.let(nil, ::T.untyped)
-  NO_GEM = ::T.let(nil, ::T.untyped)
-end
-class Sorbet::Private::GemLoader
-  def self.my_require(gem); end
-  def self.require_all_gems(); end
-  def self.require_gem(gem); end
-end
-class Sorbet::Private::HiddenMethodFinder
-  include ::Sorbet::Private::StepInterface
-  def all_modules_and_aliases(); end
-  def capture_stderr(); end
-  def constant_cache(); end
-  def gen_source_rbi(classes, aliases); end
-  def looks_like_stub_name(name); end
-  def main(); end
-  def mk_dir(); end
-  def read_constants(); end
-  def real_name(mod); end
-  def require_everything(); end
-  def rm_dir(); end
-  def serialize_alias(source_entry, rbi_entry, my_klass, source_symbols, rbi_symbols); end
-  def serialize_class(source_entry, rbi_entry, klass, source_symbols, rbi_symbols, source_by_name); end
-  def serialize_constants(source, rbi, klass, is_singleton, source_symbols, rbi_symbols); end
-  def symbols_id_to_name(entry, prefix); end
-  def write_constants(); end
-  def write_diff(source, rbi); end
-  BLACKLIST = ::T.let(nil, ::T.untyped)
-  DIFF_RBI = ::T.let(nil, ::T.untyped)
-  ERRORS_RBI = ::T.let(nil, ::T.untyped)
-  HEADER = ::T.let(nil, ::T.untyped)
-  HIDDEN_RBI = ::T.let(nil, ::T.untyped)
-  PATH = ::T.let(nil, ::T.untyped)
-  RBI_CONSTANTS = ::T.let(nil, ::T.untyped)
-  RBI_CONSTANTS_ERR = ::T.let(nil, ::T.untyped)
-  SOURCE_CONSTANTS = ::T.let(nil, ::T.untyped)
-  SOURCE_CONSTANTS_ERR = ::T.let(nil, ::T.untyped)
-  TMP_PATH = ::T.let(nil, ::T.untyped)
-  TMP_RBI = ::T.let(nil, ::T.untyped)
-end
-class Sorbet::Private::HiddenMethodFinder
-  def self.main(); end
-  def self.output_file(); end
-end
-module Sorbet::Private::Main
-end
-module Sorbet::Private::Main
-  def self.cyan(msg); end
-  def self.emojify(emoji, msg); end
-  def self.init(); end
-  def self.main(argv); end
-  def self.make_step(step); end
-  def self.usage(); end
-  def self.yellow(msg); end
-end
-module Sorbet::Private::RealStdlib
-end
-module Sorbet::Private::RealStdlib
-  def self.real_ancestors(mod); end
-  def self.real_autoload?(o, klass); end
-  def self.real_const_get(obj, const, arg); end
-  def self.real_constants(mod); end
-  def self.real_eqeq(obj, other); end
-  def self.real_hash(o); end
-  def self.real_instance_methods(mod, arg); end
-  def self.real_is_a?(o, klass); end
-  def self.real_method(obj, sym); end
-  def self.real_name(o); end
-  def self.real_object_id(o); end
-  def self.real_private_instance_methods(mod, arg); end
-  def self.real_singleton_class(obj); end
-  def self.real_singleton_methods(mod, arg); end
-  def self.real_spaceship(obj, arg); end
-  def self.real_superclass(o); end
-end
-class Sorbet::Private::RequireEverything
-end
-class Sorbet::Private::RequireEverything
-  def self.excluded_rails_files(); end
-  def self.load_bundler(); end
-  def self.load_rails(); end
-  def self.my_require(abs_path, numerator, denominator); end
-  def self.patch_kernel(); end
-  def self.rails?(); end
-  def self.rails_load_paths(); end
-  def self.rb_file_paths(); end
-  def self.require_all_files(); end
-  def self.require_everything(); end
-end
-class Sorbet::Private::Serialize
-  def alias(base, other_name); end
-  def ancestor_has_method(method, klass); end
-  def blacklisted_method(method); end
-  def class_or_module(class_name); end
-  def comparable?(value); end
-  def constant(const, value); end
-  def from_method(method); end
-  def initialize(constant_cache); end
-  def serialize_method(method, static=T.unsafe(nil), with_sig: T.unsafe(nil)); end
-  def serialize_sig(parameters); end
-  def to_sig(kind, name); end
-  def valid_class_name(name); end
-  def valid_method_name(name); end
-  BLACKLIST_CONSTANTS = ::T.let(nil, ::T.untyped)
-  KEYWORDS = ::T.let(nil, ::T.untyped)
-  SPECIAL_METHOD_NAMES = ::T.let(nil, ::T.untyped)
-end
-class Sorbet::Private::Serialize
-  def self.header(typed=T.unsafe(nil), subcommand=T.unsafe(nil)); end
-end
-module Sorbet::Private::Status
-end
-module Sorbet::Private::Status
-  def self.done(); end
-  def self.say(message, print_without_tty: T.unsafe(nil)); end
-end
-module Sorbet::Private::StepInterface
-end
-module Sorbet::Private::StepInterface
-  def self.main(); end
-  def self.output_file(); end
-end
-class Sorbet::Private::SuggestTyped
-  include ::Sorbet::Private::StepInterface
-end
-class Sorbet::Private::SuggestTyped
-  def self.main(); end
-  def self.output_file(); end
-  def self.suggest_typed(); end
-end
-class Sorbet::Private::TodoRBI
-  include ::Sorbet::Private::StepInterface
-  HEADER = ::T.let(nil, ::T.untyped)
-  OUTPUT = ::T.let(nil, ::T.untyped)
-end
-class Sorbet::Private::TodoRBI
-  def self.main(); end
-  def self.output_file(); end
-end
-class SortedSet
-  def initialize(*args, &block); end
-end
-class SortedSet
-  def self.setup(); end
-end
-class StopIteration
-  def result(); end
-end
-class String
-  include ::JSON::Ext::Generator::GeneratorMethods::String
-  def []=(*_); end
-  def casecmp?(_); end
-  def each_grapheme_cluster(); 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(fmt); end
-end
-class String
-  extend ::JSON::Ext::Generator::GeneratorMethods::String::Extend
-end
-class Struct
-  def [](_); end
-  def []=(_, _1); end
-  def deconstruct(); end
-  def deconstruct_keys(_); end
-  def dig(*_); end
-  def each_pair(); end
-  def filter(*_); end
-  def length(); end
-  def members(); end
-  def select(*_); end
-  def size(); end
-  def to_a(); end
-  def to_h(); end
-  def values(); end
-  def values_at(*_); end
-end
-Struct::Group = Etc::Group
-Struct::Passwd = Etc::Passwd
-Struct::Tms = Process::Tms
-class Symbol
-  def end_with?(*_); end
-  def start_with?(*_); end
-end
-class SystemCallError
-  def errno(); end
-end
-class SystemExit
-  def status(); end
-  def success?(); end
-end
-class Time
-  def ceil(*_); end
-  def floor(*_); end
-end
-class TracePoint
-  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
-class UnboundMethod
-  def bind_call(*_); end
-  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
-  def self.[](_); end
-  def self.[]=(_, _1); end
-end