diff options
Diffstat (limited to 'sorbet/rbi/hidden-definitions/hidden.rbi')
-rw-r--r-- | sorbet/rbi/hidden-definitions/hidden.rbi | 16981 |
1 files changed, 16981 insertions, 0 deletions
diff --git a/sorbet/rbi/hidden-definitions/hidden.rbi b/sorbet/rbi/hidden-definitions/hidden.rbi new file mode 100644 index 0000000..7f48ddb --- /dev/null +++ b/sorbet/rbi/hidden-definitions/hidden.rbi @@ -0,0 +1,16981 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi hidden-definitions + +# typed: autogenerated + +class Addrinfo + def connect_internal(local_addrinfo, timeout=T.unsafe(nil)); end +end + +class Array + include ::JSON::Ext::Generator::GeneratorMethods::Array + def abbrev(pattern=T.unsafe(nil)); end + + def shelljoin(); end + + def to_h(); end +end + +class Array + def self.try_convert(_); end +end + +class BasicObject + def as_null_object(); end + + def null_object?(); end + + def received_message?(message, *args, &block); end + + def should(matcher=T.unsafe(nil), message=T.unsafe(nil), &block); end + + def should_not(matcher=T.unsafe(nil), message=T.unsafe(nil), &block); end + + def should_not_receive(message, &block); end + + def should_receive(message, opts=T.unsafe(nil), &block); end + + def stub(message_or_hash, opts=T.unsafe(nil), &block); end + + def stub_chain(*chain, &blk); end + + def unstub(message); end +end + +BasicObject::BasicObject = BasicObject + +class BigDecimal + def clone(); end + EXCEPTION_NaN = ::T.let(nil, ::T.untyped) + VERSION = ::T.let(nil, ::T.untyped) +end + +class BigDecimal + def self.new(*args, **kwargs); end +end + +class Binding + def clone(); end + + def irb(); end +end + +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 + include ::Rake::DSL + include ::Rake::FileUtilsExt + include ::FileUtils + include ::FileUtils::StreamUtils_ + def allowed_push_host(); end + + def already_tagged?(); end + + def base(); end + + def build_gem(); end + + def built_gem_path(); end + + def clean?(); end + + def committed?(); end + + def gem_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 + +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 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 + +module Byebug + include ::Byebug::Helpers::ReflectionHelper + def displays(); end + + def displays=(displays); end + + def init_file(); end + + def init_file=(init_file); end + + def mode(); end + + def mode=(mode); end + + def run_init_script(); end + PORT = ::T.let(nil, ::T.untyped) +end + +class Byebug::AutoirbSetting + def banner(); end + + def value=(val); end + DEFAULT = ::T.let(nil, ::T.untyped) +end + +class Byebug::AutoirbSetting +end + +class Byebug::AutolistSetting + def banner(); end + + def value=(val); end + DEFAULT = ::T.let(nil, ::T.untyped) +end + +class Byebug::AutolistSetting +end + +class Byebug::AutoprySetting + def banner(); end + + def value=(val); end + DEFAULT = ::T.let(nil, ::T.untyped) +end + +class Byebug::AutoprySetting +end + +class Byebug::AutosaveSetting + def banner(); end + DEFAULT = ::T.let(nil, ::T.untyped) +end + +class Byebug::AutosaveSetting +end + +class Byebug::BasenameSetting + def banner(); end +end + +class Byebug::BasenameSetting +end + +class Byebug::BreakCommand + include ::Byebug::Helpers::EvalHelper + include ::Byebug::Helpers::FileHelper + include ::Byebug::Helpers::ParseHelper + def execute(); end +end + +class Byebug::BreakCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::Breakpoint + def enabled=(enabled); end + + def enabled?(); end + + def expr(); end + + def expr=(expr); end + + def hit_condition(); end + + def hit_condition=(hit_condition); end + + def hit_count(); end + + def hit_value(); end + + def hit_value=(hit_value); end + + def id(); end + + def initialize(_, _1, _2); end + + def pos(); end + + def source(); end +end + +class Byebug::Breakpoint + def self.add(file, line, expr=T.unsafe(nil)); end + + def self.first(); end + + def self.last(); end + + def self.none?(); end + + def self.potential_line?(filename, lineno); end + + def self.potential_lines(filename); end + + def self.remove(id); end +end + +class Byebug::CallstyleSetting + def banner(); end + DEFAULT = ::T.let(nil, ::T.untyped) +end + +class Byebug::CallstyleSetting +end + +class Byebug::CatchCommand + include ::Byebug::Helpers::EvalHelper + def execute(); end +end + +class Byebug::CatchCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::Command + def arguments(); end + + def confirm(*args, &block); end + + def context(); end + + def errmsg(*args, &block); end + + def frame(); end + + def help(*args, &block); end + + def initialize(processor, input=T.unsafe(nil)); end + + def match(*args, &block); end + + def pr(*args, &block); end + + def prc(*args, &block); end + + def print(*args, &block); end + + def processor(); end + + def prv(*args, &block); end + + def puts(*args, &block); end +end + +class Byebug::Command + extend ::Forwardable + extend ::Byebug::Helpers::StringHelper + def self.allow_in_control(); end + + def self.allow_in_control=(allow_in_control); end + + def self.allow_in_post_mortem(); end + + def self.allow_in_post_mortem=(allow_in_post_mortem); end + + def self.always_run(); end + + def self.always_run=(always_run); end + + def self.columnize(width); end + + def self.help(); end + + def self.match(input); end +end + +class Byebug::CommandList + include ::Enumerable + def each(&blk); end + + def initialize(commands); end + + def match(input); end +end + +class Byebug::CommandList +end + +class Byebug::CommandNotFound + def initialize(input, parent=T.unsafe(nil)); end +end + +class Byebug::CommandNotFound +end + +class Byebug::CommandProcessor + include ::Byebug::Helpers::EvalHelper + def after_repl(); end + + def at_breakpoint(brkpt); end + + def at_catchpoint(exception); end + + def at_end(); end + + def at_line(); end + + def at_return(return_value); end + + def at_tracing(); end + + def before_repl(); end + + def command_list(); end + + def commands(*args, &block); end + + def confirm(*args, &block); end + + def context(); end + + def errmsg(*args, &block); end + + def frame(*args, &block); end + + def initialize(context, interface=T.unsafe(nil)); end + + def interface(); end + + def pr(*args, &block); end + + def prc(*args, &block); end + + def prev_line(); end + + def prev_line=(prev_line); end + + def printer(); end + + def proceed!(); end + + def process_commands(); end + + def prompt(); end + + def prv(*args, &block); end + + def puts(*args, &block); end + + def repl(); end +end + +class Byebug::CommandProcessor + extend ::Forwardable +end + +class Byebug::ConditionCommand + include ::Byebug::Helpers::ParseHelper + def execute(); end +end + +class Byebug::ConditionCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::Context + include ::Byebug::Helpers::FileHelper + def at_breakpoint(breakpoint); end + + def at_catchpoint(exception); end + + def at_end(); end + + def at_line(); end + + def at_return(return_value); end + + def at_tracing(); end + + def backtrace(); end + + def dead?(); end + + def file(*args, &block); end + + def frame(); end + + def frame=(pos); end + + def frame_binding(*_); end + + def frame_class(*_); end + + def frame_file(*_); end + + def frame_line(*_); end + + def frame_method(*_); end + + def frame_self(*_); end + + def full_location(); end + + def ignored?(); end + + def interrupt(); end + + def line(*args, &block); end + + def location(); end + + def resume(); end + + def stack_size(); end + + def step_into(*_); end + + def step_out(*_); end + + def step_over(*_); end + + def stop_reason(); end + + def suspend(); end + + def suspended?(); end + + def switch(); end + + def thnum(); end + + def thread(); end + + def tracing(); end + + def tracing=(tracing); end +end + +class Byebug::Context + extend ::Byebug::Helpers::PathHelper + extend ::Forwardable + def self.ignored_files(); end + + def self.ignored_files=(ignored_files); end + + def self.interface(); end + + def self.interface=(interface); end + + def self.processor(); end + + def self.processor=(processor); end +end + +class Byebug::ContinueCommand + include ::Byebug::Helpers::ParseHelper + def execute(); end +end + +class Byebug::ContinueCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::ControlProcessor + def commands(); end +end + +class Byebug::ControlProcessor +end + +class Byebug::DebugCommand + include ::Byebug::Helpers::EvalHelper + def execute(); end +end + +class Byebug::DebugCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::DebugThread +end + +class Byebug::DebugThread + def self.inherited(); end +end + +class Byebug::DeleteCommand + include ::Byebug::Helpers::ParseHelper + def execute(); end +end + +class Byebug::DeleteCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::DisableCommand + include ::Byebug::Subcommands +end + +class Byebug::DisableCommand::BreakpointsCommand + include ::Byebug::Helpers::ToggleHelper + include ::Byebug::Helpers::ParseHelper + def execute(); end +end + +class Byebug::DisableCommand::BreakpointsCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::DisableCommand::DisplayCommand + include ::Byebug::Helpers::ToggleHelper + include ::Byebug::Helpers::ParseHelper + def execute(); end +end + +class Byebug::DisableCommand::DisplayCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::DisableCommand + extend ::Byebug::Subcommands::ClassMethods + extend ::Byebug::Helpers::ReflectionHelper + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::DisplayCommand + include ::Byebug::Helpers::EvalHelper + def execute(); end +end + +class Byebug::DisplayCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::DownCommand + include ::Byebug::Helpers::FrameHelper + include ::Byebug::Helpers::ParseHelper + def execute(); end +end + +class Byebug::DownCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::EditCommand + def execute(); end +end + +class Byebug::EditCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::EnableCommand + include ::Byebug::Subcommands +end + +class Byebug::EnableCommand::BreakpointsCommand + include ::Byebug::Helpers::ToggleHelper + include ::Byebug::Helpers::ParseHelper + def execute(); end +end + +class Byebug::EnableCommand::BreakpointsCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::EnableCommand::DisplayCommand + include ::Byebug::Helpers::ToggleHelper + include ::Byebug::Helpers::ParseHelper + def execute(); end +end + +class Byebug::EnableCommand::DisplayCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::EnableCommand + extend ::Byebug::Subcommands::ClassMethods + extend ::Byebug::Helpers::ReflectionHelper + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::FinishCommand + include ::Byebug::Helpers::ParseHelper + def execute(); end +end + +class Byebug::FinishCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::Frame + include ::Byebug::Helpers::FileHelper + def _binding(); end + + def _class(); end + + def _method(); end + + def _self(); end + + def args(); end + + def c_frame?(); end + + def current?(); end + + def deco_args(); end + + def deco_block(); end + + def deco_call(); end + + def deco_class(); end + + def deco_file(); end + + def deco_method(); end + + def deco_pos(); end + + def file(); end + + def initialize(context, pos); end + + def line(); end + + def locals(); end + + def mark(); end + + def pos(); end + + def to_hash(); end +end + +class Byebug::Frame +end + +class Byebug::FrameCommand + include ::Byebug::Helpers::FrameHelper + include ::Byebug::Helpers::ParseHelper + def execute(); end +end + +class Byebug::FrameCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::FullpathSetting + def banner(); end + DEFAULT = ::T.let(nil, ::T.untyped) +end + +class Byebug::FullpathSetting +end + +class Byebug::HelpCommand + def execute(); end +end + +class Byebug::HelpCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +module Byebug::Helpers +end + +module Byebug::Helpers::BinHelper + def executable_file_extensions(); end + + def find_executable(path, cmd); end + + def real_executable?(file); end + + def search_paths(); end + + def which(cmd); end +end + +module Byebug::Helpers::BinHelper +end + +module Byebug::Helpers::EvalHelper + def error_eval(str, binding=T.unsafe(nil)); end + + def multiple_thread_eval(expression); end + + def separate_thread_eval(expression); end + + def silent_eval(str, binding=T.unsafe(nil)); end + + def warning_eval(str, binding=T.unsafe(nil)); end +end + +module Byebug::Helpers::EvalHelper +end + +module Byebug::Helpers::FileHelper + def get_line(filename, lineno); end + + def get_lines(filename); end + + def n_lines(filename); end + + def normalize(filename); end + + def shortpath(fullpath); end + + def virtual_file?(name); end +end + +module Byebug::Helpers::FileHelper +end + +module Byebug::Helpers::FrameHelper + def jump_frames(steps); end + + def switch_to_frame(frame); end +end + +module Byebug::Helpers::FrameHelper +end + +module Byebug::Helpers::ParseHelper + def get_int(str, cmd, min=T.unsafe(nil), max=T.unsafe(nil)); end + + def parse_steps(str, cmd); end + + def syntax_valid?(code); end +end + +module Byebug::Helpers::ParseHelper +end + +module Byebug::Helpers::PathHelper + def all_files(); end + + def bin_file(); end + + def gem_files(); end + + def lib_files(); end + + def root_path(); end + + def test_files(); end +end + +module Byebug::Helpers::PathHelper +end + +module Byebug::Helpers::ReflectionHelper + def commands(); end +end + +module Byebug::Helpers::ReflectionHelper +end + +module Byebug::Helpers::StringHelper + def camelize(str); end + + def deindent(str, leading_spaces: T.unsafe(nil)); end + + def prettify(str); end +end + +module Byebug::Helpers::StringHelper +end + +module Byebug::Helpers::ThreadHelper + def context_from_thread(thnum); end + + def current_thread?(ctx); end + + def display_context(ctx); end + + def thread_arguments(ctx); end +end + +module Byebug::Helpers::ThreadHelper +end + +module Byebug::Helpers::ToggleHelper + include ::Byebug::Helpers::ParseHelper + def enable_disable_breakpoints(is_enable, args); end + + def enable_disable_display(is_enable, args); end +end + +module Byebug::Helpers::ToggleHelper +end + +module Byebug::Helpers::VarHelper + include ::Byebug::Helpers::EvalHelper + def var_args(); end + + def var_global(); end + + def var_instance(str); end + + def var_list(ary, binding=T.unsafe(nil)); end + + def var_local(); end +end + +module Byebug::Helpers::VarHelper +end + +module Byebug::Helpers +end + +class Byebug::HistfileSetting + def banner(); end + DEFAULT = ::T.let(nil, ::T.untyped) +end + +class Byebug::HistfileSetting +end + +class Byebug::History + def buffer(); end + + def clear(); end + + def default_max_size(); end + + def ignore?(buf); end + + def last_ids(number); end + + def pop(); end + + def push(cmd); end + + def restore(); end + + def save(); end + + def size(); end + + def size=(size); end + + def specific_max_size(number); end + + def to_s(n_cmds); end +end + +class Byebug::History +end + +class Byebug::HistoryCommand + include ::Byebug::Helpers::ParseHelper + def execute(); end +end + +class Byebug::HistoryCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::HistsizeSetting + def banner(); end + DEFAULT = ::T.let(nil, ::T.untyped) +end + +class Byebug::HistsizeSetting +end + +class Byebug::InfoCommand + include ::Byebug::Subcommands +end + +class Byebug::InfoCommand::BreakpointsCommand + def execute(); end +end + +class Byebug::InfoCommand::BreakpointsCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::InfoCommand::DisplayCommand + def execute(); end +end + +class Byebug::InfoCommand::DisplayCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::InfoCommand::FileCommand + include ::Byebug::Helpers::FileHelper + include ::Byebug::Helpers::StringHelper + def execute(); end +end + +class Byebug::InfoCommand::FileCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::InfoCommand::LineCommand + def execute(); end +end + +class Byebug::InfoCommand::LineCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::InfoCommand::ProgramCommand + def execute(); end +end + +class Byebug::InfoCommand::ProgramCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::InfoCommand + extend ::Byebug::Subcommands::ClassMethods + extend ::Byebug::Helpers::ReflectionHelper + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::Interface + include ::Byebug::Helpers::FileHelper + def autorestore(); end + + def autosave(); end + + def close(); end + + def command_queue(); end + + def command_queue=(command_queue); end + + def confirm(prompt); end + + def errmsg(message); end + + def error(); end + + def history(); end + + def history=(history); end + + def input(); end + + def last_if_empty(input); end + + def output(); end + + def prepare_input(prompt); end + + def print(message); end + + def puts(message); end + + def read_command(prompt); end + + def read_file(filename); end + + def read_input(prompt, save_hist=T.unsafe(nil)); end +end + +class Byebug::Interface +end + +class Byebug::InterruptCommand + def execute(); end +end + +class Byebug::InterruptCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::IrbCommand + def execute(); end +end + +class Byebug::IrbCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::KillCommand + def execute(); end +end + +class Byebug::KillCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::LinetraceSetting + def banner(); end + + def value=(val); end +end + +class Byebug::LinetraceSetting +end + +class Byebug::ListCommand + include ::Byebug::Helpers::FileHelper + include ::Byebug::Helpers::ParseHelper + def amend_final(*args, &block); end + + def execute(); end + + def max_line(*args, &block); end + + def size(*args, &block); end +end + +class Byebug::ListCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::ListsizeSetting + def banner(); end + DEFAULT = ::T.let(nil, ::T.untyped) +end + +class Byebug::ListsizeSetting +end + +class Byebug::LocalInterface + def readline(prompt); end + + def with_repl_like_sigint(); end + + def without_readline_completion(); end + EOF_ALIAS = ::T.let(nil, ::T.untyped) +end + +class Byebug::LocalInterface +end + +class Byebug::MethodCommand + include ::Byebug::Helpers::EvalHelper + def execute(); end +end + +class Byebug::MethodCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::NextCommand + include ::Byebug::Helpers::ParseHelper + def execute(); end +end + +class Byebug::NextCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::PostMortemProcessor + def commands(); end +end + +class Byebug::PostMortemProcessor +end + +class Byebug::PostMortemSetting + def banner(); end + + def value=(val); end +end + +class Byebug::PostMortemSetting +end + +module Byebug::Printers +end + +class Byebug::Printers::Base + def type(); end + SEPARATOR = ::T.let(nil, ::T.untyped) +end + +class Byebug::Printers::Base::MissedArgument +end + +class Byebug::Printers::Base::MissedArgument +end + +class Byebug::Printers::Base::MissedPath +end + +class Byebug::Printers::Base::MissedPath +end + +class Byebug::Printers::Base +end + +class Byebug::Printers::Plain + def print(path, args=T.unsafe(nil)); end + + def print_collection(path, collection, &block); end + + def print_variables(variables, *_unused); end +end + +class Byebug::Printers::Plain +end + +module Byebug::Printers +end + +class Byebug::PryCommand + def execute(); end +end + +class Byebug::PryCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::QuitCommand + def execute(); end +end + +class Byebug::QuitCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +module Byebug::Remote +end + +class Byebug::Remote::Client + def initialize(interface); end + + def interface(); end + + def socket(); end + + def start(host=T.unsafe(nil), port=T.unsafe(nil)); end + + def started?(); end +end + +class Byebug::Remote::Client +end + +class Byebug::Remote::Server + def actual_port(); end + + def initialize(wait_connection:, &block); end + + def start(host, port); end + + def wait_connection(); end +end + +class Byebug::Remote::Server +end + +module Byebug::Remote +end + +class Byebug::RemoteInterface + def initialize(socket); end + + def readline(prompt); end +end + +class Byebug::RemoteInterface +end + +class Byebug::RestartCommand + include ::Byebug::Helpers::BinHelper + include ::Byebug::Helpers::PathHelper + def execute(); end +end + +class Byebug::RestartCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::SaveCommand + def execute(); end +end + +class Byebug::SaveCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::SavefileSetting + def banner(); end + DEFAULT = ::T.let(nil, ::T.untyped) +end + +class Byebug::SavefileSetting +end + +class Byebug::ScriptInterface + def initialize(file, verbose=T.unsafe(nil)); end +end + +class Byebug::ScriptInterface +end + +class Byebug::ScriptProcessor + def commands(); end +end + +class Byebug::ScriptProcessor +end + +class Byebug::SetCommand + include ::Byebug::Helpers::ParseHelper + def execute(); end +end + +class Byebug::SetCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::Setting + def boolean?(); end + + def help(); end + + def integer?(); end + + def to_sym(); end + + def value(); end + + def value=(value); end + DEFAULT = ::T.let(nil, ::T.untyped) +end + +class Byebug::Setting + def self.[](name); end + + def self.[]=(name, value); end + + def self.find(shortcut); end + + def self.help_all(); end + + def self.settings(); end +end + +class Byebug::ShowCommand + def execute(); end +end + +class Byebug::ShowCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::SkipCommand + include ::Byebug::Helpers::ParseHelper + def auto_run(); end + + def execute(); end + + def initialize_attributes(); end + + def keep_execution(); end + + def reset_attributes(); end +end + +class Byebug::SkipCommand + def self.description(); end + + def self.file_line(); end + + def self.file_line=(file_line); end + + def self.file_path(); end + + def self.file_path=(file_path); end + + def self.previous_autolist(); end + + def self.regexp(); end + + def self.restore_autolist(); end + + def self.setup_autolist(value); end + + def self.short_description(); end +end + +class Byebug::SourceCommand + def execute(); end +end + +class Byebug::SourceCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::SourceFileFormatter + include ::Byebug::Helpers::FileHelper + def amend(line, ceiling); end + + def amend_final(line); end + + def amend_initial(line); end + + def annotator(); end + + def file(); end + + def initialize(file, annotator); end + + def lines(min, max); end + + def lines_around(center); end + + def max_initial_line(); end + + def max_line(); end + + def range_around(center); end + + def range_from(min); end + + def size(); end +end + +class Byebug::SourceFileFormatter +end + +class Byebug::StackOnErrorSetting + def banner(); end +end + +class Byebug::StackOnErrorSetting +end + +class Byebug::StepCommand + include ::Byebug::Helpers::ParseHelper + def execute(); end +end + +class Byebug::StepCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +module Byebug::Subcommands + def execute(); end + + def subcommand_list(*args, &block); end +end + +module Byebug::Subcommands::ClassMethods + include ::Byebug::Helpers::ReflectionHelper + def help(); end + + def subcommand_list(); end +end + +module Byebug::Subcommands::ClassMethods +end + +module Byebug::Subcommands + extend ::Forwardable + def self.included(command); end +end + +class Byebug::ThreadCommand + include ::Byebug::Subcommands +end + +class Byebug::ThreadCommand::CurrentCommand + include ::Byebug::Helpers::ThreadHelper + def execute(); end +end + +class Byebug::ThreadCommand::CurrentCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::ThreadCommand::ListCommand + include ::Byebug::Helpers::ThreadHelper + def execute(); end +end + +class Byebug::ThreadCommand::ListCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::ThreadCommand::ResumeCommand + include ::Byebug::Helpers::ThreadHelper + def execute(); end +end + +class Byebug::ThreadCommand::ResumeCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::ThreadCommand::StopCommand + include ::Byebug::Helpers::ThreadHelper + def execute(); end +end + +class Byebug::ThreadCommand::StopCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::ThreadCommand::SwitchCommand + include ::Byebug::Helpers::ThreadHelper + def execute(); end +end + +class Byebug::ThreadCommand::SwitchCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::ThreadCommand + extend ::Byebug::Subcommands::ClassMethods + extend ::Byebug::Helpers::ReflectionHelper + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::ThreadsTable +end + +class Byebug::ThreadsTable +end + +class Byebug::TracevarCommand + def execute(); end +end + +class Byebug::TracevarCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::UndisplayCommand + include ::Byebug::Helpers::ParseHelper + def execute(); end +end + +class Byebug::UndisplayCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::UntracevarCommand + def execute(); end +end + +class Byebug::UntracevarCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::UpCommand + include ::Byebug::Helpers::FrameHelper + include ::Byebug::Helpers::ParseHelper + def execute(); end +end + +class Byebug::UpCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::VarCommand + include ::Byebug::Subcommands +end + +class Byebug::VarCommand::AllCommand + include ::Byebug::Helpers::VarHelper + include ::Byebug::Helpers::EvalHelper + def execute(); end +end + +class Byebug::VarCommand::AllCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::VarCommand::ArgsCommand + include ::Byebug::Helpers::VarHelper + include ::Byebug::Helpers::EvalHelper + def execute(); end +end + +class Byebug::VarCommand::ArgsCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::VarCommand::ConstCommand + include ::Byebug::Helpers::EvalHelper + def execute(); end +end + +class Byebug::VarCommand::ConstCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::VarCommand::GlobalCommand + include ::Byebug::Helpers::VarHelper + include ::Byebug::Helpers::EvalHelper + def execute(); end +end + +class Byebug::VarCommand::GlobalCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::VarCommand::InstanceCommand + include ::Byebug::Helpers::VarHelper + include ::Byebug::Helpers::EvalHelper + def execute(); end +end + +class Byebug::VarCommand::InstanceCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::VarCommand::LocalCommand + include ::Byebug::Helpers::VarHelper + include ::Byebug::Helpers::EvalHelper + def execute(); end +end + +class Byebug::VarCommand::LocalCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::VarCommand + extend ::Byebug::Subcommands::ClassMethods + extend ::Byebug::Helpers::ReflectionHelper + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::WhereCommand + include ::Byebug::Helpers::FrameHelper + def execute(); end +end + +class Byebug::WhereCommand + def self.description(); end + + def self.regexp(); end + + def self.short_description(); end +end + +class Byebug::WidthSetting + def banner(); end + DEFAULT = ::T.let(nil, ::T.untyped) +end + +class Byebug::WidthSetting +end + +module Byebug + extend ::Byebug + extend ::Byebug::Helpers::ReflectionHelper + def self.actual_control_port(); end + + def self.actual_port(); end + + def self.attach(); end + + def self.handle_post_mortem(); end + + def self.interrupt(); end + + def self.load_settings(); end + + def self.parse_host_and_port(host_port_spec); end + + def self.spawn(host=T.unsafe(nil), port=T.unsafe(nil)); end + + def self.start_client(host=T.unsafe(nil), port=T.unsafe(nil)); end + + def self.start_control(host=T.unsafe(nil), port=T.unsafe(nil)); end + + def self.start_server(host=T.unsafe(nil), port=T.unsafe(nil)); end + + def self.wait_connection(); end + + def self.wait_connection=(wait_connection); end +end + +module CGI::HtmlExtension + def a(href=T.unsafe(nil)); end + + def base(href=T.unsafe(nil)); end + + def blockquote(cite=T.unsafe(nil)); end + + def caption(align=T.unsafe(nil)); end + + def checkbox(name=T.unsafe(nil), value=T.unsafe(nil), checked=T.unsafe(nil)); end + + def checkbox_group(name=T.unsafe(nil), *values); end + + def file_field(name=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end + + def form(method=T.unsafe(nil), action=T.unsafe(nil), enctype=T.unsafe(nil)); end + + def hidden(name=T.unsafe(nil), value=T.unsafe(nil)); end + + def html(attributes=T.unsafe(nil)); end + + def image_button(src=T.unsafe(nil), name=T.unsafe(nil), alt=T.unsafe(nil)); end + + def img(src=T.unsafe(nil), alt=T.unsafe(nil), width=T.unsafe(nil), height=T.unsafe(nil)); end + + def multipart_form(action=T.unsafe(nil), enctype=T.unsafe(nil)); end + + def password_field(name=T.unsafe(nil), value=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end + + def popup_menu(name=T.unsafe(nil), *values); end + + def radio_button(name=T.unsafe(nil), value=T.unsafe(nil), checked=T.unsafe(nil)); end + + def radio_group(name=T.unsafe(nil), *values); end + + def reset(value=T.unsafe(nil), name=T.unsafe(nil)); end + + def scrolling_list(name=T.unsafe(nil), *values); end + + def submit(value=T.unsafe(nil), name=T.unsafe(nil)); end + + def text_field(name=T.unsafe(nil), value=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end + + def textarea(name=T.unsafe(nil), cols=T.unsafe(nil), rows=T.unsafe(nil)); end +end + +module CGI::HtmlExtension +end + +class Class + def any_instance(); end + + def json_creatable?(); end +end + +class DRb::DRbArray + def _dump(lv); end +end + +class DRb::DRbArray + def self._load(s); end +end + +class DRb::DRbConn + def alive?(); end + + def close(); end + + def initialize(remote_uri); end + + def send_message(ref, msg_id, arg, block); end + + def uri(); end +end + +class DRb::DRbConn + def self.open(remote_uri); end +end + +class DRb::DRbMessage + def dump(obj, error=T.unsafe(nil)); end + + def initialize(config); end + + def load(soc); end + + def recv_reply(stream); end + + def recv_request(stream); end + + def send_reply(stream, succ, result); end + + def send_request(stream, ref, msg_id, arg, b); end +end + +class DRb::DRbObject + def ==(other); end + + def eql?(other); end + + def initialize(obj, uri=T.unsafe(nil)); end +end + +class DRb::DRbObject + def self.prepare_backtrace(uri, result); end + + def self.with_friend(uri); end +end + +module DRb::DRbProtocol + def self.auto_load(uri); end +end + +class DRb::DRbRemoteError + def initialize(error); end +end + +class DRb::DRbServer + def initialize(uri=T.unsafe(nil), front=T.unsafe(nil), config_or_acl=T.unsafe(nil)); end + + def safe_level(); end +end + +class DRb::DRbServer::InvokeMethod + include ::DRb::DRbServer::InvokeMethod18Mixin + def initialize(drb_server, client); end + + def perform(); end +end + +class DRb::DRbServer::InvokeMethod +end + +module DRb::DRbServer::InvokeMethod18Mixin + def block_yield(x); end + + def perform_with_block(); end +end + +module DRb::DRbServer::InvokeMethod18Mixin +end + +class DRb::DRbServer + def self.default_safe_level(level); end + + def self.make_config(hash=T.unsafe(nil)); end +end + +class DRb::DRbTCPSocket + def accept(); end + + def alive?(); end + + def close(); end + + def initialize(uri, soc, config=T.unsafe(nil)); end + + def peeraddr(); end + + def recv_reply(); end + + def recv_request(); end + + def send_reply(succ, result); end + + def send_request(ref, msg_id, arg, b); end + + def set_sockopt(soc); end + + def shutdown(); end + + def stream(); end + + def uri(); end +end + +class DRb::DRbTCPSocket + def self.getservername(); end + + def self.open(uri, config); end + + def self.open_server(uri, config); end + + def self.open_server_inaddr_any(host, port); end + + def self.parse_uri(uri); end + + def self.uri_option(uri, config); end +end + +class DRb::DRbURIOption + def ==(other); end + + def eql?(other); end + + def initialize(option); end + + def option(); end +end + +class DRb::DRbURIOption +end + +module DRb::DRbUndumped + def _dump(dummy); end +end + +class DRb::DRbUnknown + def _dump(lv); end +end + +class DRb::DRbUnknown + def self._load(s); end +end + +class DRb::DRbUnknownError + def _dump(lv); end + + def initialize(unknown); end +end + +class DRb::DRbUnknownError + def self._load(s); end +end + +module DRb + def self.mutex(); end +end + +DRbIdConv = DRb::DRbIdConv + +DRbObject = DRb::DRbObject + +DRbUndumped = DRb::DRbUndumped + +class Date::Infinity + def initialize(d=T.unsafe(nil)); end +end + +class DidYouMean::ClassNameChecker + def class_name(); end + + def class_names(); end + + def corrections(); end + + def initialize(exception); end + + def scopes(); end +end + +module DidYouMean::Correctable + def corrections(); end + + def original_message(); end + + def spell_checker(); end + + def to_s(); end +end + +module DidYouMean::Jaro + def self.distance(str1, str2); end +end + +module DidYouMean::JaroWinkler + def self.distance(str1, str2); end +end + +class DidYouMean::KeyErrorChecker + def corrections(); end + + def initialize(key_error); end +end + +class DidYouMean::KeyErrorChecker +end + +module DidYouMean::Levenshtein + def self.distance(str1, str2); end + + def self.min3(a, b, c); end +end + +class DidYouMean::MethodNameChecker + def corrections(); end + + def initialize(exception); end + + def method_name(); end + + def method_names(); end + + def receiver(); end + RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped) +end + +class DidYouMean::NullChecker + def corrections(); end + + def initialize(*_); end +end + +class DidYouMean::PlainFormatter + def message_for(corrections); end +end + +class DidYouMean::PlainFormatter +end + +class DidYouMean::VariableNameChecker + def corrections(); end + + def cvar_names(); end + + def initialize(exception); end + + def ivar_names(); end + + def lvar_names(); end + + def method_names(); end + + def name(); end + RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped) +end + +module DidYouMean + def self.formatter(); end + + def self.formatter=(formatter); end +end + +module Diff::LCS + def self.LCS(seq1, seq2, &block); end + + def self.diff(seq1, seq2, callbacks=T.unsafe(nil), &block); end + + def self.lcs(seq1, seq2, &block); end + + def self.patch(src, patchset, direction=T.unsafe(nil)); end + + def self.patch!(src, patchset); end + + def self.sdiff(seq1, seq2, callbacks=T.unsafe(nil), &block); end + + def self.traverse_balanced(seq1, seq2, callbacks=T.unsafe(nil)); end + + def self.traverse_sequences(seq1, seq2, callbacks=T.unsafe(nil)); end + + def self.unpatch!(src, patchset); end +end + +class Dir + def children(); end + + def each_child(); end +end + +class Dir + def self.exists?(_); end + +end + +module Docile + VERSION = ::T.let(nil, ::T.untyped) +end + +class Docile::ChainingFallbackContextProxy +end + +class Docile::ChainingFallbackContextProxy +end + +module Docile::Execution +end + +module Docile::Execution + def self.exec_in_proxy_context(dsl, proxy_type, *args, &block); end +end + +class Docile::FallbackContextProxy + def initialize(receiver, fallback); end + + def method_missing(method, *args, &block); end + NON_FALLBACK_METHODS = ::T.let(nil, ::T.untyped) + NON_PROXIED_INSTANCE_VARIABLES = ::T.let(nil, ::T.untyped) + NON_PROXIED_METHODS = ::T.let(nil, ::T.untyped) +end + +class Docile::FallbackContextProxy +end + +module Docile + extend ::Docile::Execution + def self.dsl_eval(dsl, *args, &block); end + + def self.dsl_eval_immutable(dsl, *args, &block); end + + def self.dsl_eval_with_block_return(dsl, *args, &block); end +end + +class ERB + def def_method(mod, methodname, fname=T.unsafe(nil)); end + + def def_module(methodname=T.unsafe(nil)); end + +end + +class ERB::Compiler::Scanner + DEFAULT_ETAGS = ::T.let(nil, ::T.untyped) + DEFAULT_STAGS = ::T.let(nil, ::T.untyped) +end + +class Encoding + def _dump(*_); end +end + +class Encoding::Converter + def initialize(*_); end +end + +class Encoding + def self._load(_); end +end + +module Enumerable + def chain(*_); end + + 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 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 + +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 __bb_context(); end +end + +module Exception2MessageMapper + def bind(cl); end + +end + +Exception2MessageMapper::E2MM = Exception2MessageMapper + +class Exception2MessageMapper::ErrNotRegisteredException +end + +class Exception2MessageMapper::ErrNotRegisteredException +end + +module Exception2MessageMapper + def self.Fail(klass=T.unsafe(nil), err=T.unsafe(nil), *rest); end + + def self.Raise(klass=T.unsafe(nil), err=T.unsafe(nil), *rest); end + + def self.def_e2message(k, c, m); end + + def self.def_exception(k, n, m, s=T.unsafe(nil)); end + + def self.e2mm_message(klass, exp); end + + def self.extend_object(cl); end + + def self.message(klass, exp); end +end + +class ExitCalledError +end + +class ExitCalledError +end + +class FalseClass + include ::JSON::Ext::Generator::GeneratorMethods::FalseClass +end + +class File + def self.exists?(_); end + + def self.read_utf(path); end +end + +FileList = Rake::FileList + +module FileUtils + include ::FileUtils::StreamUtils_ + def ruby(*args, **options, &block); end + + def safe_ln(*args, **options); end + + def sh(*cmd, &block); end + + def split_all(path); end + LN_SUPPORTED = ::T.let(nil, ::T.untyped) + RUBY = ::T.let(nil, ::T.untyped) +end + +module FileUtils::DryRun + include ::FileUtils + include ::FileUtils::StreamUtils_ + include ::FileUtils::LowMethods +end + +module FileUtils::DryRun + extend ::FileUtils::DryRun + extend ::FileUtils + extend ::FileUtils::StreamUtils_ + extend ::FileUtils::LowMethods +end + +module FileUtils::NoWrite + include ::FileUtils + include ::FileUtils::StreamUtils_ + include ::FileUtils::LowMethods +end + +module FileUtils::NoWrite + extend ::FileUtils::NoWrite + extend ::FileUtils + extend ::FileUtils::StreamUtils_ + extend ::FileUtils::LowMethods +end + +module FileUtils::Verbose + include ::FileUtils + include ::FileUtils::StreamUtils_ +end + +module FileUtils::Verbose + extend ::FileUtils::Verbose + extend ::FileUtils + extend ::FileUtils::StreamUtils_ +end + +module FileUtils + extend ::FileUtils::StreamUtils_ +end + +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 + +module GC + def garbage_collect(*_); 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) + RubyGemsPackageVersion = ::T.let(nil, ::T.untyped) + RubyGemsVersion = ::T.let(nil, ::T.untyped) + USE_BUNDLER_FOR_GEMDEPS = ::T.let(nil, ::T.untyped) +end + +class Gem::DependencyInstaller + def _deprecated_add_found_dependencies(to_do, dependency_list); end + + def _deprecated_gather_dependencies(); end + + def add_found_dependencies(*args, &block); end + + def gather_dependencies(*args, &block); end +end + +class Gem::Exception + extend ::Gem::Deprecate +end + +class Gem::Ext::BuildError +end + +class Gem::Ext::BuildError +end + +class Gem::Ext::Builder + def self.redirector(); end +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 + +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.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 +end + +class Gem::PathSupport + def home(); end + + def initialize(env); end + + def path(); end + + def spec_cache_dir(); end +end + +class Gem::RemoteFetcher + def correct_for_windows_path(path); end + + def s3_expiration(); end + + def sign_s3_url(uri, expiration=T.unsafe(nil)); end + BASE64_URI_TRANSLATE = ::T.let(nil, ::T.untyped) +end + +class Gem::RemoteFetcher::FetchError + 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::Resolver::ActivationRequest + def others_possible?(); end +end + +class Gem::Resolver::CurrentSet +end + +class Gem::Resolver::CurrentSet +end + +Gem::Resolver::DependencyConflict = Gem::Resolver::Conflict + +class Gem::Resolver::LocalSpecification +end + +class Gem::Resolver::LocalSpecification +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::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::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 to_ruby(); end +end + +class Gem::Specification + extend ::Gem::Deprecate + extend ::Enumerable + def self.add_spec(spec); end + + def self.add_specs(*specs); end + + def self.remove_spec(spec); end +end + +class Gem::SpecificationPolicy + 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 + +Gem::Version::Requirement = Gem::Requirement + +module Gem + def self.bin_wrapper(name); end + + def self.default_gems_use_full_paths?(); end + + def self.remove_unresolved_default_spec(spec); end +end + +class Hash + include ::JSON::Ext::Generator::GeneratorMethods::Hash +end + +class Hash + def self.try_convert(_); end +end + +class Hoe + include ::Rake::DSL + include ::Rake::FileUtilsExt + include ::FileUtils + include ::FileUtils::StreamUtils_ + def activate_plugin_deps(); end + + def activate_plugins(); end + + def add_dependencies(); end + + def author(); end + + def author=(author); end + + def changes(); end + + def changes=(changes); end + + def check_for_version(); end + + def define_spec(); end + + def dependency(name, version, type=T.unsafe(nil)); end + + def dependency_target(); end + + def description(); end + + def description=(description); end + + def description_sections(); end + + def description_sections=(description_sections); end + + def developer(name, email); end + + def email(); end + + def email=(email); end + + def extra_deps(); end + + def extra_deps=(extra_deps); end + + def extra_dev_deps(); end + + def extra_dev_deps=(extra_dev_deps); end + + def extra_rdoc_files(); end + + def extra_rdoc_files=(extra_rdoc_files); end + + def group_name(); end + + def group_name=(group_name); end + + def have_gem?(name); end + + def history_file(); end + + def history_file=(history_file); end + + def initialize(name, version=T.unsafe(nil)); end + + def initialize_plugins(); end + + def intuit_values(input); end + + def license(name); end + + def licenses(); end + + def licenses=(licenses); end + + def load_plugin_tasks(); end + + def missing(name); end + + def name(); end + + def name=(name); end + + def normalize_deps(deps); end + + def paragraphs_of(path, *paragraphs); end + + def parse_urls(text); end + + def pluggable!(); end + + def plugin?(name); end + + def post_initialize(); end + + def post_install_message(); end + + def post_install_message=(post_install_message); end + + def read_manifest(); end + + def readme_file(); end + + def readme_file=(readme_file); end + + def require_ruby_version(*versions); end + + def require_rubygems_version(*versions); end + + def ruby18!(); end + + def ruby19!(); end + + def ruby20!(); end + + def ruby21!(); end + + def ruby22!(); end + + def ruby23!(); end + + def run_spec_extras(); end + + def spec(); end + + def spec=(spec); end + + def spec_extras(); end + + def spec_extras=(spec_extras); end + + def summary(); end + + def summary=(summary); end + + def summary_sentences(); end + + def summary_sentences=(summary_sentences); end + + def test_globs(); end + + def test_globs=(test_globs); end + + def timebomb(n, m, finis=T.unsafe(nil), start=T.unsafe(nil)); end + + def urls(); end + + def urls=(urls); end + + def validate_fields(); end + + def version(); end + + def version=(version); end + + def with_config(); end + DEFAULT_CONFIG = ::T.let(nil, ::T.untyped) + RUBY_DEBUG = ::T.let(nil, ::T.untyped) + RUBY_FLAGS = ::T.let(nil, ::T.untyped) + URLS_TO_META_MAP = ::T.let(nil, ::T.untyped) + VERSION = ::T.let(nil, ::T.untyped) + WINDOZE = ::T.let(nil, ::T.untyped) +end + +class Hoe + def self.add_include_dirs(*dirs); end + + def self.bad_plugins(); end + + def self.include_dirs(); end + + def self.include_dirs=(include_dirs); end + + def self.load_plugins(plugins=T.unsafe(nil)); end + + def self.normalize_names(project); end + + def self.plugin(*plugins); end + + def self.plugins(); end + + def self.spec(name, &block); end +end + +class IO + def beep(); end + + def cooked(); end + + def cooked!(); end + + def cursor(); end + + def cursor=(); end + + def echo=(echo); end + + def echo?(); end + + def getch(*_); end + + def getpass(*_); end + + def goto(); end + + def iflush(); end + + def ioflush(); end + + def noecho(); end + + def nonblock(*_); end + + def nonblock=(nonblock); end + + def nonblock?(); end + + def nread(); end + + def oflush(); end + + def pathconf(_); end + + def pressed?(); end + + def raw(*_); end + + def raw!(*_); end + + def ready?(); end + + def wait(*_); end + + def wait_readable(*_); end + + def wait_writable(*_); end + + def winsize(); end + + def winsize=(winsize); end +end + +IO::EWOULDBLOCKWaitReadable = IO::EAGAINWaitReadable + +IO::EWOULDBLOCKWaitWritable = IO::EAGAINWaitWritable + +class IO + def self.console(*_); end + + def self.console_size(); end + + def self.default_console_size(); end +end + +class IPAddr + def ==(other); end + + def initialize(addr=T.unsafe(nil), family=T.unsafe(nil)); end +end + +module IRB + IRBRC_EXT = ::T.let(nil, ::T.untyped) + MagicFile = ::T.let(nil, ::T.untyped) + STDIN_FILE_NAME = ::T.let(nil, ::T.untyped) + VERSION = ::T.let(nil, ::T.untyped) +end + +class IRB::Context + def __exit__(*_); end + + def __inspect__(); end + + def __to_s__(); end + + def evaluate(line, line_no, exception: T.unsafe(nil)); end + + def initialize(irb, workspace=T.unsafe(nil), input_method=T.unsafe(nil), output_method=T.unsafe(nil)); end + + def inspect_last_value(); end + IDNAME_IVARS = ::T.let(nil, ::T.untyped) + NOPRINTING_IVARS = ::T.let(nil, ::T.untyped) + NO_INSPECTING_IVARS = ::T.let(nil, ::T.untyped) +end + +class IRB::DefaultEncodings + def external(); end + + def external=(_); end + + def internal(); end + + def internal=(_); end +end + +class IRB::DefaultEncodings + def self.[](*_); end + + def self.members(); end +end + +module IRB::ExtendCommandBundle + def irb(*opts, &b); end + + def irb_change_workspace(*opts, &b); end + + def irb_current_working_workspace(*opts, &b); end + + def irb_fg(*opts, &b); end + + def irb_help(*opts, &b); end + + def irb_jobs(*opts, &b); end + + def irb_kill(*opts, &b); end + + def irb_pop_workspace(*opts, &b); end + + def irb_push_workspace(*opts, &b); end + + def irb_source(*opts, &b); end + + def irb_workspaces(*opts, &b); end +end + +IRB::ExtendCommandBundle::EXCB = IRB::ExtendCommandBundle + +module IRB::ExtendCommandBundle + def self.irb_original_method_name(method_name); end +end + +class IRB::FileInputMethod + def initialize(file); end +end + +class IRB::InputMethod + def initialize(file=T.unsafe(nil)); end +end + +class IRB::Inspector + def initialize(inspect_proc, init_proc=T.unsafe(nil)); end +end + +class IRB::Irb + def handle_exception(exc); end + + def initialize(workspace=T.unsafe(nil), input_method=T.unsafe(nil), output_method=T.unsafe(nil)); end + + def output_value(); end + + def prompt(prompt, ltype, indent, line_no); end +end + +class IRB::Locale + def String(mes); end + + def encoding(); end + + def find(file, paths=T.unsafe(nil)); end + + def format(*opts); end + + def gets(*rs); end + + def initialize(locale=T.unsafe(nil)); end + + def lang(); end + + def load(file, priv=T.unsafe(nil)); end + + def modifier(); end + + def print(*opts); end + + def printf(*opts); end + + def puts(*opts); end + + def readline(*rs); end + + def require(file, priv=T.unsafe(nil)); end + + def territory(); end + LOCALE_DIR = ::T.let(nil, ::T.untyped) + LOCALE_NAME_RE = ::T.let(nil, ::T.untyped) +end + +class IRB::Locale +end + +class IRB::Notifier::AbstractNotifier + def initialize(prefix, base_notifier); end +end + +class IRB::Notifier::LeveledNotifier + def initialize(base, level, prefix); end +end + +class IRB::Notifier::NoMsgNotifier + def initialize(); end +end + +class IRB::ReadlineInputMethod + def initialize(); end +end + +class IRB::SLex + def Fail(err=T.unsafe(nil), *rest); end + + def Raise(err=T.unsafe(nil), *rest); end + + def create(token, preproc=T.unsafe(nil), postproc=T.unsafe(nil)); end + + def def_rule(token, preproc=T.unsafe(nil), postproc=T.unsafe(nil), &block); end + + def def_rules(*tokens, &block); end + + def match(token); end + + def postproc(token); end + + def preproc(token, proc); end + + def search(token); end + DOUT = ::T.let(nil, ::T.untyped) + D_DEBUG = ::T.let(nil, ::T.untyped) + D_DETAIL = ::T.let(nil, ::T.untyped) + D_WARN = ::T.let(nil, ::T.untyped) +end + +class IRB::SLex::ErrNodeAlreadyExists +end + +class IRB::SLex::ErrNodeAlreadyExists +end + +class IRB::SLex::ErrNodeNothing +end + +class IRB::SLex::ErrNodeNothing +end + +class IRB::SLex::Node + def create_subnode(chrs, preproc=T.unsafe(nil), postproc=T.unsafe(nil)); end + + def initialize(preproc=T.unsafe(nil), postproc=T.unsafe(nil)); end + + def match(chrs, op=T.unsafe(nil)); end + + def match_io(io, op=T.unsafe(nil)); end + + def postproc(); end + + def postproc=(postproc); end + + def preproc(); end + + def preproc=(preproc); end + + def search(chrs, opt=T.unsafe(nil)); end +end + +class IRB::SLex::Node +end + +class IRB::SLex + extend ::Exception2MessageMapper + def self.included(mod); end +end + +class IRB::StdioInputMethod + def initialize(); end +end + +class IRB::WorkSpace + def initialize(*main); end + + def local_variable_get(name); end + + def local_variable_set(name, value); end +end + +module IRB + def self.Inspector(inspect, init=T.unsafe(nil)); end + + def self.delete_caller(); end + + def self.init_config(ap_path); end + + def self.init_error(); end + + def self.load_modules(); end + + def self.parse_opts(argv: T.unsafe(nil)); end + + def self.rc_file(ext=T.unsafe(nil)); end + + def self.rc_file_generators(); end + + def self.run_config(); end + + def self.setup(ap_path, argv: 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 byebug(); end + + def debugger(); end + + def itself(); end + + def object_id(); end + + def pretty_inspect(); end + + def remote_byebug(host=T.unsafe(nil), port=T.unsafe(nil)); end + + def then(); end + + def yield_self(); end +end + +module Kernel + def self.at_exit(); end +end + +class KeyError + include ::DidYouMean::Correctable +end + +class Module + def context(*a, &b); end + + def describe(*a, &b); end + + def example_group(*a, &b); end + + def fcontext(*a, &b); end + + def fdescribe(*a, &b); end + + def rake_extension(method); end + + def shared_context(name, *args, &block); end + + def shared_examples(name, *args, &block); end + + def shared_examples_for(name, *args, &block); end + + def xcontext(*a, &b); end + + def xdescribe(*a, &b); end +end + +class Monitor + def enter(); end + + def exit(); end + + def try_enter(); end +end + +module MonitorMixin + def initialize(*args); end + EXCEPTION_IMMEDIATE = ::T.let(nil, ::T.untyped) + EXCEPTION_NEVER = ::T.let(nil, ::T.untyped) +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 Object + include ::JSON::Ext::Generator::GeneratorMethods::Object + include ::PP::ObjectMixin + def to_yaml(options=T.unsafe(nil)); end + ARGF = ::T.let(nil, ::T.untyped) + ARGV = ::T.let(nil, ::T.untyped) + CROSS_COMPILING = ::T.let(nil, ::T.untyped) + ENV = ::T.let(nil, ::T.untyped) + RUBY_COPYRIGHT = ::T.let(nil, ::T.untyped) + RUBY_DESCRIPTION = ::T.let(nil, ::T.untyped) + RUBY_ENGINE = ::T.let(nil, ::T.untyped) + RUBY_ENGINE_VERSION = ::T.let(nil, ::T.untyped) + RUBY_PATCHLEVEL = ::T.let(nil, ::T.untyped) + RUBY_PLATFORM = ::T.let(nil, ::T.untyped) + RUBY_RELEASE_DATE = ::T.let(nil, ::T.untyped) + RUBY_REVISION = ::T.let(nil, ::T.untyped) + RUBY_VERSION = ::T.let(nil, ::T.untyped) + STDERR = ::T.let(nil, ::T.untyped) + STDIN = ::T.let(nil, ::T.untyped) + STDOUT = ::T.let(nil, ::T.untyped) + TOPLEVEL_BINDING = ::T.let(nil, ::T.untyped) +end + +class Object + def self.yaml_tag(url); end +end + +class Pathname + def fnmatch?(*_); end + + def glob(*_); end + + def make_symlink(_); end +end + +class Proc + def <<(_); end + + def >>(_); end + + def clone(); end +end + +module Psych + VERSION = ::T.let(nil, ::T.untyped) +end + +module Psych + def self.add_builtin_type(type_tag, &block); end + + def self.add_domain_type(domain, type_tag, &block); end + + def self.add_tag(tag, klass); end + + def self.domain_types(); end + + def self.domain_types=(domain_types); end + + def self.dump_tags(); end + + def self.dump_tags=(dump_tags); end + + def self.libyaml_version(); end + + def self.load_tags(); end + + def self.load_tags=(load_tags); end + + def self.remove_type(type_tag); end +end + +class RDoc::Alias + def initialize(text, old_name, new_name, comment, singleton=T.unsafe(nil)); end +end + +class RDoc::Attr + def initialize(text, name, rw, comment, singleton=T.unsafe(nil)); end +end + +class RDoc::ClassModule + def initialize(name, superclass=T.unsafe(nil)); end +end + +class RDoc::CodeObject + def initialize_visibility(); end +end + +class RDoc::Comment + def initialize(text=T.unsafe(nil), location=T.unsafe(nil), language=T.unsafe(nil)); end + + def line(); end + + def line=(line); end +end + +class RDoc::Constant + def initialize(name, value, comment); end + MARSHAL_VERSION = ::T.let(nil, ::T.untyped) +end + +class RDoc::Context + def add_module_by_normal_module(mod); end + + def initialize_methods_etc(); end +end + +class RDoc::Context::Section + def initialize(parent, title, comment); end +end + +class RDoc::CrossReference + def initialize(context); end +end + +class RDoc::ERBIO + def initialize(str, safe_level=T.unsafe(nil), trim_mode=T.unsafe(nil), eoutvar=T.unsafe(nil)); end +end + +module RDoc::Encoding + HEADER_REGEXP = ::T.let(nil, ::T.untyped) +end + +module RDoc::Encoding + def self.detect_encoding(string); end + + def self.remove_magic_comment(string); end +end + +class RDoc::Generator::Darkfish + def initialize(store, options); end +end + +class RDoc::Generator::JsonIndex + def initialize(parent_generator, options); end +end + +class RDoc::Generator::POT + def initialize(store, options); end +end + +class RDoc::Generator::POT::MessageExtractor + def initialize(store); end +end + +class RDoc::Generator::POT::POEntry + def initialize(msgid, options=T.unsafe(nil)); end +end + +class RDoc::Generator::RI + def initialize(store, options); end +end + +class RDoc::I18n::Locale + def initialize(name); end +end + +class RDoc::I18n::Text + def initialize(raw); end +end + +class RDoc::Markdown + def initialize(extensions=T.unsafe(nil), debug=T.unsafe(nil)); end +end + +class RDoc::Markdown::Literals + def initialize(str, debug=T.unsafe(nil)); end +end + +class RDoc::Markdown::Literals::MemoEntry + def initialize(ans, pos); end +end + +class RDoc::Markdown::Literals::RuleInfo + def initialize(name, rendered); end +end + +class RDoc::Markdown::MemoEntry + def initialize(ans, pos); end +end + +class RDoc::Markdown::RuleInfo + def initialize(name, rendered); end +end + +class RDoc::Markup + def add_regexp_handling(pattern, name); end + + def initialize(attribute_manager=T.unsafe(nil)); end +end + +class RDoc::Markup::AttrSpan + def initialize(length); end +end + +class RDoc::Markup::AttributeManager + def add_regexp_handling(pattern, name); end + + def convert_regexp_handlings(str, attrs); end + + def regexp_handlings(); end +end + +class RDoc::Markup::Attributes + def regexp_handling(); end +end + +class RDoc::Markup::Document + def initialize(*parts); end +end + +class RDoc::Markup::Formatter + def add_regexp_handling_RDOCLINK(); end + + def add_regexp_handling_TIDYLINK(); end + + def convert_regexp_handling(target); end + + def initialize(options, markup=T.unsafe(nil)); end +end + +class RDoc::Markup::Include + def initialize(file, include_path); end +end + +class RDoc::Markup::IndentedParagraph + def initialize(indent, *parts); end +end + +class RDoc::Markup::List + def initialize(type=T.unsafe(nil), *items); end +end + +class RDoc::Markup::ListItem + def initialize(label=T.unsafe(nil), *parts); end +end + +class RDoc::Markup::Parser::MyStringScanner + def [](i); end + + def eos?(); end + + def initialize(input); end + + def matched(); end + + def newline!(); end + + def pos(); end + + def scan(re); end + + def unscan(s); end +end + +class RDoc::Markup::Parser::MyStringScanner +end + +class RDoc::Markup::PreProcess + def initialize(input_file_name, include_path); end +end + +class RDoc::Markup::Raw + def initialize(*parts); end +end + +class RDoc::Markup::RegexpHandling + def ==(o); end + + def initialize(type, text); end + + def text(); end + + def text=(text); end + + def type(); end +end + +class RDoc::Markup::RegexpHandling +end + +class RDoc::Markup::ToHtml + def handle_regexp_HARD_BREAK(target); end + + def handle_regexp_HYPERLINK(target); end + + def handle_regexp_RDOCLINK(target); end + + def handle_regexp_TIDYLINK(target); end +end + +class RDoc::Markup::ToHtmlCrossref + def handle_regexp_CROSSREF(target); end + + def initialize(options, from_path, context, markup=T.unsafe(nil)); end + +end + +class RDoc::Markup::ToHtmlSnippet + def handle_regexp_CROSSREF(target); end + + def initialize(options, characters=T.unsafe(nil), paragraphs=T.unsafe(nil), markup=T.unsafe(nil)); end +end + +class RDoc::Markup::ToJoinedParagraph + def initialize(); end +end + +class RDoc::Markup::ToLabel + def handle_regexp_CROSSREF(target); end + + def handle_regexp_HARD_BREAK(*node); end + + def handle_regexp_TIDYLINK(target); end + + def initialize(markup=T.unsafe(nil)); end +end + +class RDoc::Markup::ToMarkdown + def handle_regexp_RDOCLINK(target); end + + def handle_regexp_TIDYLINK(target); end +end + +class RDoc::Markup::ToRdoc + def handle_regexp_HARD_BREAK(target); end + + def handle_regexp_SUPPRESSED_CROSSREF(target); end + + def initialize(markup=T.unsafe(nil)); end +end + +class RDoc::Markup::ToTableOfContents + def initialize(); end +end + +class RDoc::Markup::ToTtOnly + def initialize(markup=T.unsafe(nil)); end +end + +class RDoc::MethodAttr + def initialize(text, name); end +end + +class RDoc::Mixin + def initialize(name, comment); end +end + +class RDoc::Parser + def initialize(top_level, file_name, content, options, stats); end +end + +class RDoc::Parser::C + def do_classes_and_modules(); end +end + +class RDoc::Parser::RipperStateLex + def get_squashed_tk(); end + + def initialize(code); end + EXPR_ARG = ::T.let(nil, ::T.untyped) + EXPR_ARG_ANY = ::T.let(nil, ::T.untyped) + EXPR_BEG = ::T.let(nil, ::T.untyped) + EXPR_BEG_ANY = ::T.let(nil, ::T.untyped) + EXPR_CLASS = ::T.let(nil, ::T.untyped) + EXPR_CMDARG = ::T.let(nil, ::T.untyped) + EXPR_DOT = ::T.let(nil, ::T.untyped) + EXPR_END = ::T.let(nil, ::T.untyped) + EXPR_ENDARG = ::T.let(nil, ::T.untyped) + EXPR_ENDFN = ::T.let(nil, ::T.untyped) + EXPR_END_ANY = ::T.let(nil, ::T.untyped) + EXPR_FITEM = ::T.let(nil, ::T.untyped) + EXPR_FNAME = ::T.let(nil, ::T.untyped) + EXPR_LABEL = ::T.let(nil, ::T.untyped) + EXPR_LABELED = ::T.let(nil, ::T.untyped) + EXPR_MID = ::T.let(nil, ::T.untyped) + EXPR_NONE = ::T.let(nil, ::T.untyped) + EXPR_VALUE = ::T.let(nil, ::T.untyped) + RIPPER_HAS_LEX_STATE = ::T.let(nil, ::T.untyped) +end + +class RDoc::Parser::RipperStateLex::InnerStateLex + def initialize(code); end + + def on_default(event, tok, data); end +end + +class RDoc::Parser::RipperStateLex::InnerStateLex +end + +class RDoc::Parser::RipperStateLex::Token + def char_no(); end + + def char_no=(_); end + + def kind(); end + + def kind=(_); end + + def line_no(); end + + def line_no=(_); end + + def state(); end + + def state=(_); end + + def text(); end + + def text=(_); end +end + +class RDoc::Parser::RipperStateLex::Token + def self.[](*_); end + + def self.members(); end +end + +class RDoc::Parser::RipperStateLex + def self.end?(token); end + + def self.parse(code); end +end + +class RDoc::Parser::Ruby + def get_included_module_with_optional_parens(); end + + def retrieve_comment_body(tk); end +end + +module RDoc::Parser::RubyTools + def skip_tkspace_without_nl(); end +end + +class RDoc::RD::BlockParser + Racc_debug_parser = ::T.let(nil, ::T.untyped) +end + +class RDoc::RD::Inline + def initialize(rdoc, reference); end +end + +class RDoc::RD::InlineParser + def initialize(block_parser); end + Racc_debug_parser = ::T.let(nil, ::T.untyped) +end + +class RDoc::RI::Driver + def initialize(initial_options=T.unsafe(nil)); end + +end + +class RDoc::RI::Driver::NotFoundError + def initialize(klass, suggestions=T.unsafe(nil)); end +end + +RDoc::RI::Store = RDoc::Store + +class RDoc::Require + def initialize(name, comment); end +end + +class RDoc::Servlet + def initialize(server, stores, cache, mount_path=T.unsafe(nil), extra_doc_dirs=T.unsafe(nil)); end +end + +class RDoc::Stats + def initialize(store, num_files, verbosity=T.unsafe(nil)); end +end + +class RDoc::Stats::Quiet + def initialize(num_files); end +end + +class RDoc::Store + def initialize(path=T.unsafe(nil), type=T.unsafe(nil)); end + + def unmatched_constant_alias(); end + + def update_parser_of_file(absolute_name, parser); end +end + +class RDoc::Store::MissingFileError + def initialize(store, file, name); end +end + +class RDoc::Task + def before_running_rdoc(&block); end + + def check_names(names); end + + def clobber_task_description(); end + + def defaults(); end + + def define(); end + + def external(); end + + def external=(external); end + + def generator(); end + + def generator=(generator); end + + def initialize(name=T.unsafe(nil)); end + + def inline_source(); end + + def inline_source=(value); end + + def main(); end + + def main=(main); end + + def markup(); end + + def markup=(markup); end + + def name(); end + + def name=(name); end + + def option_list(); end + + def options(); end + + def options=(options); end + + def rdoc_dir(); end + + def rdoc_dir=(rdoc_dir); end + + def rdoc_files(); end + + def rdoc_files=(rdoc_files); end + + def rdoc_task_description(); end + + def rerdoc_task_description(); end + + def template(); end + + def template=(template); end + + def title(); end + + def title=(title); end +end + +class RDoc::Task +end + +module RDoc::Text + def language(); end + + def language=(language); end +end + +class RDoc::TopLevel + def initialize(absolute_name, relative_name=T.unsafe(nil)); end +end + +module RSpec + MODULES_TO_AUTOLOAD = ::T.let(nil, ::T.untyped) +end + +class RSpec::CallerFilter + ADDITIONAL_TOP_LEVEL_FILES = ::T.let(nil, ::T.untyped) + IGNORE_REGEX = ::T.let(nil, ::T.untyped) + LIB_REGEX = ::T.let(nil, ::T.untyped) + RSPEC_LIBS = ::T.let(nil, ::T.untyped) +end + +class RSpec::CallerFilter + def self.first_non_rspec_line(skip_frames=T.unsafe(nil), increment=T.unsafe(nil)); end +end + +module RSpec::Core +end + +class RSpec::Core::AnonymousExampleGroup +end + +class RSpec::Core::AnonymousExampleGroup +end + +class RSpec::Core::BacktraceFormatter + def backtrace_line(line); end + + def exclude?(line); end + + def exclusion_patterns(); end + + def exclusion_patterns=(exclusion_patterns); end + + def filter_gem(gem_name); end + + def format_backtrace(backtrace, options=T.unsafe(nil)); end + + def full_backtrace=(full_backtrace); end + + def full_backtrace?(); end + + def inclusion_patterns(); end + + def inclusion_patterns=(inclusion_patterns); end +end + +class RSpec::Core::BacktraceFormatter +end + +module RSpec::Core::Bisect +end + +class RSpec::Core::Bisect::BisectFailedError +end + +class RSpec::Core::Bisect::BisectFailedError + def self.for_failed_spec_run(spec_output); end +end + +class RSpec::Core::Bisect::Channel + def close(); end + + def receive(); end + + def send(message); end +end + +class RSpec::Core::Bisect::Channel +end + +class RSpec::Core::Bisect::ExampleSetDescriptor + def all_example_ids(); end + + def all_example_ids=(_); end + + def failed_example_ids(); end + + def failed_example_ids=(_); end +end + +class RSpec::Core::Bisect::ExampleSetDescriptor + def self.[](*_); end + + def self.members(); end +end + +class RSpec::Core::Bisect::Notifier + def initialize(formatter); end + + def publish(event, *args); end +end + +class RSpec::Core::Bisect::Notifier +end + +module RSpec::Core::Bisect +end + +class RSpec::Core::Configuration + include ::RSpec::Core::Hooks + include ::RSpec::Core::Configuration::Readers + def add_formatter(formatter, output=T.unsafe(nil)); end + + def add_setting(name, opts=T.unsafe(nil)); end + + def after(scope=T.unsafe(nil), *meta, &block); end + + def alias_example_group_to(new_name, *args); end + + def alias_example_to(name, *args); end + + def alias_it_behaves_like_to(new_name, report_label=T.unsafe(nil)); end + + def alias_it_should_behave_like_to(new_name, report_label=T.unsafe(nil)); end + + def append_after(scope=T.unsafe(nil), *meta, &block); end + + def append_before(scope=T.unsafe(nil), *meta, &block); end + + def apply_derived_metadata_to(metadata); end + + def around(scope=T.unsafe(nil), *meta, &block); end + + def backtrace_exclusion_patterns(); end + + def backtrace_exclusion_patterns=(patterns); end + + def backtrace_formatter(); end + + def backtrace_inclusion_patterns(); end + + def backtrace_inclusion_patterns=(patterns); end + + def before(scope=T.unsafe(nil), *meta, &block); end + + def bisect_runner(); end + + def bisect_runner=(value); end + + def bisect_runner_class(); end + + def color(); end + + def color=(color); end + + def color_enabled?(output=T.unsafe(nil)); end + + def color_mode(); end + + def color_mode=(color_mode); end + + def configure_example(example, example_hooks); end + + def configure_expectation_framework(); end + + def configure_group(group); end + + def configure_mock_framework(); end + + def default_color=(default_color); end + + def default_color?(); end + + def default_formatter(); end + + def default_formatter=(value); end + + def default_path=(path); end + + def default_path?(); end + + def define_derived_metadata(*filters, &block); end + + def deprecation_stream=(value); end + + def detail_color=(detail_color); end + + def detail_color?(); end + + def disable_monkey_patching(); end + + def disable_monkey_patching!(); end + + def disable_monkey_patching=(disable_monkey_patching); end + + def drb=(drb); end + + def drb?(); end + + def drb_port=(drb_port); end + + def drb_port?(); end + + def dry_run=(dry_run); end + + def dry_run?(); end + + def error_stream=(error_stream); end + + def error_stream?(); end + + def example_status_persistence_file_path=(value); end + + def exclude_pattern=(value); end + + def exclusion_filter(); end + + def exclusion_filter=(filter); end + + def expect_with(*frameworks); end + + def expectation_framework=(framework); end + + def expectation_frameworks(); end + + def expose_current_running_example_as(method_name); end + + def expose_dsl_globally=(value); end + + def expose_dsl_globally?(); end + + def extend(mod, *filters); end + + def fail_fast=(value); end + + def fail_if_no_examples=(fail_if_no_examples); end + + def fail_if_no_examples?(); end + + def failure_color=(failure_color); end + + def failure_color?(); end + + def failure_exit_code=(failure_exit_code); end + + def failure_exit_code?(); end + + def files_or_directories_to_run=(*files); end + + def files_to_run(); end + + def files_to_run=(files_to_run); end + + def filter(); end + + def filter=(filter); end + + def filter_gems_from_backtrace(*gem_names); end + + def filter_manager(); end + + def filter_manager=(filter_manager); end + + def filter_run(*args); end + + def filter_run_excluding(*args); end + + def filter_run_including(*args); end + + def filter_run_when_matching(*args); end + + def fixed_color=(fixed_color); end + + def fixed_color?(); end + + def force(hash); end + + def format_docstrings(&block); end + + def format_docstrings_block(); end + + def formatter=(formatter, output=T.unsafe(nil)); end + + def formatter_loader(); end + + def formatters(); end + + def full_backtrace=(true_or_false); end + + def full_backtrace?(); end + + def full_description(); end + + def full_description=(description); end + + def in_project_source_dir_regex(); end + + def include(mod, *filters); end + + def include_context(shared_group_name, *filters); end + + def inclusion_filter(); end + + def inclusion_filter=(filter); end + + def last_run_statuses(); end + + def libs=(libs); end + + def load_spec_files(); end + + def loaded_spec_files(); end + + def max_displayed_failure_line_count=(max_displayed_failure_line_count); end + + def max_displayed_failure_line_count?(); end + + def mock_framework(); end + + def mock_framework=(framework); end + + def mock_with(framework); end + + def on_example_group_definition(&block); end + + def on_example_group_definition_callbacks(); end + + def only_failures?(); end + + def only_failures_but_not_configured?(); end + + def order=(*args, &block); end + + def ordering_manager(); end + + def ordering_registry(*args, &block); end + + def output_stream=(value); end + + def pattern=(value); end + + def pending_color=(pending_color); end + + def pending_color?(); end + + def prepend(mod, *filters); end + + def prepend_after(scope=T.unsafe(nil), *meta, &block); end + + def prepend_before(scope=T.unsafe(nil), *meta, &block); end + + def profile_examples=(profile_examples); end + + def profile_examples?(); end + + def project_source_dirs=(project_source_dirs); end + + def project_source_dirs?(); end + + def raise_errors_for_deprecations!(); end + + def raise_on_warning=(value); end + + def register_ordering(*args, &block); end + + def reporter(); end + + def requires=(paths); end + + def reset(); end + + def reset_filters(); end + + def reset_reporter(); end + + def run_all_when_everything_filtered=(run_all_when_everything_filtered); end + + def run_all_when_everything_filtered?(); end + + def seed(*args, &block); end + + def seed=(*args, &block); end + + def seed_used?(*args, &block); end + + def shared_context_metadata_behavior=(value); end + + def silence_filter_announcements=(silence_filter_announcements); end + + def silence_filter_announcements?(); end + + def spec_files_with_failures(); end + + def start_time=(start_time); end + + def start_time?(); end + + def static_config_filter_manager(); end + + def static_config_filter_manager=(static_config_filter_manager); end + + def success_color=(success_color); end + + def success_color?(); end + + def threadsafe=(threadsafe); end + + def threadsafe?(); end + + def treat_symbols_as_metadata_keys_with_true_values=(_value); end + + def tty=(tty); end + + def tty?(); end + + def warnings=(value); end + + def warnings?(); end + + def when_first_matching_example_defined(*filters); end + + def with_suite_hooks(); end + + def world(); end + + def world=(world); end + DEFAULT_FORMATTER = ::T.let(nil, ::T.untyped) + FAILED_STATUS = ::T.let(nil, ::T.untyped) + MOCKING_ADAPTERS = ::T.let(nil, ::T.untyped) + PASSED_STATUS = ::T.let(nil, ::T.untyped) + PENDING_STATUS = ::T.let(nil, ::T.untyped) + RAISE_ERROR_WARNING_NOTIFIER = ::T.let(nil, ::T.untyped) + UNKNOWN_STATUS = ::T.let(nil, ::T.untyped) + VALID_STATUSES = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Configuration::DeprecationReporterBuffer + def deprecation(*args); end + + def play_onto(reporter); end +end + +class RSpec::Core::Configuration::DeprecationReporterBuffer +end + +module RSpec::Core::Configuration::ExposeCurrentExample +end + +module RSpec::Core::Configuration::ExposeCurrentExample +end + +class RSpec::Core::Configuration::MustBeConfiguredBeforeExampleGroupsError +end + +class RSpec::Core::Configuration::MustBeConfiguredBeforeExampleGroupsError +end + +module RSpec::Core::Configuration::Readers + def default_color(); end + + def default_path(); end + + def deprecation_stream(); end + + def detail_color(); end + + def drb(); end + + def drb_port(); end + + def dry_run(); end + + def error_stream(); end + + def example_status_persistence_file_path(); end + + def exclude_pattern(); end + + def fail_fast(); end + + def fail_if_no_examples(); end + + def failure_color(); end + + def failure_exit_code(); end + + def fixed_color(); end + + def libs(); end + + def max_displayed_failure_line_count(); end + + def only_failures(); end + + def output_stream(); end + + def pattern(); end + + def pending_color(); end + + def profile_examples(); end + + def project_source_dirs(); end + + def requires(); end + + def run_all_when_everything_filtered(); end + + def shared_context_metadata_behavior(); end + + def silence_filter_announcements(); end + + def start_time(); end + + def success_color(); end + + def threadsafe(); end + + def tty(); end +end + +module RSpec::Core::Configuration::Readers +end + +class RSpec::Core::Configuration + def self.add_read_only_setting(name, opts=T.unsafe(nil)); end + + def self.add_setting(name, opts=T.unsafe(nil)); end + + def self.define_aliases(name, alias_name); end + + def self.define_predicate_for(*names); end + + def self.define_reader(name); end + + def self.delegate_to_ordering_manager(*methods); end +end + +class RSpec::Core::ConfigurationOptions + def args(); end + + def configure(config); end + + def configure_filter_manager(filter_manager); end + + def initialize(args); end + + def options(); end + OPTIONS_ORDER = ::T.let(nil, ::T.untyped) + UNFORCED_OPTIONS = ::T.let(nil, ::T.untyped) + UNPROCESSABLE_OPTIONS = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::ConfigurationOptions +end + +module RSpec::Core::DSL +end + +module RSpec::Core::DSL + def self.change_global_dsl(&changes); end + + def self.example_group_aliases(); end + + def self.expose_example_group_alias(name); end + + def self.expose_example_group_alias_globally(method_name); end + + def self.expose_globally!(); end + + def self.exposed_globally?(); end + + def self.remove_globally!(); end + + def self.top_level(); end + + def self.top_level=(top_level); end +end + +class RSpec::Core::DeprecationError +end + +class RSpec::Core::DeprecationError +end + +class RSpec::Core::DidYouMean + def call(); end + + def initialize(relative_file_name); end + + def relative_file_name(); end +end + +class RSpec::Core::DidYouMean +end + +class RSpec::Core::Example + def clock(); end + + def clock=(clock); end + + def description(); end + + def display_exception(); end + + def display_exception=(ex); end + + def duplicate_with(metadata_overrides=T.unsafe(nil)); end + + def example_group(); end + + def example_group_instance(); end + + def exception(); end + + def execution_result(); end + + def fail_with_exception(reporter, exception); end + + def file_path(); end + + def full_description(); end + + def id(); end + + def initialize(example_group_class, description, user_metadata, example_block=T.unsafe(nil)); end + + def inspect_output(); end + + def instance_exec(*args, &block); end + + def location(); end + + def location_rerun_argument(); end + + def metadata(); end + + def pending(); end + + def pending?(); end + + def reporter(); end + + def rerun_argument(); end + + def run(example_group_instance, reporter); end + + def set_aggregate_failures_exception(exception); end + + def set_exception(exception); end + + def skip(); end + + def skip_with_exception(reporter, exception); end + + def skipped?(); end + + def update_inherited_metadata(updates); end +end + +RSpec::Core::Example::AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt = RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue + +class RSpec::Core::Example::ExecutionResult + include ::RSpec::Core::HashImitatable + def ensure_timing_set(clock); end + + def example_skipped?(); end + + def exception(); end + + def exception=(exception); end + + def finished_at(); end + + def finished_at=(finished_at); end + + def pending_exception(); end + + def pending_exception=(pending_exception); end + + def pending_fixed(); end + + def pending_fixed=(pending_fixed); end + + def pending_fixed?(); end + + def pending_message(); end + + def pending_message=(pending_message); end + + def record_finished(status, finished_at); end + + def run_time(); end + + def run_time=(run_time); end + + def started_at(); end + + def started_at=(started_at); end + + def status(); end + + def status=(status); end +end + +class RSpec::Core::Example::ExecutionResult + extend ::RSpec::Core::HashImitatable::ClassMethods +end + +class RSpec::Core::Example::Procsy + def <<(*a, &b); end + + def ===(*a, &b); end + + def >>(*a, &b); end + + def [](*a, &b); end + + def arity(*a, &b); end + + def binding(*a, &b); end + + def call(*args, &block); end + + def clock(*a, &b); end + + def clock=(*a, &b); end + + def clone(*a, &b); end + + def curry(*a, &b); end + + def description(*a, &b); end + + def dup(*a, &b); end + + def duplicate_with(*a, &b); end + + def example(); end + + def example_group(*a, &b); end + + def example_group_instance(*a, &b); end + + def exception(*a, &b); end + + def executed?(); end + + def execution_result(*a, &b); end + + def file_path(*a, &b); end + + def full_description(*a, &b); end + + def hash(*a, &b); end + + def id(*a, &b); end + + def initialize(example, &block); end + + def inspect_output(*a, &b); end + + def lambda?(*a, &b); end + + def location(*a, &b); end + + def location_rerun_argument(*a, &b); end + + def metadata(*a, &b); end + + def parameters(*a, &b); end + + def pending(*a, &b); end + + def pending?(*a, &b); end + + def reporter(*a, &b); end + + def rerun_argument(*a, &b); end + + def run(*args, &block); end + + def skip(*a, &b); end + + def skipped?(*a, &b); end + + def source_location(*a, &b); end + + def to_proc(); end + + def update_inherited_metadata(*a, &b); end + + def wrap(&block); end + + def yield(*a, &b); end +end + +class RSpec::Core::Example::Procsy +end + +class RSpec::Core::Example + def self.delegate_to_metadata(key); end + + def self.parse_id(id); end +end + +class RSpec::Core::ExampleGroup + include ::RSpec::Core::MemoizedHelpers + include ::RSpec::Core::Pending + def described_class(); end + + def initialize(inspect_output=T.unsafe(nil)); end + INSTANCE_VARIABLE_TO_IGNORE = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::ExampleGroup::WrongScopeError +end + +class RSpec::Core::ExampleGroup::WrongScopeError +end + +class RSpec::Core::ExampleGroup + extend ::RSpec::Core::Hooks + extend ::RSpec::Core::MemoizedHelpers::ClassMethods + extend ::RSpec::Core::SharedExampleGroup + def self.add_example(example); end + + def self.before_context_ivars(); end + + def self.children(); end + + def self.context(*args, &example_group_block); end + + def self.currently_executing_a_context_hook?(); end + + def self.declaration_locations(); end + + def self.define_example_group_method(name, metadata=T.unsafe(nil)); end + + def self.define_example_method(name, extra_options=T.unsafe(nil)); end + + def self.define_nested_shared_group_method(new_name, report_label=T.unsafe(nil)); end + + def self.delegate_to_metadata(*names); end + + def self.descendant_filtered_examples(); end + + def self.descendants(); end + + def self.describe(*args, &example_group_block); end + + def self.described_class(); end + + def self.description(); end + + def self.each_instance_variable_for_example(group); end + + def self.ensure_example_groups_are_configured(); end + + def self.example(*all_args, &block); end + + def self.example_group(*args, &example_group_block); end + + def self.examples(); end + + def self.fcontext(*args, &example_group_block); end + + def self.fdescribe(*args, &example_group_block); end + + def self.fexample(*all_args, &block); end + + def self.file_path(); end + + def self.filtered_examples(); end + + def self.find_and_eval_shared(label, name, inclusion_location, *args, &customization_block); end + + def self.fit(*all_args, &block); end + + def self.focus(*all_args, &block); end + + def self.for_filtered_examples(reporter, &block); end + + def self.fspecify(*all_args, &block); end + + def self.id(); end + + def self.idempotently_define_singleton_method(name, &definition); end + + def self.include_context(name, *args, &block); end + + def self.include_examples(name, *args, &block); end + + def self.it(*all_args, &block); end + + def self.it_behaves_like(name, *args, &customization_block); end + + def self.it_has_behavior(name, *args, &customization_block); end + + def self.it_should_behave_like(name, *args, &customization_block); end + + def self.location(); end + + def self.metadata(); end + + def self.next_runnable_index_for(file); end + + def self.ordering_strategy(); end + + def self.parent_groups(); end + + def self.pending(*all_args, &block); end + + def self.remove_example(example); end + + def self.reset_memoized(); end + + def self.run(reporter=T.unsafe(nil)); end + + def self.run_after_context_hooks(example_group_instance); end + + def self.run_before_context_hooks(example_group_instance); end + + def self.run_examples(reporter); end + + def self.set_it_up(description, args, registration_collection, &example_group_block); end + + def self.set_ivars(instance, ivars); end + + def self.skip(*all_args, &block); end + + def self.specify(*all_args, &block); end + + def self.store_before_context_ivars(example_group_instance); end + + def self.subclass(parent, description, args, registration_collection, &example_group_block); end + + def self.superclass_before_context_ivars(); end + + def self.superclass_metadata(); end + + def self.top_level?(); end + + def self.top_level_description(); end + + def self.traverse_tree_until(&block); end + + def self.update_inherited_metadata(updates); end + + def self.with_replaced_metadata(meta); end + + def self.xcontext(*args, &example_group_block); end + + def self.xdescribe(*args, &example_group_block); end + + def self.xexample(*all_args, &block); end + + def self.xit(*all_args, &block); end + + def self.xspecify(*all_args, &block); end +end + +class RSpec::Core::ExampleStatusDumper + def dump(); end + + def initialize(examples); end +end + +class RSpec::Core::ExampleStatusDumper + def self.dump(examples); end +end + +class RSpec::Core::ExampleStatusMerger + def initialize(this_run, from_previous_runs); end + + def merge(); end +end + +class RSpec::Core::ExampleStatusMerger + def self.merge(this_run, from_previous_runs); end +end + +class RSpec::Core::ExampleStatusParser + def initialize(string); end + + def parse(); end +end + +class RSpec::Core::ExampleStatusParser + def self.parse(string); end +end + +class RSpec::Core::ExampleStatusPersister + def initialize(examples, file_name); end + + def persist(); end +end + +class RSpec::Core::ExampleStatusPersister + def self.load_from(file_name); end + + def self.persist(examples, file_name); end +end + +RSpec::Core::ExclusionRules = RSpec::Core::FilterRules + +class RSpec::Core::FilterManager + def add_ids(rerun_path, scoped_ids); end + + def add_location(file_path, line_numbers); end + + def empty?(); end + + def exclude(*args); end + + def exclude_only(*args); end + + def exclude_with_low_priority(*args); end + + def exclusions(); end + + def include(*args); end + + def include_only(*args); end + + def include_with_low_priority(*args); end + + def inclusions(); end + + def prune(examples); end +end + +class RSpec::Core::FilterManager +end + +class RSpec::Core::FilterRules + def [](key); end + + def add(updated); end + + def add_with_low_priority(updated); end + + def clear(); end + + def delete(key); end + + def description(); end + + def each_pair(&block); end + + def empty?(); end + + def fetch(*args, &block); end + + def include_example?(example); end + + def initialize(rules=T.unsafe(nil)); end + + def opposite(); end + + def opposite=(opposite); end + + def rules(); end + + def use_only(updated); end + PROC_HEX_NUMBER = ::T.let(nil, ::T.untyped) + PROJECT_DIR = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::FilterRules + def self.build(); end +end + +module RSpec::Core::FilterableItemRepository +end + +class RSpec::Core::FilterableItemRepository::QueryOptimized + def items_for(metadata); end +end + +class RSpec::Core::FilterableItemRepository::QueryOptimized +end + +class RSpec::Core::FilterableItemRepository::UpdateOptimized + def append(item, metadata); end + + def delete(item, metadata); end + + def initialize(applies_predicate); end + + def items_and_filters(); end + + def items_for(request_meta); end + + def prepend(item, metadata); end +end + +class RSpec::Core::FilterableItemRepository::UpdateOptimized +end + +module RSpec::Core::FilterableItemRepository +end + +module RSpec::Core::FlatMap +end + +module RSpec::Core::FlatMap + def self.flat_map(array, &block); end +end + +module RSpec::Core::Formatters +end + +class RSpec::Core::Formatters::BaseBisectFormatter + def example_failed(notification); end + + def example_finished(notification); end + + def initialize(expected_failures); end + + def start_dump(_notification); end +end + +class RSpec::Core::Formatters::BaseBisectFormatter + def self.inherited(formatter); end +end + +class RSpec::Core::Formatters::BaseFormatter + def close(_notification); end + + def example_group(); end + + def example_group=(example_group); end + + def example_group_started(notification); end + + def initialize(output); end + + def output(); end + + def start(notification); end +end + +class RSpec::Core::Formatters::BaseFormatter +end + +class RSpec::Core::Formatters::BaseTextFormatter + def dump_failures(notification); end + + def dump_pending(notification); end + + def dump_summary(summary); end + + def message(notification); end + + def seed(notification); end +end + +class RSpec::Core::Formatters::BaseTextFormatter +end + +class RSpec::Core::Formatters::BisectDRbFormatter + def initialize(_output); end + + def notify_results(results); end +end + +class RSpec::Core::Formatters::BisectDRbFormatter +end + +module RSpec::Core::Formatters::ConsoleCodes + VT100_CODES = ::T.let(nil, ::T.untyped) + VT100_CODE_VALUES = ::T.let(nil, ::T.untyped) +end + +module RSpec::Core::Formatters::ConsoleCodes + def self.config_colors_to_methods(); end + + def self.console_code_for(code_or_symbol); end + + def self.wrap(text, code_or_symbol); end +end + +class RSpec::Core::Formatters::DeprecationFormatter + def count(); end + + def deprecation(notification); end + + def deprecation_message_for(data); end + + def deprecation_stream(); end + + def deprecation_summary(_notification); end + + def initialize(deprecation_stream, summary_stream); end + + def output(); end + + def printer(); end + + def summary_stream(); end + DEPRECATION_STREAM_NOTICE = ::T.let(nil, ::T.untyped) + RAISE_ERROR_CONFIG_NOTICE = ::T.let(nil, ::T.untyped) + TOO_MANY_WARNINGS_NOTICE = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter + def deprecation_formatter(); end + + def deprecation_stream(); end + + def deprecation_summary(); end + + def initialize(deprecation_stream, summary_stream, deprecation_formatter); end + + def print_deferred_deprecation_warnings(); end + + def print_deprecation_message(data); end + + def stash_deprecation_message(deprecation_message); end + + def summary_stream(); end + TOO_MANY_USES_LIMIT = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter +end + +class RSpec::Core::Formatters::DeprecationFormatter::FileStream + def initialize(file); end + + def puts(*args); end + + def summarize(summary_stream, deprecation_count); end +end + +class RSpec::Core::Formatters::DeprecationFormatter::FileStream +end + +class RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage + def initialize(data); end + + def too_many_warnings_message(); end + + def type(); end + + def type=(_); end +end + +class RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage + def self.[](*_); end + + def self.members(); end +end + +class RSpec::Core::Formatters::DeprecationFormatter::ImmediatePrinter + def deprecation_formatter(); end + + def deprecation_stream(); end + + def deprecation_summary(); end + + def initialize(deprecation_stream, summary_stream, deprecation_formatter); end + + def print_deprecation_message(data); end + + def summary_stream(); end +end + +class RSpec::Core::Formatters::DeprecationFormatter::ImmediatePrinter +end + +class RSpec::Core::Formatters::DeprecationFormatter::RaiseErrorStream + def puts(message); end + + def summarize(summary_stream, deprecation_count); end +end + +class RSpec::Core::Formatters::DeprecationFormatter::RaiseErrorStream +end + +class RSpec::Core::Formatters::DeprecationFormatter::SpecifiedDeprecationMessage + def initialize(data); end + + def too_many_warnings_message(); end + + def type(); end + + def type=(_); end +end + +class RSpec::Core::Formatters::DeprecationFormatter::SpecifiedDeprecationMessage + def self.[](*_); end + + def self.members(); end +end + +class RSpec::Core::Formatters::DeprecationFormatter +end + +class RSpec::Core::Formatters::DocumentationFormatter + def example_failed(failure); end + + def example_group_finished(_notification); end + + def example_passed(passed); end + + def example_pending(pending); end + + def example_started(_notification); end +end + +class RSpec::Core::Formatters::DocumentationFormatter +end + +class RSpec::Core::Formatters::ExceptionPresenter + def colorized_formatted_backtrace(colorizer=T.unsafe(nil)); end + + def colorized_message_lines(colorizer=T.unsafe(nil)); end + + def description(); end + + def example(); end + + def exception(); end + + def formatted_backtrace(exception=T.unsafe(nil)); end + + def formatted_cause(exception); end + + def fully_formatted(failure_number, colorizer=T.unsafe(nil)); end + + def fully_formatted_lines(failure_number, colorizer); end + + def initialize(exception, example, options=T.unsafe(nil)); end + + def message_lines(); end + PENDING_DETAIL_FORMATTER = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Formatters::ExceptionPresenter::Factory + def build(); end + + def initialize(example); end +end + +class RSpec::Core::Formatters::ExceptionPresenter::Factory::CommonBacktraceTruncater + def initialize(parent); end + + def with_truncated_backtrace(child); end +end + +class RSpec::Core::Formatters::ExceptionPresenter::Factory::CommonBacktraceTruncater +end + +module RSpec::Core::Formatters::ExceptionPresenter::Factory::EmptyBacktraceFormatter +end + +module RSpec::Core::Formatters::ExceptionPresenter::Factory::EmptyBacktraceFormatter + def self.format_backtrace(*_); end +end + +class RSpec::Core::Formatters::ExceptionPresenter::Factory +end + +class RSpec::Core::Formatters::ExceptionPresenter +end + +class RSpec::Core::Formatters::FailureListFormatter + def dump_profile(_profile); end + + def example_failed(failure); end + + def message(_message); end +end + +class RSpec::Core::Formatters::FailureListFormatter +end + +class RSpec::Core::Formatters::FallbackMessageFormatter + def initialize(output); end + + def message(notification); end + + def output(); end +end + +class RSpec::Core::Formatters::FallbackMessageFormatter +end + +module RSpec::Core::Formatters::Helpers + DEFAULT_PRECISION = ::T.let(nil, ::T.untyped) + SUB_SECOND_PRECISION = ::T.let(nil, ::T.untyped) +end + +module RSpec::Core::Formatters::Helpers + def self.format_duration(duration); end + + def self.format_seconds(float, precision=T.unsafe(nil)); end + + def self.organize_ids(ids); end + + def self.pluralize(count, string); end +end + +class RSpec::Core::Formatters::HtmlFormatter + def dump_summary(summary); end + + def example_failed(failure); end + + def example_passed(passed); end + + def example_pending(pending); end + + def example_started(_notification); end + + def start_dump(_notification); end +end + +class RSpec::Core::Formatters::HtmlFormatter +end + +class RSpec::Core::Formatters::HtmlPrinter + include ::ERB::Util + def flush(); end + + def initialize(output); end + + def make_example_group_header_red(group_id); end + + def make_example_group_header_yellow(group_id); end + + def make_header_red(); end + + def make_header_yellow(); end + + def move_progress(percent_done); end + + def print_example_failed(pending_fixed, description, run_time, failure_id, exception, extra_content); end + + def print_example_group_end(); end + + def print_example_group_start(group_id, description, number_of_parents); end + + def print_example_passed(description, run_time); end + + def print_example_pending(description, pending_message); end + + def print_html_start(); end + + def print_summary(duration, example_count, failure_count, pending_count); end + GLOBAL_SCRIPTS = ::T.let(nil, ::T.untyped) + GLOBAL_STYLES = ::T.let(nil, ::T.untyped) + HTML_HEADER = ::T.let(nil, ::T.untyped) + REPORT_HEADER = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Formatters::HtmlPrinter +end + +class RSpec::Core::Formatters::JsonFormatter + def dump_profile(profile); end + + def dump_profile_slowest_example_groups(profile); end + + def dump_profile_slowest_examples(profile); end + + def dump_summary(summary); end + + def message(notification); end + + def output_hash(); end + + def seed(notification); end + + def stop(notification); end +end + +class RSpec::Core::Formatters::JsonFormatter +end + +class RSpec::Core::Formatters::Loader + def add(formatter_to_use, *paths); end + + def default_formatter(); end + + def default_formatter=(default_formatter); end + + def formatters(); end + + def initialize(reporter); end + + def prepare_default(output_stream, deprecation_stream); end + + def reporter(); end + + def setup_default(output_stream, deprecation_stream); end +end + +class RSpec::Core::Formatters::Loader + def self.formatters(); end +end + +class RSpec::Core::Formatters::ProfileFormatter + def dump_profile(profile); end + + def initialize(output); end + + def output(); end +end + +class RSpec::Core::Formatters::ProfileFormatter +end + +class RSpec::Core::Formatters::ProgressFormatter + def example_failed(_notification); end + + def example_passed(_notification); end + + def example_pending(_notification); end + + def start_dump(_notification); end +end + +class RSpec::Core::Formatters::ProgressFormatter +end + +class RSpec::Core::Formatters::SnippetExtractor + def beginning_line_number(); end + + def expression_lines(); end + + def initialize(source, beginning_line_number, max_line_count=T.unsafe(nil)); end + + def max_line_count(); end + + def source(); end +end + +class RSpec::Core::Formatters::SnippetExtractor::NoExpressionAtLineError +end + +class RSpec::Core::Formatters::SnippetExtractor::NoExpressionAtLineError +end + +class RSpec::Core::Formatters::SnippetExtractor::NoSuchFileError +end + +class RSpec::Core::Formatters::SnippetExtractor::NoSuchFileError +end + +class RSpec::Core::Formatters::SnippetExtractor::NoSuchLineError +end + +class RSpec::Core::Formatters::SnippetExtractor::NoSuchLineError +end + +class RSpec::Core::Formatters::SnippetExtractor + def self.extract_expression_lines_at(file_path, beginning_line_number, max_line_count=T.unsafe(nil)); end + + def self.extract_line_at(file_path, line_number); end + + def self.least_indentation_from(lines); end + + def self.source_from_file(path); end +end + +class RSpec::Core::Formatters::SyntaxHighlighter + def highlight(lines); end + + def initialize(configuration); end +end + +module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation + RESET_CODE = ::T.let(nil, ::T.untyped) +end + +module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation + def self.highlight_syntax(lines); end +end + +module RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation +end + +module RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation + def self.highlight_syntax(lines); end +end + +RSpec::Core::Formatters::SyntaxHighlighter::WindowsImplementation = RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation + +class RSpec::Core::Formatters::SyntaxHighlighter + def self.attempt_to_add_rspec_terms_to_coderay_keywords(); end +end + +module RSpec::Core::Formatters + def self.register(formatter_class, *notifications); end +end + +module RSpec::Core::HashImitatable + def <(*args, &block); end + + def <=(*args, &block); end + + def >(*args, &block); end + + def >=(*args, &block); end + + def [](key); end + + def []=(key, value); end + + def all?(*args, &block); end + + def any?(*args, &block); end + + def assoc(*args, &block); end + + def chain(*args, &block); end + + def chunk(*args, &block); end + + def chunk_while(*args, &block); end + + def clear(*args, &block); end + + def collect(*args, &block); end + + def collect_concat(*args, &block); end + + def compact(*args, &block); end + + def compact!(*args, &block); end + + def compare_by_identity(*args, &block); end + + def compare_by_identity?(*args, &block); end + + def count(*args, &block); end + + def cycle(*args, &block); end + + def default(*args, &block); end + + def default=(*args, &block); end + + def default_proc(*args, &block); end + + def default_proc=(*args, &block); end + + def delete(*args, &block); end + + def delete_if(*args, &block); end + + def detect(*args, &block); end + + def dig(*args, &block); end + + def drop(*args, &block); end + + def drop_while(*args, &block); end + + def each(*args, &block); end + + def each_cons(*args, &block); end + + def each_entry(*args, &block); end + + def each_key(*args, &block); end + + def each_pair(*args, &block); end + + def each_slice(*args, &block); end + + def each_value(*args, &block); end + + def each_with_index(*args, &block); end + + def each_with_object(*args, &block); end + + def empty?(*args, &block); end + + def entries(*args, &block); end + + def fetch(*args, &block); end + + def fetch_values(*args, &block); end + + def filter(*args, &block); end + + def filter!(*args, &block); end + + def find(*args, &block); end + + def find_all(*args, &block); end + + def find_index(*args, &block); end + + def first(*args, &block); end + + def flat_map(*args, &block); end + + def flatten(*args, &block); end + + def grep(*args, &block); end + + def grep_v(*args, &block); end + + def group_by(*args, &block); end + + def has_key?(*args, &block); end + + def has_value?(*args, &block); end + + def include?(*args, &block); end + + def index(*args, &block); end + + def inject(*args, &block); end + + def invert(*args, &block); end + + def keep_if(*args, &block); end + + def key(*args, &block); end + + def key?(*args, &block); end + + def keys(*args, &block); end + + def lazy(*args, &block); end + + def length(*args, &block); end + + def map(*args, &block); end + + def max(*args, &block); end + + def max_by(*args, &block); end + + def member?(*args, &block); end + + def merge(*args, &block); end + + def merge!(*args, &block); end + + def min(*args, &block); end + + def min_by(*args, &block); end + + def minmax(*args, &block); end + + def minmax_by(*args, &block); end + + def none?(*args, &block); end + + def one?(*args, &block); end + + def partition(*args, &block); end + + def rassoc(*args, &block); end + + def reduce(*args, &block); end + + def rehash(*args, &block); end + + def reject(*args, &block); end + + def reject!(*args, &block); end + + def replace(*args, &block); end + + def reverse_each(*args, &block); end + + def select(*args, &block); end + + def select!(*args, &block); end + + def shift(*args, &block); end + + def size(*args, &block); end + + def slice(*args, &block); end + + def slice_after(*args, &block); end + + def slice_before(*args, &block); end + + def slice_when(*args, &block); end + + def sort(*args, &block); end + + def sort_by(*args, &block); end + + def store(*args, &block); end + + def sum(*args, &block); end + + def take(*args, &block); end + + def take_while(*args, &block); end + + def to_a(*args, &block); end + + def to_h(); end + + def to_hash(*args, &block); end + + def to_proc(*args, &block); end + + def to_set(*args, &block); end + + def transform_keys(*args, &block); end + + def transform_keys!(*args, &block); end + + def transform_values(*args, &block); end + + def transform_values!(*args, &block); end + + def uniq(*args, &block); end + + def update(*args, &block); end + + def value?(*args, &block); end + + def values(*args, &block); end + + def values_at(*args, &block); end + + def zip(*args, &block); end +end + +module RSpec::Core::HashImitatable::ClassMethods + def attr_accessor(*names); end + + def hash_attribute_names(); end +end + +module RSpec::Core::HashImitatable::ClassMethods +end + +module RSpec::Core::HashImitatable + def self.included(klass); end +end + +module RSpec::Core::Hooks + def after(*args, &block); end + + def append_after(*args, &block); end + + def append_before(*args, &block); end + + def around(*args, &block); end + + def before(*args, &block); end + + def hooks(); end + + def prepend_after(*args, &block); end + + def prepend_before(*args, &block); end +end + +class RSpec::Core::Hooks::AfterContextHook + def run(example); end +end + +class RSpec::Core::Hooks::AfterContextHook +end + +class RSpec::Core::Hooks::AfterHook + def run(example); end +end + +class RSpec::Core::Hooks::AfterHook +end + +class RSpec::Core::Hooks::AroundHook + def execute_with(example, procsy); end + + def hook_description(); end +end + +class RSpec::Core::Hooks::AroundHook +end + +class RSpec::Core::Hooks::BeforeHook + def run(example); end +end + +class RSpec::Core::Hooks::BeforeHook +end + +class RSpec::Core::Hooks::Hook + def block(); end + + def block=(_); end + + def options(); end + + def options=(_); end +end + +class RSpec::Core::Hooks::Hook + def self.[](*_); end + + def self.members(); end +end + +class RSpec::Core::Hooks::HookCollections + def all_hooks_for(position, scope); end + + def initialize(owner, filterable_item_repo_class); end + + def matching_hooks_for(position, scope, example_or_group); end + + def processable_hooks_for(position, scope, host); end + + def register(prepend_or_append, position, *args, &block); end + + def register_global_singleton_context_hooks(example, globals); end + + def register_globals(host, globals); end + + def run(position, scope, example_or_group); end + + def run_owned_hooks_for(position, scope, example_or_group); end + EMPTY_HOOK_ARRAY = ::T.let(nil, ::T.untyped) + HOOK_TYPES = ::T.let(nil, ::T.untyped) + SCOPES = ::T.let(nil, ::T.untyped) + SCOPE_ALIASES = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Hooks::HookCollections +end + +module RSpec::Core::Hooks +end + +class RSpec::Core::InclusionRules + def add(*args); end + + def add_with_low_priority(*args); end + + def split_file_scoped_rules(); end + + def standalone?(); end +end + +class RSpec::Core::InclusionRules +end + +module RSpec::Core::Invocations +end + +class RSpec::Core::Invocations::Bisect + def call(options, err, out); end +end + +class RSpec::Core::Invocations::Bisect +end + +class RSpec::Core::Invocations::DRbWithFallback + def call(options, err, out); end +end + +class RSpec::Core::Invocations::DRbWithFallback +end + +class RSpec::Core::Invocations::InitializeProject + def call(*_args); end +end + +class RSpec::Core::Invocations::InitializeProject +end + +class RSpec::Core::Invocations::PrintHelp + def call(_options, _err, out); end + + def hidden_options(); end + + def hidden_options=(_); end + + def parser(); end + + def parser=(_); end +end + +class RSpec::Core::Invocations::PrintHelp + def self.[](*_); end + + def self.members(); end +end + +class RSpec::Core::Invocations::PrintVersion + def call(_options, _err, out); end +end + +class RSpec::Core::Invocations::PrintVersion +end + +module RSpec::Core::Invocations +end + +class RSpec::Core::LegacyExampleGroupHash + include ::RSpec::Core::HashImitatable + def initialize(metadata); end +end + +class RSpec::Core::LegacyExampleGroupHash + extend ::RSpec::Core::HashImitatable::ClassMethods +end + +module RSpec::Core::MemoizedHelpers + def initialize(*_); end + + def is_expected(); end + + def should(matcher=T.unsafe(nil), message=T.unsafe(nil)); end + + def should_not(matcher=T.unsafe(nil), message=T.unsafe(nil)); end + + def subject(); end +end + +module RSpec::Core::MemoizedHelpers::ClassMethods + def let(name, &block); end + + def let!(name, &block); end + + def subject(name=T.unsafe(nil), &block); end + + def subject!(name=T.unsafe(nil), &block); end +end + +module RSpec::Core::MemoizedHelpers::ClassMethods +end + +class RSpec::Core::MemoizedHelpers::ContextHookMemoized +end + +class RSpec::Core::MemoizedHelpers::ContextHookMemoized::After +end + +class RSpec::Core::MemoizedHelpers::ContextHookMemoized::After + def self.article(); end + + def self.hook_expression(); end + + def self.hook_intention(); end +end + +class RSpec::Core::MemoizedHelpers::ContextHookMemoized::Before +end + +class RSpec::Core::MemoizedHelpers::ContextHookMemoized::Before + def self.article(); end + + def self.hook_expression(); end + + def self.hook_intention(); end +end + +class RSpec::Core::MemoizedHelpers::ContextHookMemoized + def self.fetch_or_store(key, &_block); end + + def self.isolate_for_context_hook(example_group_instance); end +end + +class RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized + def fetch_or_store(key); end +end + +class RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized +end + +class RSpec::Core::MemoizedHelpers::ThreadsafeMemoized + def fetch_or_store(key); end +end + +class RSpec::Core::MemoizedHelpers::ThreadsafeMemoized +end + +module RSpec::Core::MemoizedHelpers + def self.define_helpers_on(example_group); end + + def self.get_constant_or_yield(example_group, name); end + + def self.module_for(example_group); end +end + +module RSpec::Core::Metadata + RESERVED_KEYS = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Metadata::ExampleGroupHash +end + +class RSpec::Core::Metadata::ExampleGroupHash + def self.backwards_compatibility_default_proc(&example_group_selector); end + + def self.create(parent_group_metadata, user_metadata, example_group_index, *args, &block); end + + def self.hash_with_backwards_compatibility_default_proc(); end +end + +class RSpec::Core::Metadata::ExampleHash +end + +class RSpec::Core::Metadata::ExampleHash + def self.create(group_metadata, user_metadata, index_provider, description, block); end +end + +class RSpec::Core::Metadata::HashPopulator + def block(); end + + def description_args(); end + + def initialize(metadata, user_metadata, index_provider, description_args, block); end + + def metadata(); end + + def populate(); end + + def user_metadata(); end +end + +class RSpec::Core::Metadata::HashPopulator +end + +module RSpec::Core::Metadata + def self.ascend(metadata); end + + def self.ascending(metadata); end + + def self.build_hash_from(args, warn_about_example_group_filtering=T.unsafe(nil)); end + + def self.deep_hash_dup(object); end + + def self.id_from(metadata); end + + def self.location_tuple_from(metadata); end + + def self.relative_path(line); end + + def self.relative_path_regex(); end +end + +module RSpec::Core::MetadataFilter +end + +module RSpec::Core::MetadataFilter + def self.apply?(predicate, filters, metadata); end + + def self.filter_applies?(key, filter_value, metadata); end + + def self.silence_metadata_example_group_deprecations(); end +end + +class RSpec::Core::MultipleExceptionError + include ::RSpec::Core::MultipleExceptionError::InterfaceTag + def aggregation_block_label(); end + + def aggregation_metadata(); end + + def all_exceptions(); end + + def exception_count_description(); end + + def failures(); end + + def initialize(*exceptions); end + + def other_errors(); end + + def summary(); end +end + +module RSpec::Core::MultipleExceptionError::InterfaceTag + def add(exception); end +end + +module RSpec::Core::MultipleExceptionError::InterfaceTag + def self.for(ex); end +end + +class RSpec::Core::MultipleExceptionError +end + +module RSpec::Core::Notifications +end + +class RSpec::Core::Notifications::CustomNotification +end + +class RSpec::Core::Notifications::CustomNotification + def self.for(options=T.unsafe(nil)); end +end + +class RSpec::Core::Notifications::DeprecationNotification + def call_site(); end + + def call_site=(_); end + + def deprecated(); end + + def deprecated=(_); end + + def message(); end + + def message=(_); end + + def replacement(); end + + def replacement=(_); end +end + +class RSpec::Core::Notifications::DeprecationNotification + def self.[](*_); end + + def self.from_hash(data); end + + def self.members(); end +end + +class RSpec::Core::Notifications::ExampleNotification + def example(); end + + def example=(_); end +end + +class RSpec::Core::Notifications::ExampleNotification + def self.[](*_); end + + def self.for(example); end + + def self.members(); end +end + +class RSpec::Core::Notifications::ExamplesNotification + def examples(); end + + def failed_examples(); end + + def failure_notifications(); end + + def fully_formatted_failed_examples(colorizer=T.unsafe(nil)); end + + def fully_formatted_pending_examples(colorizer=T.unsafe(nil)); end + + def initialize(reporter); end + + def notifications(); end + + def pending_examples(); end + + def pending_notifications(); end +end + +class RSpec::Core::Notifications::ExamplesNotification +end + +class RSpec::Core::Notifications::FailedExampleNotification + def colorized_formatted_backtrace(colorizer=T.unsafe(nil)); end + + def colorized_message_lines(colorizer=T.unsafe(nil)); end + + def description(); end + + def exception(); end + + def formatted_backtrace(); end + + def fully_formatted(failure_number, colorizer=T.unsafe(nil)); end + + def fully_formatted_lines(failure_number, colorizer=T.unsafe(nil)); end + + def initialize(example, exception_presenter=T.unsafe(nil)); end + + def message_lines(); end +end + +class RSpec::Core::Notifications::FailedExampleNotification +end + +class RSpec::Core::Notifications::GroupNotification + def group(); end + + def group=(_); end +end + +class RSpec::Core::Notifications::GroupNotification + def self.[](*_); end + + def self.members(); end +end + +class RSpec::Core::Notifications::MessageNotification + def message(); end + + def message=(_); end +end + +class RSpec::Core::Notifications::MessageNotification + def self.[](*_); end + + def self.members(); end +end + +module RSpec::Core::Notifications::NullColorizer +end + +module RSpec::Core::Notifications::NullColorizer + def self.wrap(line, _code_or_symbol); end +end + +class RSpec::Core::Notifications::NullNotification +end + +class RSpec::Core::Notifications::NullNotification +end + +class RSpec::Core::Notifications::PendingExampleFailedAsExpectedNotification +end + +class RSpec::Core::Notifications::PendingExampleFailedAsExpectedNotification +end + +class RSpec::Core::Notifications::PendingExampleFixedNotification +end + +class RSpec::Core::Notifications::PendingExampleFixedNotification +end + +class RSpec::Core::Notifications::ProfileNotification + def duration(); end + + def examples(); end + + def initialize(duration, examples, number_of_examples, example_groups); end + + def number_of_examples(); end + + def percentage(); end + + def slow_duration(); end + + def slowest_examples(); end + + def slowest_groups(); end +end + +class RSpec::Core::Notifications::ProfileNotification +end + +class RSpec::Core::Notifications::SeedNotification + def fully_formatted(); end + + def seed(); end + + def seed=(_); end + + def seed_used?(); end + + def used=(_); end +end + +class RSpec::Core::Notifications::SeedNotification + def self.[](*_); end + + def self.members(); end +end + +class RSpec::Core::Notifications::SkippedExampleNotification + def fully_formatted(pending_number, colorizer=T.unsafe(nil)); end +end + +class RSpec::Core::Notifications::SkippedExampleNotification +end + +class RSpec::Core::Notifications::StartNotification + def count(); end + + def count=(_); end + + def load_time(); end + + def load_time=(_); end +end + +class RSpec::Core::Notifications::StartNotification + def self.[](*_); end + + def self.members(); end +end + +class RSpec::Core::Notifications::SummaryNotification + include ::RSpec::Core::ShellEscape + def colorized_rerun_commands(colorizer=T.unsafe(nil)); end + + def colorized_totals_line(colorizer=T.unsafe(nil)); end + + def duration(); end + + def duration=(_); end + + def errors_outside_of_examples_count(); end + + def errors_outside_of_examples_count=(_); end + + def example_count(); end + + def examples(); end + + def examples=(_); end + + def failed_examples(); end + + def failed_examples=(_); end + + def failure_count(); end + + def formatted_duration(); end + + def formatted_load_time(); end + + def fully_formatted(colorizer=T.unsafe(nil)); end + + def load_time(); end + + def load_time=(_); end + + def pending_count(); end + + def pending_examples(); end + + def pending_examples=(_); end + + def totals_line(); end +end + +class RSpec::Core::Notifications::SummaryNotification + def self.[](*_); end + + def self.members(); end +end + +module RSpec::Core::Notifications +end + +class RSpec::Core::NullReporter +end + +class RSpec::Core::NullReporter +end + +module RSpec::Core::Ordering +end + +class RSpec::Core::Ordering::ConfigurationManager + def force(hash); end + + def order=(type); end + + def ordering_registry(); end + + def register_ordering(name, strategy=T.unsafe(nil)); end + + def seed(); end + + def seed=(seed); end + + def seed_used?(); end +end + +class RSpec::Core::Ordering::ConfigurationManager +end + +class RSpec::Core::Ordering::Custom + def initialize(callable); end + + def order(list); end +end + +class RSpec::Core::Ordering::Custom +end + +class RSpec::Core::Ordering::Identity + def order(items); end +end + +class RSpec::Core::Ordering::Identity +end + +class RSpec::Core::Ordering::Random + def initialize(configuration); end + + def order(items); end + + def used?(); end + MAX_32_BIT = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Ordering::Random +end + +class RSpec::Core::Ordering::Registry + def fetch(name, &fallback); end + + def initialize(configuration); end + + def register(sym, strategy); end + + def used_random_seed?(); end +end + +class RSpec::Core::Ordering::Registry +end + +module RSpec::Core::Ordering +end + +class RSpec::Core::OutputWrapper + def <<(*args, &block); end + + def advise(*args, &block); end + + def autoclose=(*args, &block); end + + def autoclose?(*args, &block); end + + def binmode(*args, &block); end + + def binmode?(*args, &block); end + + def bytes(*args, &block); end + + def chars(*args, &block); end + + def close(*args, &block); end + + def close_on_exec=(*args, &block); end + + def close_on_exec?(*args, &block); end + + def close_read(*args, &block); end + + def close_write(*args, &block); end + + def closed?(*args, &block); end + + def codepoints(*args, &block); end + + def each(*args, &block); end + + def each_byte(*args, &block); end + + def each_char(*args, &block); end + + def each_codepoint(*args, &block); end + + def each_line(*args, &block); end + + def eof(*args, &block); end + + def eof?(*args, &block); end + + def external_encoding(*args, &block); end + + def fcntl(*args, &block); end + + def fdatasync(*args, &block); end + + def fileno(*args, &block); end + + def flush(*args, &block); end + + def fsync(*args, &block); end + + def getbyte(*args, &block); end + + def getc(*args, &block); end + + def gets(*args, &block); end + + def initialize(output); end + + def inspect(*args, &block); end + + def internal_encoding(*args, &block); end + + def ioctl(*args, &block); end + + def isatty(*args, &block); end + + def lineno(*args, &block); end + + def lineno=(*args, &block); end + + def lines(*args, &block); end + + def method_missing(name, *args, &block); end + + def nread(*args, &block); end + + def output(); end + + def output=(output); end + + def pathconf(*args, &block); end + + def pid(*args, &block); end + + def pos(*args, &block); end + + def pos=(*args, &block); end + + def pread(*args, &block); end + + def print(*args, &block); end + + def printf(*args, &block); end + + def putc(*args, &block); end + + def puts(*args, &block); end + + def pwrite(*args, &block); end + + def read(*args, &block); end + + def read_nonblock(*args, &block); end + + def readbyte(*args, &block); end + + def readchar(*args, &block); end + + def readline(*args, &block); end + + def readlines(*args, &block); end + + def readpartial(*args, &block); end + + def ready?(*args, &block); end + + def reopen(*args, &block); end + + def respond_to?(name, priv=T.unsafe(nil)); end + + def rewind(*args, &block); end + + def seek(*args, &block); end + + def set_encoding(*args, &block); end + + def stat(*args, &block); end + + def sync(*args, &block); end + + def sync=(*args, &block); end + + def sysread(*args, &block); end + + def sysseek(*args, &block); end + + def syswrite(*args, &block); end + + def tell(*args, &block); end + + def to_i(*args, &block); end + + def to_io(*args, &block); end + + def tty?(*args, &block); end + + def ungetbyte(*args, &block); end + + def ungetc(*args, &block); end + + def wait(*args, &block); end + + def wait_readable(*args, &block); end + + def wait_writable(*args, &block); end + + def write(*args, &block); end + + def write_nonblock(*args, &block); end +end + +class RSpec::Core::OutputWrapper +end + +class RSpec::Core::Parser + def initialize(original_args); end + + def original_args(); end + + def parse(source=T.unsafe(nil)); end +end + +class RSpec::Core::Parser + def self.parse(args, source=T.unsafe(nil)); end +end + +module RSpec::Core::Pending + def pending(message=T.unsafe(nil)); end + + def skip(message=T.unsafe(nil)); end + NOT_YET_IMPLEMENTED = ::T.let(nil, ::T.untyped) + NO_REASON_GIVEN = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Pending::PendingExampleFixedError +end + +class RSpec::Core::Pending::PendingExampleFixedError +end + +class RSpec::Core::Pending::SkipDeclaredInExample + def argument(); end + + def initialize(argument); end +end + +class RSpec::Core::Pending::SkipDeclaredInExample +end + +module RSpec::Core::Pending + def self.mark_fixed!(example); end + + def self.mark_pending!(example, message_or_bool); end + + def self.mark_skipped!(example, message_or_bool); end +end + +class RSpec::Core::Profiler + def example_group_finished(notification); end + + def example_group_started(notification); end + + def example_groups(); end + + def example_started(notification); end + NOTIFICATIONS = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Profiler +end + +class RSpec::Core::Reporter + def abort_with(msg, exit_status); end + + def close_after(); end + + def deprecation(hash); end + + def example_failed(example); end + + def example_finished(example); end + + def example_group_finished(group); end + + def example_group_started(group); end + + def example_passed(example); end + + def example_pending(example); end + + def example_started(example); end + + def examples(); end + + def exit_early(exit_code); end + + def fail_fast_limit_met?(); end + + def failed_examples(); end + + def finish(); end + + def initialize(configuration); end + + def message(message); end + + def notify(event, notification); end + + def notify_non_example_exception(exception, context_description); end + + def pending_examples(); end + + def prepare_default(loader, output_stream, deprecation_stream); end + + def publish(event, options=T.unsafe(nil)); end + + def register_listener(listener, *notifications); end + + def registered_listeners(notification); end + + def report(expected_example_count); end + + def start(expected_example_count, time=T.unsafe(nil)); end + + def stop(); end + RSPEC_NOTIFICATIONS = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Reporter +end + +module RSpec::Core::RubyProject +end + +module RSpec::Core::RubyProject + def self.add_dir_to_load_path(dir); end + + def self.add_to_load_path(*dirs); end + + def self.ascend_until(); end + + def self.determine_root(); end + + def self.find_first_parent_containing(dir); end + + def self.root(); end +end + +class RSpec::Core::Runner + def configuration(); end + + def configure(err, out); end + + def initialize(options, configuration=T.unsafe(nil), world=T.unsafe(nil)); end + + def options(); end + + def run(err, out); end + + def run_specs(example_groups); end + + def setup(err, out); end + + def world(); end +end + +class RSpec::Core::Runner + def self.autorun(); end + + def self.autorun_disabled?(); end + + def self.disable_autorun!(); end + + def self.handle_interrupt(); end + + def self.installed_at_exit?(); end + + def self.invoke(); end + + def self.perform_at_exit(); end + + def self.run(args, err=T.unsafe(nil), out=T.unsafe(nil)); end + + def self.running_in_drb?(); end + + def self.trap_interrupt(); end +end + +class RSpec::Core::Set + include ::Enumerable + def <<(key); end + + def clear(); end + + def delete(key); end + + def each(&block); end + + def empty?(); end + + def include?(key); end + + def initialize(array=T.unsafe(nil)); end + + def merge(values); end +end + +class RSpec::Core::Set +end + +module RSpec::Core::SharedContext + def __shared_context_recordings(); end + + def after(*args, &block); end + + def append_after(*args, &block); end + + def append_before(*args, &block); end + + def around(*args, &block); end + + def before(*args, &block); end + + def context(*args, &block); end + + def describe(*args, &block); end + + def hooks(*args, &block); end + + def included(group); end + + def let(*args, &block); end + + def let!(*args, &block); end + + def prepend_after(*args, &block); end + + def prepend_before(*args, &block); end + + def subject(*args, &block); end + + def subject!(*args, &block); end +end + +class RSpec::Core::SharedContext::Recording + def args(); end + + def args=(_); end + + def block(); end + + def block=(_); end + + def method_name(); end + + def method_name=(_); end + + def playback_onto(group); end +end + +class RSpec::Core::SharedContext::Recording + def self.[](*_); end + + def self.members(); end +end + +module RSpec::Core::SharedContext + def self.record(methods); end +end + +module RSpec::Core::SharedExampleGroup + def shared_context(name, *args, &block); end + + def shared_examples(name, *args, &block); end + + def shared_examples_for(name, *args, &block); end +end + +class RSpec::Core::SharedExampleGroup::Registry + def add(context, name, *metadata_args, &block); end + + def find(lookup_contexts, name); end +end + +class RSpec::Core::SharedExampleGroup::Registry +end + +module RSpec::Core::SharedExampleGroup::TopLevelDSL +end + +module RSpec::Core::SharedExampleGroup::TopLevelDSL + def self.definitions(); end + + def self.expose_globally!(); end + + def self.exposed_globally?(); end + + def self.remove_globally!(); end +end + +module RSpec::Core::SharedExampleGroup +end + +class RSpec::Core::SharedExampleGroupInclusionStackFrame + def description(); end + + def formatted_inclusion_location(); end + + def inclusion_location(); end + + def initialize(shared_group_name, inclusion_location); end + + def shared_group_name(); end +end + +class RSpec::Core::SharedExampleGroupInclusionStackFrame + def self.current_backtrace(); end + + def self.shared_example_group_inclusions(); end + + def self.with_frame(name, location); end +end + +class RSpec::Core::SharedExampleGroupModule + def definition(); end + + def include_in(klass, inclusion_line, args, customization_block); end + + def included(klass); end + + def initialize(description, definition, metadata); end +end + +class RSpec::Core::SharedExampleGroupModule +end + +module RSpec::Core::ShellEscape + SHELLS_ALLOWING_UNQUOTED_IDS = ::T.let(nil, ::T.untyped) +end + +module RSpec::Core::ShellEscape + def self.conditionally_quote(id); end + + def self.escape(shell_command); end + + def self.quote(argument); end + + def self.shell_allows_unquoted_ids?(); end +end + +class RSpec::Core::SuiteHookContext + def initialize(hook_description, reporter); end +end + +class RSpec::Core::SuiteHookContext +end + +class RSpec::Core::Time +end + +class RSpec::Core::Time + def self.now(); end +end + +module RSpec::Core::Version + STRING = ::T.let(nil, ::T.untyped) +end + +module RSpec::Core::Version +end + +module RSpec::Core::Warnings + def deprecate(deprecated, data=T.unsafe(nil)); end + + def warn_deprecation(message, opts=T.unsafe(nil)); end + + def warn_with(message, options=T.unsafe(nil)); end +end + +module RSpec::Core::Warnings +end + +class RSpec::Core::World + def all_example_groups(); end + + def all_examples(); end + + def announce_exclusion_filter(announcements); end + + def announce_filters(); end + + def announce_inclusion_filter(announcements); end + + def everything_filtered_message(); end + + def example_count(groups=T.unsafe(nil)); end + + def example_group_counts_by_spec_file(); end + + def example_groups(); end + + def exclusion_filter(); end + + def filter_manager(); end + + def filtered_examples(); end + + def inclusion_filter(); end + + def initialize(configuration=T.unsafe(nil)); end + + def non_example_failure(); end + + def non_example_failure=(non_example_failure); end + + def num_example_groups_defined_in(file); end + + def ordered_example_groups(); end + + def preceding_declaration_line(absolute_file_name, filter_line); end + + def prepare_example_filtering(); end + + def record(example_group); end + + def registered_example_group_files(); end + + def report_filter_message(message); end + + def reporter(); end + + def reset(); end + + def shared_example_group_registry(); end + + def source_from_file(path); end + + def syntax_highlighter(); end + + def traverse_example_group_trees_until(&block); end + + def wants_to_quit(); end + + def wants_to_quit=(wants_to_quit); end +end + +module RSpec::Core::World::Null +end + +module RSpec::Core::World::Null + def self.all_example_groups(); end + + def self.example_groups(); end + + def self.non_example_failure(); end + + def self.non_example_failure=(_); end + + def self.registered_example_group_files(); end + + def self.traverse_example_group_trees_until(); end +end + +class RSpec::Core::World +end + +module RSpec::Core + def self.path_to_executable(); end +end + +module RSpec::ExampleGroups +end + +module RSpec::ExampleGroups + extend ::RSpec::Support::RecursiveConstMethods + def self.assign_const(group); end + + def self.base_name_for(group); end + + def self.constant_scope_for(group); end + + def self.disambiguate(name, const_scope); end + + def self.remove_all_constants(); end +end + +module RSpec::Expectations +end + +class RSpec::Expectations::BlockExpectationTarget + def not_to(matcher, message=T.unsafe(nil), &block); end + + def to(matcher, message=T.unsafe(nil), &block); end + + def to_not(matcher, message=T.unsafe(nil), &block); end +end + +class RSpec::Expectations::BlockExpectationTarget +end + +class RSpec::Expectations::BlockSnippetExtractor + def body_content_lines(); end + + def initialize(proc, method_name); end + + def method_name(); end +end + +class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError +end + +class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError +end + +class RSpec::Expectations::BlockSnippetExtractor::BlockLocator + def beginning_line_number(); end + + def beginning_line_number=(_); end + + def body_content_locations(); end + + def method_call_location(); end + + def method_name(); end + + def method_name=(_); end + + def source(); end + + def source=(_); end +end + +class RSpec::Expectations::BlockSnippetExtractor::BlockLocator + def self.[](*_); end + + def self.members(); end +end + +class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor + def beginning_line_number(); end + + def beginning_line_number=(_); end + + def body_tokens(); end + + def method_name(); end + + def method_name=(_); end + + def source(); end + + def source=(_); end + + def state(); end +end + +class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor + def self.[](*_); end + + def self.members(); end +end + +class RSpec::Expectations::BlockSnippetExtractor::Error +end + +class RSpec::Expectations::BlockSnippetExtractor::Error +end + +class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError +end + +class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError +end + +class RSpec::Expectations::BlockSnippetExtractor + def self.try_extracting_single_line_body_of(proc, method_name); end +end + +class RSpec::Expectations::Configuration + def add_should_and_should_not_to(*modules); end + + def backtrace_formatter(); end + + def backtrace_formatter=(backtrace_formatter); end + + def color?(); end + + def false_positives_handler(); end + + def include_chain_clauses_in_custom_matcher_descriptions=(include_chain_clauses_in_custom_matcher_descriptions); end + + def include_chain_clauses_in_custom_matcher_descriptions?(); end + + def max_formatted_output_length=(length); end + + def on_potential_false_positives(); end + + def on_potential_false_positives=(behavior); end + + def reset_syntaxes_to_default(); end + + def syntax(); end + + def syntax=(values); end + + def warn_about_potential_false_positives=(boolean); end + + def warn_about_potential_false_positives?(); end + FALSE_POSITIVE_BEHAVIOURS = ::T.let(nil, ::T.untyped) +end + +module RSpec::Expectations::Configuration::NullBacktraceFormatter +end + +module RSpec::Expectations::Configuration::NullBacktraceFormatter + def self.format_backtrace(backtrace); end +end + +class RSpec::Expectations::Configuration +end + +module RSpec::Expectations::ExpectationHelper +end + +module RSpec::Expectations::ExpectationHelper + def self.check_message(msg); end + + def self.handle_failure(matcher, message, failure_message_method); end + + def self.modern_matcher_from(matcher); end + + def self.with_matcher(handler, matcher, message); end +end + +class RSpec::Expectations::ExpectationNotMetError +end + +class RSpec::Expectations::ExpectationNotMetError +end + +class RSpec::Expectations::ExpectationTarget + include ::RSpec::Expectations::ExpectationTarget::InstanceMethods + def initialize(value); end + + def target(); end +end + +module RSpec::Expectations::ExpectationTarget::InstanceMethods + def not_to(matcher=T.unsafe(nil), message=T.unsafe(nil), &block); end + + def to(matcher=T.unsafe(nil), message=T.unsafe(nil), &block); end + + def to_not(matcher=T.unsafe(nil), message=T.unsafe(nil), &block); end +end + +module RSpec::Expectations::ExpectationTarget::InstanceMethods +end + +module RSpec::Expectations::ExpectationTarget::UndefinedValue +end + +module RSpec::Expectations::ExpectationTarget::UndefinedValue +end + +class RSpec::Expectations::ExpectationTarget + def self.for(value, block); end +end + +class RSpec::Expectations::FailureAggregator + def aggregate(); end + + def block_label(); end + + def call(failure, options); end + + def failures(); end + + def initialize(block_label, metadata); end + + def metadata(); end + + def other_errors(); end +end + +class RSpec::Expectations::FailureAggregator +end + +RSpec::Expectations::LegacyMacherAdapter = RSpec::Expectations::LegacyMatcherAdapter + +class RSpec::Expectations::LegacyMatcherAdapter + def initialize(matcher); end +end + +class RSpec::Expectations::LegacyMatcherAdapter::RSpec1 + def failure_message(); end + + def failure_message_when_negated(); end +end + +class RSpec::Expectations::LegacyMatcherAdapter::RSpec1 + def self.interface_matches?(matcher); end +end + +class RSpec::Expectations::LegacyMatcherAdapter::RSpec2 + def failure_message(); end + + def failure_message_when_negated(); end +end + +class RSpec::Expectations::LegacyMatcherAdapter::RSpec2 + def self.interface_matches?(matcher); end +end + +class RSpec::Expectations::LegacyMatcherAdapter + def self.wrap(matcher); end +end + +class RSpec::Expectations::MultipleExpectationsNotMetError + def aggregation_block_label(); end + + def aggregation_metadata(); end + + def all_exceptions(); end + + def exception_count_description(); end + + def failures(); end + + def initialize(failure_aggregator); end + + def other_errors(); end + + def summary(); end +end + +class RSpec::Expectations::MultipleExpectationsNotMetError +end + +class RSpec::Expectations::NegativeExpectationHandler +end + +class RSpec::Expectations::NegativeExpectationHandler + def self.does_not_match?(matcher, actual, &block); end + + def self.handle_matcher(actual, initial_matcher, message=T.unsafe(nil), &block); end + + def self.opposite_should_method(); end + + def self.should_method(); end + + def self.verb(); end +end + +class RSpec::Expectations::PositiveExpectationHandler +end + +class RSpec::Expectations::PositiveExpectationHandler + def self.handle_matcher(actual, initial_matcher, message=T.unsafe(nil), &block); end + + def self.opposite_should_method(); end + + def self.should_method(); end + + def self.verb(); end +end + +module RSpec::Expectations::Syntax +end + +module RSpec::Expectations::Syntax + def self.default_should_host(); end + + def self.disable_expect(syntax_host=T.unsafe(nil)); end + + def self.disable_should(syntax_host=T.unsafe(nil)); end + + def self.enable_expect(syntax_host=T.unsafe(nil)); end + + def self.enable_should(syntax_host=T.unsafe(nil)); end + + def self.expect_enabled?(syntax_host=T.unsafe(nil)); end + + def self.should_enabled?(syntax_host=T.unsafe(nil)); end + + def self.warn_about_should!(); end + + def self.warn_about_should_unless_configured(method_name); end +end + +module RSpec::Expectations::Version + STRING = ::T.let(nil, ::T.untyped) +end + +module RSpec::Expectations::Version +end + +module RSpec::Expectations + def self.configuration(); end + + def self.differ(); end + + def self.fail_with(message, expected=T.unsafe(nil), actual=T.unsafe(nil)); end +end + +module RSpec::Matchers + def a_block_changing(*args, &block); end + + def a_block_outputting(*args, &block); end + + def a_block_raising(*args, &block); end + + def a_block_throwing(*args, &block); end + + def a_block_yielding_control(*args, &block); end + + def a_block_yielding_successive_args(*args, &block); end + + def a_block_yielding_with_args(*args, &block); end + + def a_block_yielding_with_no_args(*args, &block); end + + def a_collection_containing_exactly(*args, &block); end + + def a_collection_ending_with(*args, &block); end + + def a_collection_including(*args, &block); end + + def a_collection_starting_with(*args, &block); end + + def a_falsey_value(*args, &block); end + + def a_falsy_value(*args, &block); end + + def a_hash_including(*args, &block); end + + def a_kind_of(*args, &block); end + + def a_nil_value(*args, &block); end + + def a_range_covering(*args, &block); end + + def a_string_ending_with(*args, &block); end + + def a_string_including(*args, &block); end + + def a_string_matching(*args, &block); end + + def a_string_starting_with(*args, &block); end + + def a_truthy_value(*args, &block); end + + def a_value(*args, &block); end + + def a_value_between(*args, &block); end + + def a_value_within(*args, &block); end + + def aggregate_failures(label=T.unsafe(nil), metadata=T.unsafe(nil), &block); end + + def all(expected); end + + def an_instance_of(*args, &block); end + + def an_object_eq_to(*args, &block); end + + def an_object_eql_to(*args, &block); end + + def an_object_equal_to(*args, &block); end + + def an_object_existing(*args, &block); end + + def an_object_having_attributes(*args, &block); end + + def an_object_matching(*args, &block); end + + def an_object_responding_to(*args, &block); end + + def an_object_satisfying(*args, &block); end + + def be(*args); end + + def be_a(klass); end + + def be_a_kind_of(expected); end + + def be_an(klass); end + + def be_an_instance_of(expected); end + + def be_between(min, max); end + + def be_falsey(); end + + def be_falsy(*args, &block); end + + def be_instance_of(expected); end + + def be_kind_of(expected); end + + def be_nil(); end + + def be_truthy(); end + + def be_within(delta); end + + def change(receiver=T.unsafe(nil), message=T.unsafe(nil), &block); end + + def changing(*args, &block); end + + def contain_exactly(*items); end + + def containing_exactly(*args, &block); end + + def cover(*values); end + + def covering(*args, &block); end + + def end_with(*expected); end + + def ending_with(*args, &block); end + + def eq(expected); end + + def eq_to(*args, &block); end + + def eql(expected); end + + def eql_to(*args, &block); end + + def equal(expected); end + + def equal_to(*args, &block); end + + def exist(*args); end + + def existing(*args, &block); end + + def expect(value=T.unsafe(nil), &block); end + + def have_attributes(expected); end + + def having_attributes(*args, &block); end + + def include(*expected); end + + def including(*args, &block); end + + def match(expected); end + + def match_array(items); end + + def match_regex(*args, &block); end + + def matching(*args, &block); end + + def output(expected=T.unsafe(nil)); end + + def raise_error(error=T.unsafe(nil), message=T.unsafe(nil), &block); end + + def raise_exception(error=T.unsafe(nil), message=T.unsafe(nil), &block); end + + def raising(*args, &block); end + + def respond_to(*names); end + + def responding_to(*args, &block); end + + def satisfy(description=T.unsafe(nil), &block); end + + def satisfying(*args, &block); end + + def start_with(*expected); end + + def starting_with(*args, &block); end + + def throw_symbol(expected_symbol=T.unsafe(nil), expected_arg=T.unsafe(nil)); end + + def throwing(*args, &block); end + + def within(*args, &block); end + + def yield_control(); end + + def yield_successive_args(*args); end + + def yield_with_args(*args); end + + def yield_with_no_args(); end + + def yielding_control(*args, &block); end + + def yielding_successive_args(*args, &block); end + + def yielding_with_args(*args, &block); end + + def yielding_with_no_args(*args, &block); end + BE_PREDICATE_REGEX = ::T.let(nil, ::T.untyped) + DYNAMIC_MATCHER_REGEX = ::T.let(nil, ::T.untyped) + HAS_REGEX = ::T.let(nil, ::T.untyped) +end + +class RSpec::Matchers::AliasedMatcher + def description(); end + + def failure_message(); end + + def failure_message_when_negated(); end + + def initialize(base_matcher, description_block); end + + def method_missing(*_); end +end + +class RSpec::Matchers::AliasedMatcher +end + +class RSpec::Matchers::AliasedMatcherWithOperatorSupport +end + +class RSpec::Matchers::AliasedMatcherWithOperatorSupport +end + +class RSpec::Matchers::AliasedNegatedMatcher + def does_not_match?(*args, &block); end + + def matches?(*args, &block); end +end + +RSpec::Matchers::AliasedNegatedMatcher::DefaultFailureMessages = RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages + +class RSpec::Matchers::AliasedNegatedMatcher +end + +module RSpec::Matchers::BuiltIn +end + +class RSpec::Matchers::BuiltIn::All + def does_not_match?(_actual); end + + def failed_objects(); end + + def initialize(matcher); end + + def matcher(); end +end + +class RSpec::Matchers::BuiltIn::All +end + +class RSpec::Matchers::BuiltIn::BaseMatcher + include ::RSpec::Matchers::Composable + include ::RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting + include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages + def actual(); end + + def actual_formatted(); end + + def description(); end + + def diffable?(); end + + def expected(); end + + def expected_formatted(); end + + def expects_call_stack_jump?(); end + + def initialize(expected=T.unsafe(nil)); end + + def match_unless_raises(*exceptions); end + + def matcher_name(); end + + def matcher_name=(matcher_name); end + + def matches?(actual); end + + def present_ivars(); end + + def rescued_exception(); end + + def supports_block_expectations?(); end + UNDEFINED = ::T.let(nil, ::T.untyped) +end + +module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages + def failure_message(); end + + def failure_message_when_negated(); end +end + +module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages + def self.has_default_failure_messages?(matcher); end +end + +module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting +end + +module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting + def self.improve_hash_formatting(inspect_string); end +end + +class RSpec::Matchers::BuiltIn::BaseMatcher + def self.matcher_name(); end +end + +class RSpec::Matchers::BuiltIn::Be + include ::RSpec::Matchers::BuiltIn::BeHelpers + def <(operand); end + + def <=(operand); end + + def ==(operand); end + + def ===(operand); end + + def =~(operand); end + + def >(operand); end + + def >=(operand); end + + def initialize(*args); end +end + +class RSpec::Matchers::BuiltIn::Be +end + +class RSpec::Matchers::BuiltIn::BeAKindOf +end + +class RSpec::Matchers::BuiltIn::BeAKindOf +end + +class RSpec::Matchers::BuiltIn::BeAnInstanceOf +end + +class RSpec::Matchers::BuiltIn::BeAnInstanceOf +end + +class RSpec::Matchers::BuiltIn::BeBetween + def exclusive(); end + + def inclusive(); end + + def initialize(min, max); end +end + +class RSpec::Matchers::BuiltIn::BeBetween +end + +class RSpec::Matchers::BuiltIn::BeComparedTo + include ::RSpec::Matchers::BuiltIn::BeHelpers + def initialize(operand, operator); end +end + +class RSpec::Matchers::BuiltIn::BeComparedTo +end + +class RSpec::Matchers::BuiltIn::BeFalsey +end + +class RSpec::Matchers::BuiltIn::BeFalsey +end + +module RSpec::Matchers::BuiltIn::BeHelpers +end + +module RSpec::Matchers::BuiltIn::BeHelpers +end + +class RSpec::Matchers::BuiltIn::BeNil +end + +class RSpec::Matchers::BuiltIn::BeNil +end + +class RSpec::Matchers::BuiltIn::BePredicate + include ::RSpec::Matchers::BuiltIn::BeHelpers + def does_not_match?(actual, &block); end + + def initialize(*args, &block); end + + def matches?(actual, &block); end +end + +class RSpec::Matchers::BuiltIn::BePredicate +end + +class RSpec::Matchers::BuiltIn::BeTruthy +end + +class RSpec::Matchers::BuiltIn::BeTruthy +end + +class RSpec::Matchers::BuiltIn::BeWithin + def initialize(delta); end + + def of(expected); end + + def percent_of(expected); end +end + +class RSpec::Matchers::BuiltIn::BeWithin +end + +module RSpec::Matchers::BuiltIn::CaptureStderr +end + +module RSpec::Matchers::BuiltIn::CaptureStderr + def self.capture(block); end +end + +module RSpec::Matchers::BuiltIn::CaptureStdout +end + +module RSpec::Matchers::BuiltIn::CaptureStdout + def self.capture(block); end +end + +class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile + def capture(block); end +end + +class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile +end + +class RSpec::Matchers::BuiltIn::Change + def by(expected_delta); end + + def by_at_least(minimum); end + + def by_at_most(maximum); end + + def does_not_match?(event_proc); end + + def from(value); end + + def initialize(receiver=T.unsafe(nil), message=T.unsafe(nil), &block); end + + def matches?(event_proc); end + + def to(value); end +end + +class RSpec::Matchers::BuiltIn::Change +end + +class RSpec::Matchers::BuiltIn::ChangeDetails + def actual_after(); end + + def actual_delta(); end + + def changed?(); end + + def initialize(matcher_name, receiver=T.unsafe(nil), message=T.unsafe(nil), &block); end + + def perform_change(event_proc); end + + def value_representation(); end +end + +class RSpec::Matchers::BuiltIn::ChangeDetails +end + +class RSpec::Matchers::BuiltIn::ChangeFromValue + def does_not_match?(event_proc); end + + def initialize(change_details, expected_before); end + + def to(value); end +end + +class RSpec::Matchers::BuiltIn::ChangeFromValue +end + +class RSpec::Matchers::BuiltIn::ChangeRelatively + def does_not_match?(_event_proc); end + + def initialize(change_details, expected_delta, relativity, &comparer); end + + def matches?(event_proc); end +end + +class RSpec::Matchers::BuiltIn::ChangeRelatively +end + +class RSpec::Matchers::BuiltIn::ChangeToValue + def does_not_match?(_event_proc); end + + def from(value); end + + def initialize(change_details, expected_after); end +end + +class RSpec::Matchers::BuiltIn::ChangeToValue +end + +class RSpec::Matchers::BuiltIn::Compound + def diffable_matcher_list(); end + + def does_not_match?(_actual); end + + def evaluator(); end + + def initialize(matcher_1, matcher_2); end + + def matcher_1(); end + + def matcher_2(); end +end + +class RSpec::Matchers::BuiltIn::Compound::And +end + +class RSpec::Matchers::BuiltIn::Compound::And +end + +class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator + def initialize(actual, matcher_1, matcher_2); end + + def matcher_matches?(matcher); end +end + +class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator + def self.matcher_expects_call_stack_jump?(matcher); end +end + +class RSpec::Matchers::BuiltIn::Compound::Or +end + +class RSpec::Matchers::BuiltIn::Compound::Or +end + +class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator + def initialize(actual, *_); end + + def matcher_matches?(matcher); end +end + +class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator +end + +class RSpec::Matchers::BuiltIn::Compound +end + +class RSpec::Matchers::BuiltIn::ContainExactly +end + +class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer + def actual_to_expected_matched_indexes(); end + + def expected_to_actual_matched_indexes(); end + + def find_best_solution(); end + + def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes); end + + def solution(); end +end + +class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution +end + +class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution + def self.worse_than?(_other); end +end + +class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution + def +(derived_candidate_solution); end + + def candidate?(); end + + def ideal?(); end + + def indeterminate_actual_indexes(); end + + def indeterminate_actual_indexes=(_); end + + def indeterminate_expected_indexes(); end + + def indeterminate_expected_indexes=(_); end + + def unmatched_actual_indexes(); end + + def unmatched_actual_indexes=(_); end + + def unmatched_expected_indexes(); end + + def unmatched_expected_indexes=(_); end + + def unmatched_item_count(); end + + def worse_than?(other); end +end + +class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution + def self.[](*_); end + + def self.members(); end +end + +class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer +end + +class RSpec::Matchers::BuiltIn::ContainExactly +end + +class RSpec::Matchers::BuiltIn::Cover + def does_not_match?(range); end + + def initialize(*expected); end + + def matches?(range); end +end + +class RSpec::Matchers::BuiltIn::Cover +end + +class RSpec::Matchers::BuiltIn::EndWith +end + +class RSpec::Matchers::BuiltIn::EndWith +end + +class RSpec::Matchers::BuiltIn::Eq +end + +class RSpec::Matchers::BuiltIn::Eq +end + +class RSpec::Matchers::BuiltIn::Eql +end + +class RSpec::Matchers::BuiltIn::Eql +end + +class RSpec::Matchers::BuiltIn::Equal + LITERAL_SINGLETONS = ::T.let(nil, ::T.untyped) +end + +class RSpec::Matchers::BuiltIn::Equal +end + +class RSpec::Matchers::BuiltIn::Exist + def does_not_match?(actual); end + + def initialize(*expected); end +end + +class RSpec::Matchers::BuiltIn::Exist::ExistenceTest + def actual_exists?(); end + + def valid_test?(); end + + def validity_message(); end +end + +class RSpec::Matchers::BuiltIn::Exist::ExistenceTest +end + +class RSpec::Matchers::BuiltIn::Exist +end + +class RSpec::Matchers::BuiltIn::Has + def does_not_match?(actual, &block); end + + def initialize(method_name, *args, &block); end + + def matches?(actual, &block); end +end + +class RSpec::Matchers::BuiltIn::Has +end + +class RSpec::Matchers::BuiltIn::HaveAttributes + def does_not_match?(actual); end + + def initialize(expected); end + + def respond_to_failed(); end +end + +class RSpec::Matchers::BuiltIn::HaveAttributes +end + +class RSpec::Matchers::BuiltIn::Include + def does_not_match?(actual); end + + def expecteds(); end + + def initialize(*expecteds); end +end + +class RSpec::Matchers::BuiltIn::Include +end + +class RSpec::Matchers::BuiltIn::Match + def initialize(expected); end + + def with_captures(*captures); end +end + +class RSpec::Matchers::BuiltIn::Match +end + +class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher + def __delegate_operator(actual, operator, expected); end +end + +class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher +end + +module RSpec::Matchers::BuiltIn::NullCapture +end + +module RSpec::Matchers::BuiltIn::NullCapture + def self.capture(_block); end +end + +class RSpec::Matchers::BuiltIn::OperatorMatcher + def !=(_expected); end + + def !~(_expected); end + + def <(expected); end + + def <=(expected); end + + def ==(expected); end + + def ===(expected); end + + def =~(expected); end + + def >(expected); end + + def >=(expected); end + + def description(); end + + def fail_with_message(message); end + + def initialize(actual); end +end + +class RSpec::Matchers::BuiltIn::OperatorMatcher + def self.get(klass, operator); end + + def self.register(klass, operator, matcher); end + + def self.registry(); end + + def self.unregister(klass, operator); end + + def self.use_custom_matcher_or_delegate(operator); end +end + +class RSpec::Matchers::BuiltIn::Output + def does_not_match?(block); end + + def initialize(expected); end + + def matches?(block); end + + def to_stderr(); end + + def to_stderr_from_any_process(); end + + def to_stdout(); end + + def to_stdout_from_any_process(); end +end + +class RSpec::Matchers::BuiltIn::Output +end + +class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher + def __delegate_operator(actual, operator, expected); end +end + +class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher +end + +class RSpec::Matchers::BuiltIn::RaiseError + include ::RSpec::Matchers::Composable + def description(); end + + def does_not_match?(given_proc); end + + def expects_call_stack_jump?(); end + + def failure_message(); end + + def failure_message_when_negated(); end + + def initialize(expected_error_or_message=T.unsafe(nil), expected_message=T.unsafe(nil), &block); end + + def matches?(given_proc, negative_expectation=T.unsafe(nil), &block); end + + def supports_block_expectations?(); end + + def with_message(expected_message); end +end + +class RSpec::Matchers::BuiltIn::RaiseError +end + +class RSpec::Matchers::BuiltIn::ReliableMatchData + def captures(); end + + def initialize(match_data); end + + def match_data(); end + + def names(); end +end + +class RSpec::Matchers::BuiltIn::ReliableMatchData +end + +class RSpec::Matchers::BuiltIn::RespondTo + def and_any_keywords(); end + + def and_keywords(*keywords); end + + def and_unlimited_arguments(); end + + def argument(); end + + def arguments(); end + + def does_not_match?(actual); end + + def ignoring_method_signature_failure!(); end + + def initialize(*names); end + + def with(n); end + + def with_any_keywords(); end + + def with_keywords(*keywords); end + + def with_unlimited_arguments(); end +end + +class RSpec::Matchers::BuiltIn::RespondTo +end + +class RSpec::Matchers::BuiltIn::Satisfy + def initialize(description=T.unsafe(nil), &block); end + + def matches?(actual, &block); end +end + +class RSpec::Matchers::BuiltIn::Satisfy +end + +class RSpec::Matchers::BuiltIn::SpecificValuesChange + def initialize(change_details, from, to); end + + def matches?(event_proc); end +end + +RSpec::Matchers::BuiltIn::SpecificValuesChange::MATCH_ANYTHING = BasicObject + +class RSpec::Matchers::BuiltIn::SpecificValuesChange +end + +RSpec::Matchers::BuiltIn::StartAndEndWith = RSpec::Matchers::BuiltIn::StartOrEndWith + +class RSpec::Matchers::BuiltIn::StartOrEndWith + def initialize(*expected); end +end + +class RSpec::Matchers::BuiltIn::StartOrEndWith +end + +class RSpec::Matchers::BuiltIn::StartWith +end + +class RSpec::Matchers::BuiltIn::StartWith +end + +class RSpec::Matchers::BuiltIn::ThrowSymbol + include ::RSpec::Matchers::Composable + def description(); end + + def does_not_match?(given_proc); end + + def expects_call_stack_jump?(); end + + def failure_message(); end + + def failure_message_when_negated(); end + + def initialize(expected_symbol=T.unsafe(nil), expected_arg=T.unsafe(nil)); end + + def matches?(given_proc); end + + def supports_block_expectations?(); end +end + +class RSpec::Matchers::BuiltIn::ThrowSymbol +end + +class RSpec::Matchers::BuiltIn::YieldControl + def at_least(number); end + + def at_most(number); end + + def does_not_match?(block); end + + def exactly(number); end + + def initialize(); end + + def matches?(block); end + + def once(); end + + def thrice(); end + + def times(); end + + def twice(); end +end + +class RSpec::Matchers::BuiltIn::YieldControl +end + +class RSpec::Matchers::BuiltIn::YieldProbe + def assert_used!(); end + + def assert_valid_expect_block!(); end + + def has_block?(); end + + def initialize(block, &callback); end + + def num_yields(); end + + def num_yields=(num_yields); end + + def probe(); end + + def single_yield_args(); end + + def to_proc(); end + + def yielded_args(); end + + def yielded_args=(yielded_args); end + + def yielded_once?(matcher_name); end +end + +class RSpec::Matchers::BuiltIn::YieldProbe + def self.probe(block, &callback); end +end + +class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs + def does_not_match?(block); end + + def initialize(*args); end + + def matches?(block); end +end + +class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs +end + +class RSpec::Matchers::BuiltIn::YieldWithArgs + def does_not_match?(block); end + + def initialize(*args); end + + def matches?(block); end +end + +class RSpec::Matchers::BuiltIn::YieldWithArgs +end + +class RSpec::Matchers::BuiltIn::YieldWithNoArgs + def does_not_match?(block); end + + def matches?(block); end +end + +class RSpec::Matchers::BuiltIn::YieldWithNoArgs +end + +module RSpec::Matchers::BuiltIn +end + +module RSpec::Matchers::Composable + def &(matcher); end + + def ===(value); end + + def and(matcher); end + + def or(matcher); end + + def |(matcher); end +end + +module RSpec::Matchers::Composable + def self.should_enumerate?(item); end + + def self.surface_descriptions_in(item); end + + def self.unreadable_io?(object); end +end + +module RSpec::Matchers::DSL + def alias_matcher(new_name, old_name, options=T.unsafe(nil), &description_override); end + + def define(name, &declarations); end + + def define_negated_matcher(negated_name, base_name, &description_override); end + + def matcher(name, &declarations); end +end + +module RSpec::Matchers::DSL::DefaultImplementations + include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages + def description(); end + + def diffable?(); end + + def expects_call_stack_jump?(); end + + def supports_block_expectations?(); end +end + +module RSpec::Matchers::DSL::DefaultImplementations +end + +module RSpec::Matchers::DSL::Macros + def chain(method_name, *attr_names, &definition); end + + def description(&definition); end + + def diffable(); end + + def failure_message(&definition); end + + def failure_message_when_negated(&definition); end + + def match(options=T.unsafe(nil), &match_block); end + + def match_unless_raises(expected_exception=T.unsafe(nil), &match_block); end + + def match_when_negated(options=T.unsafe(nil), &match_block); end + + def supports_block_expectations(); end + RAISE_NOTIFIER = ::T.let(nil, ::T.untyped) +end + +module RSpec::Matchers::DSL::Macros::Deprecated + def failure_message_for_should(&definition); end + + def failure_message_for_should_not(&definition); end + + def match_for_should(&definition); end + + def match_for_should_not(&definition); end +end + +module RSpec::Matchers::DSL::Macros::Deprecated +end + +module RSpec::Matchers::DSL::Macros +end + +class RSpec::Matchers::DSL::Matcher + include ::RSpec::Matchers::DSL::DefaultImplementations + include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages + include ::RSpec::Matchers + include ::RSpec::Matchers::Composable + def actual(); end + + def block_arg(); end + + def expected(); end + + def expected_as_array(); end + + def initialize(name, declarations, matcher_execution_context, *expected, &block_arg); end + + def name(); end + + def rescued_exception(); end +end + +class RSpec::Matchers::DSL::Matcher + extend ::RSpec::Matchers::DSL::Macros + extend ::RSpec::Matchers::DSL::Macros::Deprecated +end + +module RSpec::Matchers::DSL +end + +module RSpec::Matchers::EnglishPhrasing +end + +module RSpec::Matchers::EnglishPhrasing + def self.list(obj); end + + def self.split_words(sym); end +end + +class RSpec::Matchers::ExpectedsForMultipleDiffs + def initialize(expected_list); end + + def message_with_diff(message, differ, actual); end + DEFAULT_DIFF_LABEL = ::T.let(nil, ::T.untyped) + DESCRIPTION_MAX_LENGTH = ::T.let(nil, ::T.untyped) +end + +class RSpec::Matchers::ExpectedsForMultipleDiffs + def self.for_many_matchers(matchers); end + + def self.from(expected); end +end + +class RSpec::Matchers::MatcherDelegator + include ::RSpec::Matchers::Composable + def base_matcher(); end + + def initialize(base_matcher); end + + def method_missing(*args, &block); end +end + +class RSpec::Matchers::MatcherDelegator +end + +module RSpec::Matchers + extend ::RSpec::Matchers::DSL + def self.alias_matcher(*args, &block); end + + def self.clear_generated_description(); end + + def self.configuration(); end + + def self.generated_description(); end + + def self.is_a_describable_matcher?(obj); end + + def self.is_a_matcher?(obj); end + + def self.last_description(); end + + def self.last_expectation_handler(); end + + def self.last_expectation_handler=(last_expectation_handler); end + + def self.last_matcher(); end + + def self.last_matcher=(last_matcher); end +end + +module RSpec::Mocks + DEFAULT_CALLBACK_INVOCATION_STRATEGY = ::T.let(nil, ::T.untyped) + IGNORED_BACKTRACE_LINE = ::T.let(nil, ::T.untyped) +end + +class RSpec::Mocks::AllowanceTarget + def expression(); end + + def not_to(matcher, *_args); end + + def to(matcher, &block); end + + def to_not(matcher, *_args); end +end + +class RSpec::Mocks::AllowanceTarget +end + +class RSpec::Mocks::AndReturnImplementation + def call(*_args_to_ignore, &_block); end + + def initialize(values_to_return); end +end + +class RSpec::Mocks::AndReturnImplementation +end + +class RSpec::Mocks::AndWrapOriginalImplementation + def call(*args, &block); end + + def initial_action=(_value); end + + def initialize(method, block); end + + def inner_action(); end + + def inner_action=(_value); end + + def present?(); end + + def terminal_action=(_value); end +end + +class RSpec::Mocks::AndWrapOriginalImplementation::CannotModifyFurtherError +end + +class RSpec::Mocks::AndWrapOriginalImplementation::CannotModifyFurtherError +end + +class RSpec::Mocks::AndWrapOriginalImplementation +end + +class RSpec::Mocks::AndYieldImplementation + def call(*_args_to_ignore, &block); end + + def initialize(args_to_yield, eval_context, error_generator); end +end + +class RSpec::Mocks::AndYieldImplementation +end + +module RSpec::Mocks::AnyInstance +end + +class RSpec::Mocks::AnyInstance::Chain + include ::RSpec::Mocks::AnyInstance::Chain::Customizations + def constrained_to_any_of?(*constraints); end + + def expectation_fulfilled!(); end + + def initialize(recorder, *args, &block); end + + def matches_args?(*args); end + + def never(); end + + def playback!(instance); end +end + +module RSpec::Mocks::AnyInstance::Chain::Customizations + def and_call_original(*args, &block); end + + def and_raise(*args, &block); end + + def and_return(*args, &block); end + + def and_throw(*args, &block); end + + def and_wrap_original(*args, &block); end + + def and_yield(*args, &block); end + + def at_least(*args, &block); end + + def at_most(*args, &block); end + + def exactly(*args, &block); end + + def never(*args, &block); end + + def once(*args, &block); end + + def thrice(*args, &block); end + + def time(*args, &block); end + + def times(*args, &block); end + + def twice(*args, &block); end + + def with(*args, &block); end +end + +module RSpec::Mocks::AnyInstance::Chain::Customizations + def self.record(method_name); end +end + +class RSpec::Mocks::AnyInstance::Chain +end + +class RSpec::Mocks::AnyInstance::ErrorGenerator + def raise_does_not_implement_error(klass, method_name); end + + def raise_message_already_received_by_other_instance_error(method_name, object_inspect, invoked_instance); end + + def raise_not_supported_with_prepend_error(method_name, problem_mod); end + + def raise_second_instance_received_message_error(unfulfilled_expectations); end +end + +class RSpec::Mocks::AnyInstance::ErrorGenerator +end + +class RSpec::Mocks::AnyInstance::ExpectChainChain + def initialize(*args); end +end + +class RSpec::Mocks::AnyInstance::ExpectChainChain +end + +class RSpec::Mocks::AnyInstance::ExpectationChain + def expectation_fulfilled?(); end + + def initialize(*args, &block); end +end + +class RSpec::Mocks::AnyInstance::ExpectationChain +end + +class RSpec::Mocks::AnyInstance::FluentInterfaceProxy + def initialize(targets); end + + def method_missing(*args, &block); end +end + +class RSpec::Mocks::AnyInstance::FluentInterfaceProxy +end + +class RSpec::Mocks::AnyInstance::MessageChains + def [](method_name); end + + def add(method_name, chain); end + + def all_expectations_fulfilled?(); end + + def each_unfulfilled_expectation_matching(method_name, *args); end + + def has_expectation?(method_name); end + + def playback!(instance, method_name); end + + def received_expected_message!(method_name); end + + def remove_stub_chains_for!(method_name); end + + def unfulfilled_expectations(); end +end + +class RSpec::Mocks::AnyInstance::MessageChains +end + +class RSpec::Mocks::AnyInstance::PositiveExpectationChain + ExpectationInvocationOrder = ::T.let(nil, ::T.untyped) +end + +class RSpec::Mocks::AnyInstance::PositiveExpectationChain +end + +class RSpec::Mocks::AnyInstance::Proxy + def expect_chain(*chain, &block); end + + def initialize(recorder, target_proxies); end + + def klass(); end + + def should_not_receive(method_name, &block); end + + def should_receive(method_name, &block); end + + def stub(method_name_or_method_map, &block); end + + def stub_chain(*chain, &block); end + + def unstub(method_name); end +end + +class RSpec::Mocks::AnyInstance::Proxy +end + +class RSpec::Mocks::AnyInstance::Recorder + def already_observing?(method_name); end + + def build_alias_method_name(method_name); end + + def expect_chain(*method_names_and_optional_return_values, &block); end + + def initialize(klass); end + + def instance_that_received(method_name); end + + def klass(); end + + def message_chains(); end + + def notify_received_message(_object, message, args, _blk); end + + def playback!(instance, method_name); end + + def should_not_receive(method_name, &block); end + + def should_receive(method_name, &block); end + + def stop_all_observation!(); end + + def stop_observing!(method_name); end + + def stub(method_name, &block); end + + def stub_chain(*method_names_and_optional_return_values, &block); end + + def stubs(); end + + def unstub(method_name); end + + def verify(); end +end + +class RSpec::Mocks::AnyInstance::Recorder +end + +class RSpec::Mocks::AnyInstance::StubChain + def expectation_fulfilled?(); end + EmptyInvocationOrder = ::T.let(nil, ::T.untyped) + InvocationOrder = ::T.let(nil, ::T.untyped) +end + +class RSpec::Mocks::AnyInstance::StubChain +end + +class RSpec::Mocks::AnyInstance::StubChainChain + def initialize(*args); end +end + +class RSpec::Mocks::AnyInstance::StubChainChain +end + +module RSpec::Mocks::AnyInstance + def self.error_generator(); end +end + +class RSpec::Mocks::AnyInstanceAllowanceTarget + def expression(); end + + def not_to(matcher, *_args); end + + def to(matcher, &block); end + + def to_not(matcher, *_args); end +end + +class RSpec::Mocks::AnyInstanceAllowanceTarget +end + +class RSpec::Mocks::AnyInstanceExpectationTarget + def expression(); end + + def not_to(matcher, &block); end + + def to(matcher, &block); end + + def to_not(matcher, &block); end +end + +class RSpec::Mocks::AnyInstanceExpectationTarget +end + +class RSpec::Mocks::ArgumentListMatcher + def args_match?(*args); end + + def expected_args(); end + + def initialize(*expected_args); end + + def resolve_expected_args_based_on(actual_args); end + MATCH_ALL = ::T.let(nil, ::T.untyped) +end + +class RSpec::Mocks::ArgumentListMatcher +end + +module RSpec::Mocks::ArgumentMatchers + def a_kind_of(klass); end + + def an_instance_of(klass); end + + def any_args(); end + + def anything(); end + + def array_including(*args); end + + def boolean(); end + + def duck_type(*args); end + + def hash_excluding(*args); end + + def hash_including(*args); end + + def hash_not_including(*args); end + + def instance_of(klass); end + + def kind_of(klass); end + + def no_args(); end +end + +class RSpec::Mocks::ArgumentMatchers::AnyArgMatcher + def ===(_other); end + + def description(); end + INSTANCE = ::T.let(nil, ::T.untyped) +end + +class RSpec::Mocks::ArgumentMatchers::AnyArgMatcher +end + +class RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher + def description(); end + INSTANCE = ::T.let(nil, ::T.untyped) +end + +class RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher +end + +class RSpec::Mocks::ArgumentMatchers::ArrayIncludingMatcher + def ===(actual); end + + def description(); end + + def initialize(expected); end +end + +class RSpec::Mocks::ArgumentMatchers::ArrayIncludingMatcher +end + +class RSpec::Mocks::ArgumentMatchers::BaseHashMatcher + def ===(predicate, actual); end + + def description(name); end + + def initialize(expected); end +end + +class RSpec::Mocks::ArgumentMatchers::BaseHashMatcher +end + +class RSpec::Mocks::ArgumentMatchers::BooleanMatcher + def ===(value); end + + def description(); end + INSTANCE = ::T.let(nil, ::T.untyped) +end + +class RSpec::Mocks::ArgumentMatchers::BooleanMatcher +end + +class RSpec::Mocks::ArgumentMatchers::DuckTypeMatcher + def ===(value); end + + def description(); end + + def initialize(*methods_to_respond_to); end +end + +class RSpec::Mocks::ArgumentMatchers::DuckTypeMatcher +end + +class RSpec::Mocks::ArgumentMatchers::HashExcludingMatcher + def ===(actual); end + + def description(); end +end + +class RSpec::Mocks::ArgumentMatchers::HashExcludingMatcher +end + +class RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher + def ===(actual); end + + def description(); end +end + +class RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher +end + +class RSpec::Mocks::ArgumentMatchers::InstanceOf + def ===(actual); end + + def description(); end + + def initialize(klass); end +end + +class RSpec::Mocks::ArgumentMatchers::InstanceOf +end + +class RSpec::Mocks::ArgumentMatchers::KindOf + def ===(actual); end + + def description(); end + + def initialize(klass); end +end + +class RSpec::Mocks::ArgumentMatchers::KindOf +end + +class RSpec::Mocks::ArgumentMatchers::NoArgsMatcher + def description(); end + INSTANCE = ::T.let(nil, ::T.untyped) +end + +class RSpec::Mocks::ArgumentMatchers::NoArgsMatcher +end + +class RSpec::Mocks::ArgumentMatchers::SingletonMatcher +end + +class RSpec::Mocks::ArgumentMatchers::SingletonMatcher + def self.inherited(subklass); end +end + +module RSpec::Mocks::ArgumentMatchers + def self.anythingize_lonely_keys(*args); end +end + +class RSpec::Mocks::CallbackInvocationStrategy + def call(doubled_module); end +end + +class RSpec::Mocks::CallbackInvocationStrategy +end + +class RSpec::Mocks::CannotSupportArgMutationsError +end + +class RSpec::Mocks::CannotSupportArgMutationsError +end + +class RSpec::Mocks::ClassNewMethodReference +end + +class RSpec::Mocks::ClassNewMethodReference + def self.applies_to?(method_name); end +end + +class RSpec::Mocks::ClassVerifyingDouble + include ::RSpec::Mocks::ObjectVerifyingDoubleMethods + include ::RSpec::Mocks::TestDouble + include ::RSpec::Mocks::VerifyingDouble +end + +class RSpec::Mocks::ClassVerifyingDouble +end + +class RSpec::Mocks::Configuration + def add_stub_and_should_receive_to(*modules); end + + def allow_message_expectations_on_nil(); end + + def allow_message_expectations_on_nil=(allow_message_expectations_on_nil); end + + def before_verifying_doubles(&block); end + + def color?(); end + + def patch_marshal_to_support_partial_doubles=(val); end + + def reset_syntaxes_to_default(); end + + def syntax(); end + + def syntax=(*values); end + + def temporarily_suppress_partial_double_verification(); end + + def temporarily_suppress_partial_double_verification=(temporarily_suppress_partial_double_verification); end + + def transfer_nested_constants=(transfer_nested_constants); end + + def transfer_nested_constants?(); end + + def verify_doubled_constant_names=(verify_doubled_constant_names); end + + def verify_doubled_constant_names?(); end + + def verify_partial_doubles=(val); end + + def verify_partial_doubles?(); end + + def verifying_double_callbacks(); end + + def when_declaring_verifying_double(&block); end + + def yield_receiver_to_any_instance_implementation_blocks=(yield_receiver_to_any_instance_implementation_blocks); end + + def yield_receiver_to_any_instance_implementation_blocks?(); end +end + +class RSpec::Mocks::Configuration +end + +class RSpec::Mocks::Constant + def hidden=(hidden); end + + def hidden?(); end + + def initialize(name); end + + def mutated?(); end + + def name(); end + + def original_value(); end + + def original_value=(original_value); end + + def previously_defined=(previously_defined); end + + def previously_defined?(); end + + def stubbed=(stubbed); end + + def stubbed?(); end + + def valid_name=(valid_name); end + + def valid_name?(); end +end + +class RSpec::Mocks::Constant + extend ::RSpec::Support::RecursiveConstMethods + def self.original(name); end + + def self.unmutated(name); end +end + +class RSpec::Mocks::ConstantMutator +end + +class RSpec::Mocks::ConstantMutator::BaseMutator + include ::RSpec::Support::RecursiveConstMethods + def full_constant_name(); end + + def idempotently_reset(); end + + def initialize(full_constant_name, mutated_value, transfer_nested_constants); end + + def original_value(); end + + def to_constant(); end +end + +class RSpec::Mocks::ConstantMutator::BaseMutator +end + +class RSpec::Mocks::ConstantMutator::ConstantHider + def mutate(); end + + def reset(); end +end + +class RSpec::Mocks::ConstantMutator::ConstantHider +end + +class RSpec::Mocks::ConstantMutator::DefinedConstantReplacer + def initialize(*args); end + + def mutate(); end + + def reset(); end + + def should_transfer_nested_constants?(); end + + def transfer_nested_constants(); end + + def verify_constants_to_transfer!(); end +end + +class RSpec::Mocks::ConstantMutator::DefinedConstantReplacer +end + +class RSpec::Mocks::ConstantMutator::UndefinedConstantSetter + def mutate(); end + + def reset(); end +end + +class RSpec::Mocks::ConstantMutator::UndefinedConstantSetter +end + +class RSpec::Mocks::ConstantMutator + extend ::RSpec::Support::RecursiveConstMethods + def self.hide(constant_name); end + + def self.mutate(mutator); end + + def self.raise_on_invalid_const(); end + + def self.stub(constant_name, value, options=T.unsafe(nil)); end +end + +class RSpec::Mocks::DirectObjectReference + def const_to_replace(); end + + def defined?(); end + + def description(); end + + def initialize(object); end + + def target(); end + + def when_loaded(); end +end + +class RSpec::Mocks::DirectObjectReference +end + +class RSpec::Mocks::Double + include ::RSpec::Mocks::TestDouble +end + +class RSpec::Mocks::Double +end + +class RSpec::Mocks::ErrorGenerator + def default_error_message(expectation, expected_args, actual_args); end + + def describe_expectation(verb, message, expected_received_count, _actual_received_count, args); end + + def expectation_on_nil_message(method_name); end + + def initialize(target=T.unsafe(nil)); end + + def intro(unwrapped=T.unsafe(nil)); end + + def method_call_args_description(args, generic_prefix=T.unsafe(nil), matcher_prefix=T.unsafe(nil)); end + + def opts(); end + + def opts=(opts); end + + def raise_already_invoked_error(message, calling_customization); end + + def raise_cant_constrain_count_for_negated_have_received_error(count_constraint); end + + def raise_double_negation_error(wrapped_expression); end + + def raise_expectation_error(message, expected_received_count, argument_list_matcher, actual_received_count, expectation_count_type, args, backtrace_line=T.unsafe(nil), source_id=T.unsafe(nil)); end + + def raise_expectation_on_mocked_method(method); end + + def raise_expectation_on_nil_error(method_name); end + + def raise_expectation_on_unstubbed_method(method); end + + def raise_expired_test_double_error(); end + + def raise_have_received_disallowed(type, reason); end + + def raise_invalid_arguments_error(verifier); end + + def raise_method_not_stubbed_error(method_name); end + + def raise_missing_block_error(args_to_yield); end + + def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end + + def raise_non_public_error(method_name, visibility); end + + def raise_only_valid_on_a_partial_double(method); end + + def raise_out_of_order_error(message); end + + def raise_similar_message_args_error(expectation, args_for_multiple_calls, backtrace_line=T.unsafe(nil)); end + + def raise_unexpected_message_args_error(expectation, args_for_multiple_calls, source_id=T.unsafe(nil)); end + + def raise_unexpected_message_error(message, args); end + + def raise_unimplemented_error(doubled_module, method_name, object); end + + def raise_verifying_double_not_defined_error(ref); end + + def raise_wrong_arity_error(args_to_yield, signature); end +end + +class RSpec::Mocks::ErrorGenerator +end + +module RSpec::Mocks::ExampleMethods + include ::RSpec::Mocks::ArgumentMatchers + def allow(target); end + + def allow_any_instance_of(klass); end + + def allow_message_expectations_on_nil(); end + + def class_double(doubled_class, *args); end + + def class_spy(*args); end + + def double(*args); end + + def expect_any_instance_of(klass); end + + def have_received(method_name, &block); end + + def hide_const(constant_name); end + + def instance_double(doubled_class, *args); end + + def instance_spy(*args); end + + def object_double(object_or_name, *args); end + + def object_spy(*args); end + + def receive(method_name, &block); end + + def receive_message_chain(*messages, &block); end + + def receive_messages(message_return_value_hash); end + + def spy(*args); end + + def stub_const(constant_name, value, options=T.unsafe(nil)); end + + def without_partial_double_verification(); end +end + +module RSpec::Mocks::ExampleMethods::ExpectHost + def expect(target); end +end + +module RSpec::Mocks::ExampleMethods::ExpectHost +end + +module RSpec::Mocks::ExampleMethods + def self.declare_double(type, *args); end + + def self.declare_verifying_double(type, ref, *args); end + + def self.extended(object); end + + def self.included(klass); end +end + +class RSpec::Mocks::ExpectChain +end + +class RSpec::Mocks::ExpectChain + def self.expect_chain_on(object, *chain, &blk); end +end + +class RSpec::Mocks::ExpectationTarget + include ::RSpec::Mocks::ExpectationTargetMethods +end + +class RSpec::Mocks::ExpectationTarget +end + +module RSpec::Mocks::ExpectationTargetMethods + include ::RSpec::Mocks::TargetDelegationInstanceMethods + def expression(); end + + def not_to(matcher, &block); end + + def to(matcher, &block); end + + def to_not(matcher, &block); end +end + +module RSpec::Mocks::ExpectationTargetMethods + extend ::RSpec::Mocks::TargetDelegationClassMethods +end + +class RSpec::Mocks::ExpiredTestDoubleError +end + +class RSpec::Mocks::ExpiredTestDoubleError +end + +class RSpec::Mocks::Implementation + def call(*args, &block); end + + def initial_action(); end + + def initial_action=(initial_action); end + + def inner_action(); end + + def inner_action=(inner_action); end + + def present?(); end + + def terminal_action(); end + + def terminal_action=(terminal_action); end +end + +class RSpec::Mocks::Implementation +end + +class RSpec::Mocks::InstanceMethodReference +end + +class RSpec::Mocks::InstanceMethodReference +end + +class RSpec::Mocks::InstanceMethodStasher + def handle_restoration_failures(); end + + def initialize(object, method); end + + def method_is_stashed?(); end + + def original_method(); end + + def restore(); end + + def stash(); end +end + +class RSpec::Mocks::InstanceMethodStasher +end + +class RSpec::Mocks::InstanceVerifyingDouble + include ::RSpec::Mocks::TestDouble + include ::RSpec::Mocks::VerifyingDouble +end + +class RSpec::Mocks::InstanceVerifyingDouble +end + +class RSpec::Mocks::MarshalExtension +end + +class RSpec::Mocks::MarshalExtension + def self.patch!(); end + + def self.unpatch!(); end +end + +module RSpec::Mocks::Matchers +end + +class RSpec::Mocks::Matchers::ExpectationCustomization + def block(); end + + def block=(block); end + + def initialize(method_name, args, block); end + + def playback_onto(expectation); end +end + +class RSpec::Mocks::Matchers::ExpectationCustomization +end + +class RSpec::Mocks::Matchers::HaveReceived + include ::RSpec::Mocks::Matchers::Matcher + def at_least(*args); end + + def at_most(*args); end + + def description(); end + + def does_not_match?(subject); end + + def exactly(*args); end + + def failure_message(); end + + def failure_message_when_negated(); end + + def initialize(method_name, &block); end + + def matches?(subject, &block); end + + def name(); end + + def once(*args); end + + def ordered(*args); end + + def setup_allowance(_subject, &_block); end + + def setup_any_instance_allowance(_subject, &_block); end + + def setup_any_instance_expectation(_subject, &_block); end + + def setup_any_instance_negative_expectation(_subject, &_block); end + + def setup_expectation(subject, &block); end + + def setup_negative_expectation(subject, &block); end + + def thrice(*args); end + + def time(*args); end + + def times(*args); end + + def twice(*args); end + + def with(*args); end + ARGS_CONSTRAINTS = ::T.let(nil, ::T.untyped) + CONSTRAINTS = ::T.let(nil, ::T.untyped) + COUNT_CONSTRAINTS = ::T.let(nil, ::T.untyped) +end + +class RSpec::Mocks::Matchers::HaveReceived +end + +module RSpec::Mocks::Matchers::Matcher +end + +module RSpec::Mocks::Matchers::Matcher +end + +class RSpec::Mocks::Matchers::Receive + include ::RSpec::Mocks::Matchers::Matcher + def and_call_original(*args, &block); end + + def and_raise(*args, &block); end + + def and_return(*args, &block); end + + def and_throw(*args, &block); end + + def and_wrap_original(*args, &block); end + + def and_yield(*args, &block); end + + def at_least(*args, &block); end + + def at_most(*args, &block); end + + def description(); end + + def does_not_match?(subject, &block); end + + def exactly(*args, &block); end + + def initialize(message, block); end + + def matches?(subject, &block); end + + def name(); end + + def never(*args, &block); end + + def once(*args, &block); end + + def ordered(*args, &block); end + + def setup_allowance(subject, &block); end + + def setup_any_instance_allowance(subject, &block); end + + def setup_any_instance_expectation(subject, &block); end + + def setup_any_instance_negative_expectation(subject, &block); end + + def setup_expectation(subject, &block); end + + def setup_negative_expectation(subject, &block); end + + def thrice(*args, &block); end + + def time(*args, &block); end + + def times(*args, &block); end + + def twice(*args, &block); end + + def with(*args, &block); end +end + +class RSpec::Mocks::Matchers::Receive::DefaultDescribable + def description_for(verb); end + + def initialize(message); end +end + +class RSpec::Mocks::Matchers::Receive::DefaultDescribable +end + +class RSpec::Mocks::Matchers::Receive +end + +class RSpec::Mocks::Matchers::ReceiveMessageChain + include ::RSpec::Mocks::Matchers::Matcher + def and_call_original(*args, &block); end + + def and_raise(*args, &block); end + + def and_return(*args, &block); end + + def and_throw(*args, &block); end + + def and_yield(*args, &block); end + + def description(); end + + def does_not_match?(*_args); end + + def initialize(chain, &block); end + + def matches?(subject, &block); end + + def name(); end + + def setup_allowance(subject, &block); end + + def setup_any_instance_allowance(subject, &block); end + + def setup_any_instance_expectation(subject, &block); end + + def setup_expectation(subject, &block); end + + def setup_negative_expectation(*_args); end + + def with(*args, &block); end +end + +class RSpec::Mocks::Matchers::ReceiveMessageChain +end + +class RSpec::Mocks::Matchers::ReceiveMessages + include ::RSpec::Mocks::Matchers::Matcher + def description(); end + + def does_not_match?(_subject); end + + def initialize(message_return_value_hash); end + + def matches?(subject); end + + def name(); end + + def setup_allowance(subject); end + + def setup_any_instance_allowance(subject); end + + def setup_any_instance_expectation(subject); end + + def setup_expectation(subject); end + + def setup_negative_expectation(_subject); end + + def warn_about_block(); end +end + +class RSpec::Mocks::Matchers::ReceiveMessages +end + +module RSpec::Mocks::Matchers +end + +class RSpec::Mocks::MessageChain + def block(); end + + def chain(); end + + def initialize(object, *chain, &blk); end + + def object(); end + + def setup_chain(); end +end + +class RSpec::Mocks::MessageChain +end + +class RSpec::Mocks::MessageExpectation + include ::RSpec::Mocks::MessageExpectation::ImplementationDetails + def and_call_original(); end + + def and_raise(*args); end + + def and_return(first_value, *values); end + + def and_throw(*args); end + + def and_wrap_original(&block); end + + def and_yield(*args, &block); end + + def at_least(n, &block); end + + def at_most(n, &block); end + + def exactly(n, &block); end + + def never(); end + + def once(&block); end + + def ordered(&block); end + + def thrice(&block); end + + def time(&block); end + + def times(&block); end + + def twice(&block); end + + def with(*args, &block); end +end + +module RSpec::Mocks::MessageExpectation::ImplementationDetails + def actual_received_count_matters?(); end + + def additional_expected_calls(); end + + def advise(*args); end + + def and_yield_receiver_to_implementation(); end + + def argument_list_matcher=(argument_list_matcher); end + + def called_max_times?(); end + + def description_for(verb); end + + def ensure_expected_ordering_received!(); end + + def error_generator(); end + + def error_generator=(error_generator); end + + def expectation_count_type(); end + + def expected_args(); end + + def expected_from=(expected_from); end + + def expected_messages_received?(); end + + def expected_received_count=(expected_received_count); end + + def generate_error(); end + + def ignoring_args?(); end + + def implementation(); end + + def implementation=(implementation); end + + def increase_actual_received_count!(); end + + def initialize(error_generator, expectation_ordering, expected_from, method_double, type=T.unsafe(nil), opts=T.unsafe(nil), &implementation_block); end + + def invoke(parent_stub, *args, &block); end + + def invoke_without_incrementing_received_count(parent_stub, *args, &block); end + + def matches?(message, *args); end + + def matches_at_least_count?(); end + + def matches_at_most_count?(); end + + def matches_exact_count?(); end + + def matches_name_but_not_args(message, *args); end + + def message(); end + + def negative?(); end + + def negative_expectation_for?(message); end + + def ordered?(); end + + def orig_object(); end + + def raise_out_of_order_error(); end + + def raise_unexpected_message_args_error(args_for_multiple_calls); end + + def safe_invoke(parent_stub, *args, &block); end + + def similar_messages(); end + + def type(); end + + def unadvise(args); end + + def verify_messages_received(); end + + def yield_receiver_to_implementation_block?(); end +end + +module RSpec::Mocks::MessageExpectation::ImplementationDetails +end + +class RSpec::Mocks::MessageExpectation +end + +class RSpec::Mocks::MethodDouble + def add_default_stub(*args, &implementation); end + + def add_expectation(error_generator, expectation_ordering, expected_from, opts, &implementation); end + + def add_simple_expectation(method_name, response, error_generator, backtrace_line); end + + def add_simple_stub(method_name, response); end + + def add_stub(error_generator, expectation_ordering, expected_from, opts=T.unsafe(nil), &implementation); end + + def build_expectation(error_generator, expectation_ordering); end + + def clear(); end + + def configure_method(); end + + def define_proxy_method(); end + + def expectations(); end + + def initialize(object, method_name, proxy); end + + def message_expectation_class(); end + + def method_name(); end + + def method_stasher(); end + + def object(); end + + def object_singleton_class(); end + + def original_implementation_callable(); end + + def original_method(); end + + def proxy_method_invoked(_obj, *args, &block); end + + def raise_method_not_stubbed_error(); end + + def remove_stub(); end + + def remove_stub_if_present(); end + + def reset(); end + + def restore_original_method(); end + + def restore_original_visibility(); end + + def save_original_implementation_callable!(); end + + def setup_simple_method_double(method_name, response, collection, error_generator=T.unsafe(nil), backtrace_line=T.unsafe(nil)); end + + def show_frozen_warning(); end + + def stubs(); end + + def verify(); end + + def visibility(); end +end + +class RSpec::Mocks::MethodDouble::RSpecPrependedModule +end + +class RSpec::Mocks::MethodDouble::RSpecPrependedModule +end + +class RSpec::Mocks::MethodDouble +end + +class RSpec::Mocks::MethodReference + def defined?(); end + + def implemented?(); end + + def initialize(object_reference, method_name); end + + def unimplemented?(); end + + def visibility(); end + + def with_signature(); end +end + +class RSpec::Mocks::MethodReference + def self.for(object_reference, method_name); end + + def self.instance_method_visibility_for(klass, method_name); end + + def self.method_defined_at_any_visibility?(klass, method_name); end + + def self.method_visibility_for(object, method_name); end +end + +class RSpec::Mocks::MockExpectationAlreadyInvokedError +end + +class RSpec::Mocks::MockExpectationAlreadyInvokedError +end + +class RSpec::Mocks::MockExpectationError +end + +class RSpec::Mocks::MockExpectationError +end + +class RSpec::Mocks::NamedObjectReference + def const_to_replace(); end + + def defined?(); end + + def description(); end + + def initialize(const_name); end + + def target(); end + + def when_loaded(); end +end + +class RSpec::Mocks::NamedObjectReference +end + +class RSpec::Mocks::NegationUnsupportedError +end + +class RSpec::Mocks::NegationUnsupportedError +end + +class RSpec::Mocks::NestedSpace + def initialize(parent); end +end + +class RSpec::Mocks::NestedSpace +end + +class RSpec::Mocks::NoCallbackInvocationStrategy + def call(_doubled_module); end +end + +class RSpec::Mocks::NoCallbackInvocationStrategy +end + +class RSpec::Mocks::ObjectMethodReference +end + +class RSpec::Mocks::ObjectMethodReference +end + +class RSpec::Mocks::ObjectReference + MODULE_NAME_METHOD = ::T.let(nil, ::T.untyped) +end + +class RSpec::Mocks::ObjectReference + def self.for(object_module_or_name, allow_direct_object_refs=T.unsafe(nil)); end +end + +class RSpec::Mocks::ObjectVerifyingDouble + include ::RSpec::Mocks::ObjectVerifyingDoubleMethods + include ::RSpec::Mocks::TestDouble + include ::RSpec::Mocks::VerifyingDouble +end + +class RSpec::Mocks::ObjectVerifyingDouble +end + +module RSpec::Mocks::ObjectVerifyingDoubleMethods + include ::RSpec::Mocks::TestDouble + include ::RSpec::Mocks::VerifyingDouble + def as_stubbed_const(options=T.unsafe(nil)); end +end + +module RSpec::Mocks::ObjectVerifyingDoubleMethods +end + +class RSpec::Mocks::OrderGroup + def clear(); end + + def consume(); end + + def empty?(); end + + def handle_order_constraint(expectation); end + + def invoked(message); end + + def ready_for?(expectation); end + + def register(expectation); end + + def verify_invocation_order(expectation); end +end + +class RSpec::Mocks::OrderGroup +end + +class RSpec::Mocks::OutsideOfExampleError +end + +class RSpec::Mocks::OutsideOfExampleError +end + +class RSpec::Mocks::PartialClassDoubleProxy + include ::RSpec::Mocks::PartialClassDoubleProxyMethods +end + +class RSpec::Mocks::PartialClassDoubleProxy +end + +module RSpec::Mocks::PartialClassDoubleProxyMethods + def initialize(source_space, *args); end + + def method_double_from_ancestor_for(message); end + + def original_method_handle_for(message); end + + def original_unbound_method_handle_from_ancestor_for(message); end + + def superclass_proxy(); end +end + +module RSpec::Mocks::PartialClassDoubleProxyMethods +end + +class RSpec::Mocks::PartialDoubleProxy + def original_method_handle_for(message); end + + def visibility_for(method_name); end +end + +class RSpec::Mocks::PartialDoubleProxy +end + +class RSpec::Mocks::Proxy + def add_message_expectation(method_name, opts=T.unsafe(nil), &block); end + + def add_simple_expectation(method_name, response, location); end + + def add_simple_stub(method_name, response); end + + def add_stub(method_name, opts=T.unsafe(nil), &implementation); end + + def build_expectation(method_name); end + + def check_for_unexpected_arguments(expectation); end + + def ensure_implemented(*_args); end + + def has_negative_expectation?(message); end + + def initialize(object, order_group, options=T.unsafe(nil)); end + + def message_received(message, *args, &block); end + + def messages_arg_list(); end + + def method_double_if_exists_for_message(message); end + + def object(); end + + def original_method_handle_for(_message); end + + def prepended_modules_of_singleton_class(); end + + def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end + + def raise_unexpected_message_error(method_name, args); end + + def received_message?(method_name, *args, &block); end + + def record_message_received(message, *args, &block); end + + def remove_stub(method_name); end + + def remove_stub_if_present(method_name); end + + def replay_received_message_on(expectation, &block); end + + def reset(); end + + def verify(); end + + def visibility_for(_method_name); end + DEFAULT_MESSAGE_EXPECTATION_OPTS = ::T.let(nil, ::T.untyped) +end + +class RSpec::Mocks::Proxy::SpecificMessage + def ==(expectation); end + + def args(); end + + def args=(_); end + + def message(); end + + def message=(_); end + + def object(); end + + def object=(_); end +end + +class RSpec::Mocks::Proxy::SpecificMessage + def self.[](*_); end + + def self.members(); end +end + +class RSpec::Mocks::Proxy + def self.prepended_modules_of(klass); end +end + +class RSpec::Mocks::ProxyForNil + def disallow_expectations(); end + + def disallow_expectations=(disallow_expectations); end + + def initialize(order_group); end + + def warn_about_expectations(); end + + def warn_about_expectations=(warn_about_expectations); end +end + +class RSpec::Mocks::ProxyForNil +end + +class RSpec::Mocks::RootSpace + def any_instance_proxy_for(*_args); end + + def any_instance_recorder_for(*_args); end + + def any_instance_recorders_from_ancestry_of(_object); end + + def new_scope(); end + + def proxy_for(*_args); end + + def register_constant_mutator(_mutator); end + + def registered?(_object); end + + def reset_all(); end + + def superclass_proxy_for(*_args); end + + def verify_all(); end +end + +class RSpec::Mocks::RootSpace +end + +class RSpec::Mocks::SimpleMessageExpectation + def called_max_times?(); end + + def initialize(message, response, error_generator, backtrace_line=T.unsafe(nil)); end + + def invoke(*_); end + + def matches?(message, *_); end + + def unadvise(_); end + + def verify_messages_received(); end +end + +class RSpec::Mocks::SimpleMessageExpectation +end + +class RSpec::Mocks::Space + def any_instance_mutex(); end + + def any_instance_proxy_for(klass); end + + def any_instance_recorder_for(klass, only_return_existing=T.unsafe(nil)); end + + def any_instance_recorders(); end + + def any_instance_recorders_from_ancestry_of(object); end + + def constant_mutator_for(name); end + + def ensure_registered(object); end + + def new_scope(); end + + def proxies(); end + + def proxies_of(klass); end + + def proxy_for(object); end + + def proxy_mutex(); end + + def register_constant_mutator(mutator); end + + def registered?(object); end + + def reset_all(); end + + def superclass_proxy_for(klass); end + + def verify_all(); end +end + +class RSpec::Mocks::Space +end + +class RSpec::Mocks::StubChain +end + +class RSpec::Mocks::StubChain + def self.stub_chain_on(object, *chain, &blk); end +end + +module RSpec::Mocks::Syntax +end + +module RSpec::Mocks::Syntax + def self.default_should_syntax_host(); end + + def self.disable_expect(syntax_host=T.unsafe(nil)); end + + def self.disable_should(syntax_host=T.unsafe(nil)); end + + def self.enable_expect(syntax_host=T.unsafe(nil)); end + + def self.enable_should(syntax_host=T.unsafe(nil)); end + + def self.expect_enabled?(syntax_host=T.unsafe(nil)); end + + def self.should_enabled?(syntax_host=T.unsafe(nil)); end + + def self.warn_about_should!(); end + + def self.warn_unless_should_configured(method_name, replacement=T.unsafe(nil)); end +end + +class RSpec::Mocks::TargetBase + include ::RSpec::Mocks::TargetDelegationInstanceMethods + def initialize(target); end +end + +class RSpec::Mocks::TargetBase + extend ::RSpec::Mocks::TargetDelegationClassMethods +end + +module RSpec::Mocks::TargetDelegationClassMethods + def delegate_not_to(matcher_method, options=T.unsafe(nil)); end + + def delegate_to(matcher_method); end + + def disallow_negation(method_name); end +end + +module RSpec::Mocks::TargetDelegationClassMethods +end + +module RSpec::Mocks::TargetDelegationInstanceMethods + def target(); end +end + +module RSpec::Mocks::TargetDelegationInstanceMethods +end + +module RSpec::Mocks::TestDouble + def ==(other); end + + def __build_mock_proxy_unless_expired(order_group); end + + def __disallow_further_usage!(); end + + def as_null_object(); end + + def freeze(); end + + def initialize(name=T.unsafe(nil), stubs=T.unsafe(nil)); end + + def inspect(); end + + def null_object?(); end + + def respond_to?(message, incl_private=T.unsafe(nil)); end + + def to_s(); end +end + +module RSpec::Mocks::TestDouble +end + +module RSpec::Mocks::TestDoubleFormatter +end + +module RSpec::Mocks::TestDoubleFormatter + def self.format(dbl, unwrap=T.unsafe(nil)); end +end + +class RSpec::Mocks::TestDoubleProxy +end + +class RSpec::Mocks::TestDoubleProxy +end + +class RSpec::Mocks::UnsupportedMatcherError +end + +class RSpec::Mocks::UnsupportedMatcherError +end + +module RSpec::Mocks::VerifyingDouble + def __send__(name, *args, &block); end + + def initialize(doubled_module, *args); end + + def method_missing(message, *args, &block); end + + def respond_to?(message, include_private=T.unsafe(nil)); end + + def send(name, *args, &block); end +end + +module RSpec::Mocks::VerifyingDouble::SilentIO +end + +module RSpec::Mocks::VerifyingDouble::SilentIO +end + +module RSpec::Mocks::VerifyingDouble +end + +class RSpec::Mocks::VerifyingDoubleNotDefinedError +end + +class RSpec::Mocks::VerifyingDoubleNotDefinedError +end + +class RSpec::Mocks::VerifyingExistingClassNewMethodDouble +end + +class RSpec::Mocks::VerifyingExistingClassNewMethodDouble +end + +class RSpec::Mocks::VerifyingExistingMethodDouble + def initialize(object, method_name, proxy); end + + def unimplemented?(); end + + def with_signature(); end +end + +class RSpec::Mocks::VerifyingExistingMethodDouble + def self.for(object, method_name, proxy); end +end + +class RSpec::Mocks::VerifyingMessageExpectation + def initialize(*args); end + + def method_reference(); end + + def method_reference=(method_reference); end +end + +class RSpec::Mocks::VerifyingMessageExpectation +end + +class RSpec::Mocks::VerifyingMethodDouble + def add_expectation(*args, &block); end + + def add_stub(*args, &block); end + + def initialize(object, method_name, proxy, method_reference); end + + def proxy_method_invoked(obj, *args, &block); end + + def validate_arguments!(actual_args); end +end + +class RSpec::Mocks::VerifyingMethodDouble +end + +class RSpec::Mocks::VerifyingPartialClassDoubleProxy + include ::RSpec::Mocks::PartialClassDoubleProxyMethods +end + +class RSpec::Mocks::VerifyingPartialClassDoubleProxy +end + +class RSpec::Mocks::VerifyingPartialDoubleProxy + include ::RSpec::Mocks::VerifyingProxyMethods + def ensure_implemented(_method_name); end + + def initialize(object, expectation_ordering, optional_callback_invocation_strategy=T.unsafe(nil)); end + + def method_reference(); end +end + +class RSpec::Mocks::VerifyingPartialDoubleProxy +end + +class RSpec::Mocks::VerifyingProxy + include ::RSpec::Mocks::VerifyingProxyMethods + def initialize(object, order_group, doubled_module, method_reference_class); end + + def method_reference(); end + + def validate_arguments!(method_name, args); end + + def visibility_for(method_name); end +end + +class RSpec::Mocks::VerifyingProxy +end + +module RSpec::Mocks::VerifyingProxyMethods + def add_message_expectation(method_name, opts=T.unsafe(nil), &block); end + + def add_simple_stub(method_name, *args); end + + def add_stub(method_name, opts=T.unsafe(nil), &implementation); end + + def ensure_implemented(method_name); end + + def ensure_publicly_implemented(method_name, _object); end +end + +module RSpec::Mocks::VerifyingProxyMethods +end + +module RSpec::Mocks::Version + STRING = ::T.let(nil, ::T.untyped) +end + +module RSpec::Mocks::Version +end + +module RSpec::Mocks + def self.allow_message(subject, message, opts=T.unsafe(nil), &block); end + + def self.configuration(); end + + def self.error_generator(); end + + def self.expect_message(subject, message, opts=T.unsafe(nil), &block); end + + def self.setup(); end + + def self.space(); end + + def self.teardown(); end + + def self.verify(); end + + def self.with_temporary_scope(); end +end + +RSpec::SharedContext = RSpec::Core::SharedContext + +module RSpec::Support + DEFAULT_FAILURE_NOTIFIER = ::T.let(nil, ::T.untyped) + DEFAULT_WARNING_NOTIFIER = ::T.let(nil, ::T.untyped) + KERNEL_METHOD_METHOD = ::T.let(nil, ::T.untyped) +end + +module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue + AVOID_RESCUING = ::T.let(nil, ::T.untyped) +end + +module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue + def self.===(exception); end +end + +class RSpec::Support::BlockSignature +end + +class RSpec::Support::BlockSignature +end + +class RSpec::Support::ComparableVersion + include ::Comparable + def initialize(string); end + + def segments(); end + + def string(); end +end + +class RSpec::Support::ComparableVersion +end + +class RSpec::Support::Differ + def color?(); end + + def diff(actual, expected); end + + def diff_as_object(actual, expected); end + + def diff_as_string(actual, expected); end + + def initialize(opts=T.unsafe(nil)); end +end + +class RSpec::Support::Differ +end + +class RSpec::Support::DirectoryMaker +end + +class RSpec::Support::DirectoryMaker + def self.mkdir_p(path); end +end + +class RSpec::Support::EncodedString + def <<(string); end + + def ==(*args, &block); end + + def empty?(*args, &block); end + + def encoding(*args, &block); end + + def eql?(*args, &block); end + + def initialize(string, encoding=T.unsafe(nil)); end + + def lines(*args, &block); end + + def source_encoding(); end + + def split(regex_or_string); end + + def to_str(); end + REPLACE = ::T.let(nil, ::T.untyped) + US_ASCII = ::T.let(nil, ::T.untyped) + UTF_8 = ::T.let(nil, ::T.untyped) +end + +class RSpec::Support::EncodedString + def self.pick_encoding(source_a, source_b); end +end + +module RSpec::Support::FuzzyMatcher +end + +module RSpec::Support::FuzzyMatcher + def self.values_match?(expected, actual); end +end + +class RSpec::Support::LooseSignatureVerifier +end + +class RSpec::Support::LooseSignatureVerifier::SignatureWithKeywordArgumentsMatcher + def has_kw_args_in?(args); end + + def initialize(signature); end + + def invalid_kw_args_from(_kw_args); end + + def missing_kw_args_from(_kw_args); end + + def non_kw_args_arity_description(); end + + def valid_non_kw_args?(*args); end +end + +class RSpec::Support::LooseSignatureVerifier::SignatureWithKeywordArgumentsMatcher +end + +class RSpec::Support::LooseSignatureVerifier +end + +class RSpec::Support::MethodSignature + def arbitrary_kw_args?(); end + + def classify_arity(arity=T.unsafe(nil)); end + + def classify_parameters(); end + + def could_contain_kw_args?(args); end + + def description(); end + + def has_kw_args_in?(args); end + + def initialize(method); end + + def invalid_kw_args_from(given_kw_args); end + + def max_non_kw_args(); end + + def min_non_kw_args(); end + + def missing_kw_args_from(given_kw_args); end + + def non_kw_args_arity_description(); end + + def optional_kw_args(); end + + def required_kw_args(); end + + def unlimited_args?(); end + + def valid_non_kw_args?(positional_arg_count, optional_max_arg_count=T.unsafe(nil)); end + INFINITY = ::T.let(nil, ::T.untyped) +end + +class RSpec::Support::MethodSignature +end + +class RSpec::Support::MethodSignatureExpectation + def empty?(); end + + def expect_arbitrary_keywords(); end + + def expect_arbitrary_keywords=(expect_arbitrary_keywords); end + + def expect_unlimited_arguments(); end + + def expect_unlimited_arguments=(expect_unlimited_arguments); end + + def keywords(); end + + def keywords=(values); end + + def max_count(); end + + def max_count=(number); end + + def min_count(); end + + def min_count=(number); end +end + +class RSpec::Support::MethodSignatureExpectation +end + +class RSpec::Support::MethodSignatureVerifier + def error_message(); end + + def initialize(signature, args=T.unsafe(nil)); end + + def kw_args(); end + + def max_non_kw_args(); end + + def min_non_kw_args(); end + + def non_kw_args(); end + + def valid?(); end + + def with_expectation(expectation); end +end + +class RSpec::Support::MethodSignatureVerifier +end + +class RSpec::Support::Mutex + NEW_MUTEX_METHOD = ::T.let(nil, ::T.untyped) +end + +class RSpec::Support::Mutex + def self.new(); end +end + +module RSpec::Support::OS +end + +module RSpec::Support::OS + def self.windows?(); end + + def self.windows_file_path?(); end +end + +class RSpec::Support::ObjectFormatter + def format(object); end + + def initialize(max_formatted_output_length=T.unsafe(nil)); end + + def max_formatted_output_length(); end + + def max_formatted_output_length=(max_formatted_output_length); end + + def prepare_array(array); end + + def prepare_element(element); end + + def prepare_for_inspection(object); end + + def prepare_hash(input_hash); end + + def recursive_structure?(object); end + + def sort_hash_keys(input_hash); end + + def with_entering_structure(structure); end + ELLIPSIS = ::T.let(nil, ::T.untyped) + INSPECTOR_CLASSES = ::T.let(nil, ::T.untyped) +end + +class RSpec::Support::ObjectFormatter::BaseInspector + def formatter(); end + + def formatter=(_); end + + def object(); end + + def object=(_); end + + def pretty_print(pp); end +end + +class RSpec::Support::ObjectFormatter::BaseInspector + def self.[](*_); end + + def self.can_inspect?(_object); end + + def self.members(); end +end + +class RSpec::Support::ObjectFormatter::BigDecimalInspector +end + +class RSpec::Support::ObjectFormatter::BigDecimalInspector + def self.can_inspect?(object); end +end + +class RSpec::Support::ObjectFormatter::DateTimeInspector + FORMAT = ::T.let(nil, ::T.untyped) +end + +class RSpec::Support::ObjectFormatter::DateTimeInspector + def self.can_inspect?(object); end +end + +class RSpec::Support::ObjectFormatter::DelegatorInspector +end + +class RSpec::Support::ObjectFormatter::DelegatorInspector + def self.can_inspect?(object); end +end + +class RSpec::Support::ObjectFormatter::DescribableMatcherInspector +end + +class RSpec::Support::ObjectFormatter::DescribableMatcherInspector + def self.can_inspect?(object); end +end + +class RSpec::Support::ObjectFormatter::InspectableItem + def pretty_print(pp); end + + def text(); end + + def text=(_); end +end + +class RSpec::Support::ObjectFormatter::InspectableItem + def self.[](*_); end + + def self.members(); end +end + +class RSpec::Support::ObjectFormatter::InspectableObjectInspector +end + +class RSpec::Support::ObjectFormatter::InspectableObjectInspector + def self.can_inspect?(object); end +end + +class RSpec::Support::ObjectFormatter::TimeInspector + FORMAT = ::T.let(nil, ::T.untyped) +end + +class RSpec::Support::ObjectFormatter::TimeInspector + def self.can_inspect?(object); end +end + +class RSpec::Support::ObjectFormatter::UninspectableObjectInspector + def klass(); end + + def native_object_id(); end + OBJECT_ID_FORMAT = ::T.let(nil, ::T.untyped) +end + +class RSpec::Support::ObjectFormatter::UninspectableObjectInspector + def self.can_inspect?(object); end +end + +class RSpec::Support::ObjectFormatter + def self.default_instance(); end + + def self.format(object); end + + def self.prepare_for_inspection(object); end +end + +module RSpec::Support::RecursiveConstMethods + def const_defined_on?(mod, const_name); end + + def constants_defined_on(mod); end + + def get_const_defined_on(mod, const_name); end + + def normalize_const_name(const_name); end + + def recursive_const_defined?(const_name); end + + def recursive_const_get(const_name); end +end + +module RSpec::Support::RecursiveConstMethods +end + +class RSpec::Support::ReentrantMutex + def synchronize(); end +end + +class RSpec::Support::ReentrantMutex +end + +module RSpec::Support::Ruby +end + +module RSpec::Support::Ruby + def self.jruby?(); end + + def self.jruby_9000?(); end + + def self.jruby_version(); end + + def self.mri?(); end + + def self.non_mri?(); end + + def self.rbx?(); end + + def self.truffleruby?(); end +end + +module RSpec::Support::RubyFeatures +end + +module RSpec::Support::RubyFeatures + def self.caller_locations_supported?(); end + + def self.fork_supported?(); end + + def self.kw_args_supported?(); end + + def self.module_prepends_supported?(); end + + def self.module_refinement_supported?(); end + + def self.optional_and_splat_args_supported?(); end + + def self.required_kw_args_supported?(); end + + def self.ripper_supported?(); end + + def self.supports_exception_cause?(); end + + def self.supports_rebinding_module_methods?(); end + + def self.supports_taint?(); end +end + +RSpec::Support::StrictSignatureVerifier = RSpec::Support::MethodSignatureVerifier + +module RSpec::Support::Version + STRING = ::T.let(nil, ::T.untyped) +end + +module RSpec::Support::Version +end + +module RSpec::Support::Warnings + def deprecate(deprecated, options=T.unsafe(nil)); end + + def warn_deprecation(message, options=T.unsafe(nil)); end + + def warn_with(message, options=T.unsafe(nil)); end + + def warning(text, options=T.unsafe(nil)); end +end + +module RSpec::Support::Warnings +end + +module RSpec::Support::WithKeywordsWhenNeeded +end + +module RSpec::Support::WithKeywordsWhenNeeded + def self.class_exec(klass, *args, &block); end +end + +module RSpec::Support + def self.class_of(object); end + + def self.define_optimized_require_for_rspec(lib, &require_relative); end + + def self.deregister_matcher_definition(&block); end + + def self.failure_notifier(); end + + def self.failure_notifier=(callable); end + + def self.is_a_matcher?(object); end + + def self.matcher_definitions(); end + + def self.method_handle_for(object, method_name); end + + def self.notify_failure(failure, options=T.unsafe(nil)); end + + def self.register_matcher_definition(&block); end + + def self.require_rspec_core(f); end + + def self.require_rspec_expectations(f); end + + def self.require_rspec_matchers(f); end + + def self.require_rspec_mocks(f); end + + def self.require_rspec_support(f); end + + def self.rspec_description_for_object(object); end + + def self.thread_local_data(); end + + def self.warning_notifier(); end + + def self.warning_notifier=(warning_notifier); end + + def self.with_failure_notifier(callable); end +end + +module RSpec::Version + STRING = ::T.let(nil, ::T.untyped) +end + +module RSpec::Version +end + +module RSpec + extend ::RSpec::Support::Warnings + extend ::RSpec::Core::Warnings + def self.clear_examples(); end + + def self.configuration(); end + + def self.configuration=(configuration); end + + def self.configure(); end + + def self.const_missing(name); end + + def self.context(*args, &example_group_block); end + + def self.current_example(); end + + def self.current_example=(example); end + + def self.describe(*args, &example_group_block); end + + def self.example_group(*args, &example_group_block); end + + def self.fcontext(*args, &example_group_block); end + + def self.fdescribe(*args, &example_group_block); end + + def self.reset(); end + + def self.world(); end + + def self.world=(world); end + + def self.xcontext(*args, &example_group_block); end + + def self.xdescribe(*args, &example_group_block); end +end + +class Racc::Parser + Racc_Main_Parsing_Routine = ::T.let(nil, ::T.untyped) + Racc_Runtime_Core_Id_C = ::T.let(nil, ::T.untyped) + Racc_Runtime_Core_Revision = ::T.let(nil, ::T.untyped) + Racc_Runtime_Core_Revision_C = ::T.let(nil, ::T.untyped) + Racc_Runtime_Core_Revision_R = ::T.let(nil, ::T.untyped) + Racc_Runtime_Core_Version = ::T.let(nil, ::T.untyped) + Racc_Runtime_Core_Version_C = ::T.let(nil, ::T.untyped) + Racc_Runtime_Core_Version_R = ::T.let(nil, ::T.untyped) + Racc_Runtime_Revision = ::T.let(nil, ::T.untyped) + Racc_Runtime_Type = ::T.let(nil, ::T.untyped) + Racc_Runtime_Version = ::T.let(nil, ::T.untyped) + Racc_YY_Parse_Method = ::T.let(nil, ::T.untyped) +end + +module Rake + EARLY = ::T.let(nil, ::T.untyped) + EMPTY_TASK_ARGS = ::T.let(nil, ::T.untyped) + LATE = ::T.let(nil, ::T.untyped) + VERSION = ::T.let(nil, ::T.untyped) +end + +class Rake::Application + include ::Rake::TaskManager + include ::Rake::TraceOutput + def add_import(fn); end + + def add_loader(ext, loader); end + + def collect_command_line_tasks(args); end + + def default_task_name(); end + + def deprecate(old_usage, new_usage, call_site); end + + def display_cause_details(ex); end + + def display_error_message(ex); end + + def display_exception_backtrace(ex); end + + def display_exception_details(ex); end + + def display_exception_details_seen(); end + + def display_exception_message_details(ex); end + + def display_prerequisites(); end + + def display_tasks_and_comments(); end + + def dynamic_width(); end + + def dynamic_width_stty(); end + + def dynamic_width_tput(); end + + def exit_because_of_exception(ex); end + + def find_rakefile_location(); end + + def handle_options(argv); end + + def has_cause?(ex); end + + def have_rakefile(); end + + def init(app_name=T.unsafe(nil), argv=T.unsafe(nil)); end + + def invoke_task(task_string); end + + def load_imports(); end + + def load_rakefile(); end + + def name(); end + + def options(); end + + def original_dir(); end + + def parse_task_string(string); end + + def print_rakefile_directory(location); end + + def rake_require(file_name, paths=T.unsafe(nil), loaded=T.unsafe(nil)); end + + def rakefile(); end + + def rakefile_location(backtrace=T.unsafe(nil)); end + + def raw_load_rakefile(); end + + def run(argv=T.unsafe(nil)); end + + def run_with_threads(); end + + def set_default_options(); end + + def standard_exception_handling(); end + + def standard_rake_options(); end + + def system_dir(); end + + def terminal_columns(); end + + def terminal_columns=(terminal_columns); end + + def terminal_width(); end + + def thread_pool(); end + + def top_level(); end + + def top_level_tasks(); end + + def trace(*strings); end + + def truncate(string, width); end + + def truncate_output?(); end + + def tty_output=(tty_output); end + + def tty_output?(); end + + def unix?(); end + + def windows?(); end + DEFAULT_RAKEFILES = ::T.let(nil, ::T.untyped) +end + +class Rake::Application +end + +module Rake::Backtrace + SUPPRESSED_PATHS = ::T.let(nil, ::T.untyped) + SUPPRESSED_PATHS_RE = ::T.let(nil, ::T.untyped) + SUPPRESS_PATTERN = ::T.let(nil, ::T.untyped) + SYS_KEYS = ::T.let(nil, ::T.untyped) + SYS_PATHS = ::T.let(nil, ::T.untyped) +end + +module Rake::Backtrace + def self.collapse(backtrace); end +end + +module Rake::Cloneable +end + +module Rake::Cloneable +end + +class Rake::CommandLineOptionError +end + +class Rake::CommandLineOptionError +end + +class Rake::CpuCounter + def count(); end + + def count_with_default(default=T.unsafe(nil)); end +end + +class Rake::CpuCounter + def self.count(); end +end + +module Rake::DSL + include ::Rake::FileUtilsExt + include ::FileUtils + include ::FileUtils::StreamUtils_ +end + +module Rake::DSL +end + +class Rake::DefaultLoader + def load(fn); end +end + +class Rake::DefaultLoader +end + +class Rake::EarlyTime + include ::Comparable + include ::Singleton +end + +class Rake::EarlyTime + extend ::Singleton::SingletonClassMethods + def self.instance(); end +end + +class Rake::FileCreationTask +end + +class Rake::FileCreationTask +end + +class Rake::FileList + include ::Rake::Cloneable + def &(*args, &block); end + + def *(other); end + + def +(*args, &block); end + + def -(*args, &block); end + + def <<(obj); end + + def ==(array); end + + def [](*args, &block); end + + def []=(*args, &block); end + + def add(*filenames); end + + def all?(*args, &block); end + + def any?(*args, &block); end + + def append(*args, &block); end + + def assoc(*args, &block); end + + def at(*args, &block); end + + def bsearch(*args, &block); end + + def bsearch_index(*args, &block); end + + def chain(*args, &block); end + + def chunk(*args, &block); end + + def chunk_while(*args, &block); end + + def clear(*args, &block); end + + def clear_exclude(); end + + def collect(*args, &block); end + + def collect!(*args, &block); end + + def collect_concat(*args, &block); end + + def combination(*args, &block); end + + def compact(*args, &block); end + + def compact!(*args, &block); end + + def concat(*args, &block); end + + def count(*args, &block); end + + def cycle(*args, &block); end + + def delete(*args, &block); end + + def delete_at(*args, &block); end + + def delete_if(*args, &block); end + + def detect(*args, &block); end + + def difference(*args, &block); end + + def dig(*args, &block); end + + def drop(*args, &block); end + + def drop_while(*args, &block); end + + def each(*args, &block); end + + def each_cons(*args, &block); end + + def each_entry(*args, &block); end + + def each_index(*args, &block); end + + def each_slice(*args, &block); end + + def each_with_index(*args, &block); end + + def each_with_object(*args, &block); end + + def egrep(pattern, *options); end + + def empty?(*args, &block); end + + def entries(*args, &block); end + + def exclude(*patterns, &block); end + + def excluded_from_list?(fn); end + + def existing(); end + + def existing!(); end + + def ext(newext=T.unsafe(nil)); end + + def fetch(*args, &block); end + + def fill(*args, &block); end + + def filter(*args, &block); end + + def filter!(*args, &block); end + + def find(*args, &block); end + + def find_all(*args, &block); end + + def find_index(*args, &block); end + + def first(*args, &block); end + + def flat_map(*args, &block); end + + def flatten(*args, &block); end + + def flatten!(*args, &block); end + + def grep(*args, &block); end + + def grep_v(*args, &block); end + + def group_by(*args, &block); end + + def gsub(pat, rep); end + + def gsub!(pat, rep); end + + def import(array); end + + def include(*filenames); end + + def include?(*args, &block); end + + def index(*args, &block); end + + def initialize(*patterns); end + + def inject(*args, &block); end + + def insert(*args, &block); end + + def inspect(*args, &block); end + + def is_a?(klass); end + + def join(*args, &block); end + + def keep_if(*args, &block); end + + def kind_of?(klass); end + + def last(*args, &block); end + + def lazy(*args, &block); end + + def length(*args, &block); end + + def map(*args, &block); end + + def map!(*args, &block); end + + def max(*args, &block); end + + def max_by(*args, &block); end + + def member?(*args, &block); end + + def min(*args, &block); end + + def min_by(*args, &block); end + + def minmax(*args, &block); end + + def minmax_by(*args, &block); end + + def none?(*args, &block); end + + def one?(*args, &block); end + + def pack(*args, &block); end + + def partition(&block); end + + def pathmap(spec=T.unsafe(nil), &block); end + + def permutation(*args, &block); end + + def pop(*args, &block); end + + def prepend(*args, &block); end + + def product(*args, &block); end + + def push(*args, &block); end + + def rassoc(*args, &block); end + + def reduce(*args, &block); end + + def reject(*args, &block); end + + def reject!(*args, &block); end + + def repeated_combination(*args, &block); end + + def repeated_permutation(*args, &block); end + + def replace(*args, &block); end + + def resolve(); end + + def reverse(*args, &block); end + + def reverse!(*args, &block); end + + def reverse_each(*args, &block); end + + def rindex(*args, &block); end + + def rotate(*args, &block); end + + def rotate!(*args, &block); end + + def sample(*args, &block); end + + def select(*args, &block); end + + def select!(*args, &block); end + + def shelljoin(*args, &block); end + + def shift(*args, &block); end + + def shuffle(*args, &block); end + + def shuffle!(*args, &block); end + + def size(*args, &block); end + + def slice(*args, &block); end + + def slice!(*args, &block); end + + def slice_after(*args, &block); end + + def slice_before(*args, &block); end + + def slice_when(*args, &block); end + + def sort(*args, &block); end + + def sort!(*args, &block); end + + def sort_by(*args, &block); end + + def sort_by!(*args, &block); end + + def sub(pat, rep); end + + def sub!(pat, rep); end + + def sum(*args, &block); end + + def take(*args, &block); end + + def take_while(*args, &block); end + + def to_a(); end + + def to_ary(); end + + def to_h(*args, &block); end + + def to_set(*args, &block); end + + def transpose(*args, &block); end + + def union(*args, &block); end + + def uniq(*args, &block); end + + def uniq!(*args, &block); end + + def unshift(*args, &block); end + + def values_at(*args, &block); end + + def zip(*args, &block); end + + def |(*args, &block); end + ARRAY_METHODS = ::T.let(nil, ::T.untyped) + DEFAULT_IGNORE_PATTERNS = ::T.let(nil, ::T.untyped) + DEFAULT_IGNORE_PROCS = ::T.let(nil, ::T.untyped) + DELEGATING_METHODS = ::T.let(nil, ::T.untyped) + GLOB_PATTERN = ::T.let(nil, ::T.untyped) + MUST_DEFINE = ::T.let(nil, ::T.untyped) + MUST_NOT_DEFINE = ::T.let(nil, ::T.untyped) + SPECIAL_RETURN = ::T.let(nil, ::T.untyped) +end + +class Rake::FileList + def self.[](*args); end + + def self.glob(pattern, *args); end +end + +class Rake::FileTask +end + +class Rake::FileTask +end + +module Rake::FileUtilsExt + include ::FileUtils + include ::FileUtils::StreamUtils_ + def cd(*args, **options, &block); end + + def chdir(*args, **options, &block); end + + def chmod(*args, **options, &block); end + + def chmod_R(*args, **options, &block); end + + def chown(*args, **options, &block); end + + def chown_R(*args, **options, &block); end + + def copy(*args, **options, &block); end + + def cp(*args, **options, &block); end + + def cp_lr(*args, **options, &block); end + + def cp_r(*args, **options, &block); end + + def install(*args, **options, &block); end + + def link(*args, **options, &block); end + + def ln(*args, **options, &block); end + + def ln_s(*args, **options, &block); end + + def ln_sf(*args, **options, &block); end + + def makedirs(*args, **options, &block); end + + def mkdir(*args, **options, &block); end + + def mkdir_p(*args, **options, &block); end + + def mkpath(*args, **options, &block); end + + def move(*args, **options, &block); end + + def mv(*args, **options, &block); end + + def nowrite(value=T.unsafe(nil)); end + + def rake_check_options(options, *optdecl); end + + def rake_output_message(message); end + + def remove(*args, **options, &block); end + + def rm(*args, **options, &block); end + + def rm_f(*args, **options, &block); end + + def rm_r(*args, **options, &block); end + + def rm_rf(*args, **options, &block); end + + def rmdir(*args, **options, &block); end + + def rmtree(*args, **options, &block); end + + def safe_unlink(*args, **options, &block); end + + def symlink(*args, **options, &block); end + + def touch(*args, **options, &block); end + + def verbose(value=T.unsafe(nil)); end + + def when_writing(msg=T.unsafe(nil)); end + DEFAULT = ::T.let(nil, ::T.untyped) +end + +module Rake::FileUtilsExt + extend ::Rake::FileUtilsExt + extend ::FileUtils + extend ::FileUtils::StreamUtils_ + def self.nowrite_flag(); end + + def self.nowrite_flag=(nowrite_flag); end + + def self.verbose_flag(); end + + def self.verbose_flag=(verbose_flag); end +end + +class Rake::InvocationChain + def append(invocation); end + + def member?(invocation); end + EMPTY = ::T.let(nil, ::T.untyped) +end + +class Rake::InvocationChain::EmptyInvocationChain + def append(invocation); end + + def member?(obj); end +end + +class Rake::InvocationChain::EmptyInvocationChain +end + +class Rake::InvocationChain + def self.append(invocation, chain); end +end + +module Rake::InvocationExceptionMixin + def chain(); end + + def chain=(value); end +end + +module Rake::InvocationExceptionMixin +end + +class Rake::LateTime + include ::Comparable + include ::Singleton +end + +class Rake::LateTime + extend ::Singleton::SingletonClassMethods + def self.instance(); end +end + +class Rake::LinkedList + include ::Enumerable + def ==(other); end + + def conj(item); end + + def each(&blk); end + + def empty?(); end + + def head(); end + + def initialize(head, tail=T.unsafe(nil)); end + + def tail(); end + EMPTY = ::T.let(nil, ::T.untyped) +end + +class Rake::LinkedList::EmptyLinkedList + def initialize(); end +end + +class Rake::LinkedList::EmptyLinkedList +end + +class Rake::LinkedList + def self.cons(head, tail); end + + def self.empty(); end + + def self.make(*args); end +end + +class Rake::MultiTask +end + +class Rake::MultiTask +end + +class Rake::NameSpace + def [](name); end + + def initialize(task_manager, scope_list); end + + def scope(); end + + def tasks(); end +end + +class Rake::NameSpace +end + +module Rake::PrivateReader +end + +module Rake::PrivateReader::ClassMethods + def private_reader(*names); end +end + +module Rake::PrivateReader::ClassMethods +end + +module Rake::PrivateReader + def self.included(base); end +end + +class Rake::Promise + def initialize(args, &block); end + + def recorder(); end + + def recorder=(recorder); end + + def value(); end + + def work(); end + NOT_SET = ::T.let(nil, ::T.untyped) +end + +class Rake::Promise +end + +class Rake::PseudoStatus + def >>(n); end + + def exited?(); end + + def exitstatus(); end + + def initialize(code=T.unsafe(nil)); end + + def stopped?(); end + + def to_i(); end +end + +class Rake::PseudoStatus +end + +Rake::RDocTask = RDoc::Task + +class Rake::RuleRecursionOverflowError + def add_target(target); end + + def initialize(*args); end +end + +class Rake::RuleRecursionOverflowError +end + +class Rake::Scope + def path(); end + + def path_with_task_name(task_name); end + + def trim(n); end + EMPTY = ::T.let(nil, ::T.untyped) +end + +class Rake::Scope::EmptyScope + def path(); end + + def path_with_task_name(task_name); end +end + +class Rake::Scope::EmptyScope +end + +class Rake::Scope +end + +class Rake::Task + def actions(); end + + def add_description(description); end + + def all_prerequisite_tasks(); end + + def already_invoked(); end + + def application(); end + + def application=(application); end + + def arg_description(); end + + def arg_names(); end + + def clear(); end + + def clear_actions(); end + + def clear_args(); end + + def clear_comments(); end + + def clear_prerequisites(); end + + def collect_prerequisites(seen); end + + def comment(); end + + def comment=(comment); end + + def enhance(deps=T.unsafe(nil), &block); end + + def execute(args=T.unsafe(nil)); end + + def full_comment(); end + + def initialize(task_name, app); end + + def investigation(); end + + def invoke(*args); end + + def invoke_prerequisites(task_args, invocation_chain); end + + def invoke_prerequisites_concurrently(task_args, invocation_chain); end + + def invoke_with_call_chain(task_args, invocation_chain); end + + def locations(); end + + def name(); end + + def name_with_args(); end + + def needed?(); end + + def old_comment(); end + + def order_only_prerequisites(); end + + def plugin(); end + + def plugin=(plugin); end + + def prereqs(); end + + def prerequisite_tasks(); end + + def prerequisites(); end + + def reenable(); end + + def scope(); end + + def set_arg_names(args); end + + def source(); end + + def sources(); end + + def sources=(sources); end + + def timestamp(); end + + def |(deps); end +end + +class Rake::Task + def self.[](task_name); end + + def self.clear(); end + + def self.create_rule(*args, &block); end + + def self.define_task(*args, &block); end + + def self.format_deps(deps); end + + def self.scope_name(scope, task_name); end + + def self.task_defined?(task_name); end + + def self.tasks(); end +end + +class Rake::TaskArgumentError +end + +class Rake::TaskArgumentError +end + +class Rake::TaskArguments + include ::Enumerable + def [](index); end + + def each(&block); end + + def extras(); end + + def fetch(*args, &block); end + + def has_key?(key); end + + def initialize(names, values, parent=T.unsafe(nil)); end + + def key?(key); end + + def lookup(name); end + + def method_missing(sym, *args); end + + def names(); end + + def new_scope(names); end + + def to_a(); end + + def to_hash(); end + + def values_at(*keys); end + + def with_defaults(defaults); end +end + +class Rake::TaskArguments +end + +class Rake::TaskLib + include ::Rake::Cloneable + include ::Rake::DSL + include ::Rake::FileUtilsExt + include ::FileUtils + include ::FileUtils::StreamUtils_ +end + +class Rake::TaskLib +end + +module Rake::TaskManager + def [](task_name, scopes=T.unsafe(nil)); end + + def all_tasks(); end + + def clear(); end + + def create_rule(*args, &block); end + + def current_scope(); end + + def define_task(task_class, *args, &block); end + + def enhance_with_matching_rule(task_name, level=T.unsafe(nil)); end + + def generate_did_you_mean_suggestions(task_name); end + + def generate_message_for_undefined_task(task_name); end + + def in_namespace(name); end + + def initialize(); end + + def intern(task_class, task_name); end + + def last_description(); end + + def last_description=(last_description); end + + def lookup(task_name, initial_scope=T.unsafe(nil)); end + + def resolve_args(args); end + + def synthesize_file_task(task_name); end + + def tasks(); end + + def tasks_in_scope(scope); end +end + +module Rake::TaskManager + def self.record_task_metadata(); end + + def self.record_task_metadata=(record_task_metadata); end +end + +class Rake::TestTask + def define(); end + + def deps(); end + + def deps=(deps); end + + def description(); end + + def description=(description); end + + def file_list(); end + + def file_list_string(); end + + def find_dir(fn); end + + def find_file(fn); end + + def initialize(name=T.unsafe(nil)); end + + def lib_path(); end + + def libs(); end + + def libs=(libs); end + + def loader(); end + + def loader=(loader); end + + def name(); end + + def name=(name); end + + def option_list(); end + + def options(); end + + def options=(options); end + + def pattern(); end + + def pattern=(pattern); end + + def rake_include_arg(); end + + def rake_lib_dir(); end + + def rake_loader(); end + + def ruby_opts(); end + + def ruby_opts=(ruby_opts); end + + def ruby_opts_string(); end + + def ruby_version(); end + + def run_code(); end + + def test_files=(list); end + + def verbose(); end + + def verbose=(verbose); end + + def warning(); end + + def warning=(warning); end +end + +class Rake::TestTask +end + +class Rake::ThreadHistoryDisplay + include ::Rake::PrivateReader + def initialize(stats); end + + def show(); end +end + +class Rake::ThreadHistoryDisplay + extend ::Rake::PrivateReader::ClassMethods +end + +class Rake::ThreadPool + def future(*args, &block); end + + def gather_history(); end + + def history(); end + + def initialize(thread_count); end + + def join(); end + + def statistics(); end +end + +class Rake::ThreadPool +end + +module Rake::TraceOutput + def trace_on(out, *strings); end +end + +module Rake::TraceOutput +end + +module Rake::Version + BUILD = ::T.let(nil, ::T.untyped) + MAJOR = ::T.let(nil, ::T.untyped) + MINOR = ::T.let(nil, ::T.untyped) + NUMBERS = ::T.let(nil, ::T.untyped) + OTHER = ::T.let(nil, ::T.untyped) +end + +module Rake::Version +end + +module Rake::Win32 +end + +class Rake::Win32::Win32HomeError +end + +class Rake::Win32::Win32HomeError +end + +module Rake::Win32 + def self.normalize(path); end + + def self.win32_system_dir(); end + + def self.windows?(); end +end + +module Rake + extend ::Rake::FileUtilsExt + extend ::FileUtils + extend ::FileUtils::StreamUtils_ + def self.add_rakelib(*files); end + + def self.all_tasks(); end + + def self.application(); end + + def self.application=(app); end + + def self.clear_tasks(*tasks); end + + def self.each_dir_parent(dir); end + + def self.from_pathname(path); end + + def self.load_rakefile(path); end + + def self.original_dir(); end + + def self.suggested_thread_count(); end + + def self.undo(*names); end + + def self.with_application(block_application=T.unsafe(nil)); end +end + +RakeFileUtils = Rake::FileUtilsExt + +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 Readline + def self.completion_quote_character(); end +end + +class Ripper::Filter + def initialize(src, filename=T.unsafe(nil), lineno=T.unsafe(nil)); end +end + +class RubyLex + include ::RubyToken + def Fail(err=T.unsafe(nil), *rest); end + + def Raise(err=T.unsafe(nil), *rest); end + + def char_no(); end + + def each_top_level_statement(); end + + def eof?(); end + + def exception_on_syntax_error(); end + + def exception_on_syntax_error=(exception_on_syntax_error); end + + def get_readed(); end + + def getc(); end + + def getc_of_rests(); end + + def gets(); end + + def identify_comment(); end + + def identify_gvar(); end + + def identify_here_document(); end + + def identify_identifier(); end + + def identify_number(); end + + def identify_quotation(); end + + def identify_string(ltype, quoted=T.unsafe(nil)); end + + def identify_string_dvar(); end + + def indent(); end + + def initialize_input(); end + + def lex(); end + + def lex_init(); end + + def lex_int2(); end + + def line_no(); end + + def peek(i=T.unsafe(nil)); end + + def peek_equal?(str); end + + def peek_match?(regexp); end + + def prompt(); end + + def read_escape(); end + + def readed_auto_clean_up(); end + + def readed_auto_clean_up=(readed_auto_clean_up); end + + def seek(); end + + def set_input(io, p=T.unsafe(nil), &block); end + + def set_prompt(p=T.unsafe(nil), &block); end + + def skip_space(); end + + def skip_space=(skip_space); end + + def token(); end + + def ungetc(c=T.unsafe(nil)); end + DEINDENT_CLAUSE = ::T.let(nil, ::T.untyped) + DLtype2Token = ::T.let(nil, ::T.untyped) + ENINDENT_CLAUSE = ::T.let(nil, ::T.untyped) + Ltype2Token = ::T.let(nil, ::T.untyped) + PERCENT_LTYPE = ::T.let(nil, ::T.untyped) + PERCENT_PAREN = ::T.let(nil, ::T.untyped) +end + +class RubyLex::AlreadyDefinedToken +end + +class RubyLex::AlreadyDefinedToken +end + +class RubyLex::SyntaxError +end + +class RubyLex::SyntaxError +end + +class RubyLex::TerminateLineInput +end + +class RubyLex::TerminateLineInput +end + +class RubyLex::TkReading2TokenDuplicateError +end + +class RubyLex::TkReading2TokenDuplicateError +end + +class RubyLex::TkReading2TokenNoKey +end + +class RubyLex::TkReading2TokenNoKey +end + +class RubyLex::TkSymbol2TokenNoKey +end + +class RubyLex::TkSymbol2TokenNoKey +end + +class RubyLex + extend ::Exception2MessageMapper + def self.debug?(); end + + def self.debug_level(); end + + def self.debug_level=(debug_level); end + + def self.included(mod); end +end + +module RubyToken + def Token(token, value=T.unsafe(nil)); end + EXPR_ARG = ::T.let(nil, ::T.untyped) + EXPR_BEG = ::T.let(nil, ::T.untyped) + EXPR_CLASS = ::T.let(nil, ::T.untyped) + EXPR_DOT = ::T.let(nil, ::T.untyped) + EXPR_END = ::T.let(nil, ::T.untyped) + EXPR_FNAME = ::T.let(nil, ::T.untyped) + EXPR_MID = ::T.let(nil, ::T.untyped) + TkReading2Token = ::T.let(nil, ::T.untyped) + TkSymbol2Token = ::T.let(nil, ::T.untyped) + TokenDefinitions = ::T.let(nil, ::T.untyped) +end + +class RubyToken::TkALIAS +end + +class RubyToken::TkALIAS +end + +class RubyToken::TkAMPER +end + +class RubyToken::TkAMPER +end + +class RubyToken::TkAND +end + +class RubyToken::TkAND +end + +class RubyToken::TkANDOP +end + +class RubyToken::TkANDOP +end + +class RubyToken::TkAREF +end + +class RubyToken::TkAREF +end + +class RubyToken::TkASET +end + +class RubyToken::TkASET +end + +class RubyToken::TkASSIGN +end + +class RubyToken::TkASSIGN +end + +class RubyToken::TkASSOC +end + +class RubyToken::TkASSOC +end + +class RubyToken::TkAT +end + +class RubyToken::TkAT +end + +class RubyToken::TkBACKQUOTE +end + +class RubyToken::TkBACKQUOTE +end + +class RubyToken::TkBACKSLASH +end + +class RubyToken::TkBACKSLASH +end + +class RubyToken::TkBACK_REF +end + +class RubyToken::TkBACK_REF +end + +class RubyToken::TkBEGIN +end + +class RubyToken::TkBEGIN +end + +class RubyToken::TkBITAND +end + +class RubyToken::TkBITAND +end + +class RubyToken::TkBITNOT +end + +class RubyToken::TkBITNOT +end + +class RubyToken::TkBITOR +end + +class RubyToken::TkBITOR +end + +class RubyToken::TkBITXOR +end + +class RubyToken::TkBITXOR +end + +class RubyToken::TkBREAK +end + +class RubyToken::TkBREAK +end + +class RubyToken::TkCASE +end + +class RubyToken::TkCASE +end + +class RubyToken::TkCLASS +end + +class RubyToken::TkCLASS +end + +class RubyToken::TkCMP +end + +class RubyToken::TkCMP +end + +class RubyToken::TkCOLON +end + +class RubyToken::TkCOLON +end + +class RubyToken::TkCOLON2 +end + +class RubyToken::TkCOLON2 +end + +class RubyToken::TkCOLON3 +end + +class RubyToken::TkCOLON3 +end + +class RubyToken::TkCOMMA +end + +class RubyToken::TkCOMMA +end + +class RubyToken::TkCOMMENT +end + +class RubyToken::TkCOMMENT +end + +class RubyToken::TkCONSTANT +end + +class RubyToken::TkCONSTANT +end + +class RubyToken::TkCVAR +end + +class RubyToken::TkCVAR +end + +class RubyToken::TkDEF +end + +class RubyToken::TkDEF +end + +class RubyToken::TkDEFINED +end + +class RubyToken::TkDEFINED +end + +class RubyToken::TkDIV +end + +class RubyToken::TkDIV +end + +class RubyToken::TkDO +end + +class RubyToken::TkDO +end + +class RubyToken::TkDOLLAR +end + +class RubyToken::TkDOLLAR +end + +class RubyToken::TkDOT +end + +class RubyToken::TkDOT +end + +class RubyToken::TkDOT2 +end + +class RubyToken::TkDOT2 +end + +class RubyToken::TkDOT3 +end + +class RubyToken::TkDOT3 +end + +class RubyToken::TkDREGEXP +end + +class RubyToken::TkDREGEXP +end + +class RubyToken::TkDSTRING +end + +class RubyToken::TkDSTRING +end + +class RubyToken::TkDXSTRING +end + +class RubyToken::TkDXSTRING +end + +class RubyToken::TkELSE +end + +class RubyToken::TkELSE +end + +class RubyToken::TkELSIF +end + +class RubyToken::TkELSIF +end + +class RubyToken::TkEND +end + +class RubyToken::TkEND +end + +class RubyToken::TkEND_OF_SCRIPT +end + +class RubyToken::TkEND_OF_SCRIPT +end + +class RubyToken::TkENSURE +end + +class RubyToken::TkENSURE +end + +class RubyToken::TkEQ +end + +class RubyToken::TkEQ +end + +class RubyToken::TkEQQ +end + +class RubyToken::TkEQQ +end + +class RubyToken::TkError +end + +class RubyToken::TkError +end + +class RubyToken::TkFALSE +end + +class RubyToken::TkFALSE +end + +class RubyToken::TkFID +end + +class RubyToken::TkFID +end + +class RubyToken::TkFLOAT +end + +class RubyToken::TkFLOAT +end + +class RubyToken::TkFOR +end + +class RubyToken::TkFOR +end + +class RubyToken::TkGEQ +end + +class RubyToken::TkGEQ +end + +class RubyToken::TkGT +end + +class RubyToken::TkGT +end + +class RubyToken::TkGVAR +end + +class RubyToken::TkGVAR +end + +class RubyToken::TkIDENTIFIER +end + +class RubyToken::TkIDENTIFIER +end + +class RubyToken::TkIF +end + +class RubyToken::TkIF +end + +class RubyToken::TkIF_MOD +end + +class RubyToken::TkIF_MOD +end + +class RubyToken::TkIN +end + +class RubyToken::TkIN +end + +class RubyToken::TkINTEGER +end + +class RubyToken::TkINTEGER +end + +class RubyToken::TkIVAR +end + +class RubyToken::TkIVAR +end + +class RubyToken::TkId + def initialize(seek, line_no, char_no, name); end + + def name(); end +end + +class RubyToken::TkId +end + +class RubyToken::TkLBRACE +end + +class RubyToken::TkLBRACE +end + +class RubyToken::TkLBRACK +end + +class RubyToken::TkLBRACK +end + +class RubyToken::TkLEQ +end + +class RubyToken::TkLEQ +end + +class RubyToken::TkLPAREN +end + +class RubyToken::TkLPAREN +end + +class RubyToken::TkLSHFT +end + +class RubyToken::TkLSHFT +end + +class RubyToken::TkLT +end + +class RubyToken::TkLT +end + +class RubyToken::TkMATCH +end + +class RubyToken::TkMATCH +end + +class RubyToken::TkMINUS +end + +class RubyToken::TkMINUS +end + +class RubyToken::TkMOD +end + +class RubyToken::TkMOD +end + +class RubyToken::TkMODULE +end + +class RubyToken::TkMODULE +end + +class RubyToken::TkMULT +end + +class RubyToken::TkMULT +end + +class RubyToken::TkNEQ +end + +class RubyToken::TkNEQ +end + +class RubyToken::TkNEXT +end + +class RubyToken::TkNEXT +end + +class RubyToken::TkNIL +end + +class RubyToken::TkNIL +end + +class RubyToken::TkNL +end + +class RubyToken::TkNL +end + +class RubyToken::TkNMATCH +end + +class RubyToken::TkNMATCH +end + +class RubyToken::TkNOT +end + +class RubyToken::TkNOT +end + +class RubyToken::TkNOTOP +end + +class RubyToken::TkNOTOP +end + +class RubyToken::TkNTH_REF +end + +class RubyToken::TkNTH_REF +end + +class RubyToken::TkNode + def node(); end +end + +class RubyToken::TkNode +end + +class RubyToken::TkOPASGN + def initialize(seek, line_no, char_no, op); end + + def op(); end +end + +class RubyToken::TkOPASGN +end + +class RubyToken::TkOR +end + +class RubyToken::TkOR +end + +class RubyToken::TkOROP +end + +class RubyToken::TkOROP +end + +class RubyToken::TkOp + def name(); end + + def name=(name); end +end + +class RubyToken::TkOp +end + +class RubyToken::TkPLUS +end + +class RubyToken::TkPLUS +end + +class RubyToken::TkPOW +end + +class RubyToken::TkPOW +end + +class RubyToken::TkQUESTION +end + +class RubyToken::TkQUESTION +end + +class RubyToken::TkRBRACE +end + +class RubyToken::TkRBRACE +end + +class RubyToken::TkRBRACK +end + +class RubyToken::TkRBRACK +end + +class RubyToken::TkRD_COMMENT +end + +class RubyToken::TkRD_COMMENT +end + +class RubyToken::TkREDO +end + +class RubyToken::TkREDO +end + +class RubyToken::TkREGEXP +end + +class RubyToken::TkREGEXP +end + +class RubyToken::TkRESCUE +end + +class RubyToken::TkRESCUE +end + +class RubyToken::TkRETRY +end + +class RubyToken::TkRETRY +end + +class RubyToken::TkRETURN +end + +class RubyToken::TkRETURN +end + +class RubyToken::TkRPAREN +end + +class RubyToken::TkRPAREN +end + +class RubyToken::TkRSHFT +end + +class RubyToken::TkRSHFT +end + +class RubyToken::TkSELF +end + +class RubyToken::TkSELF +end + +class RubyToken::TkSEMICOLON +end + +class RubyToken::TkSEMICOLON +end + +class RubyToken::TkSPACE +end + +class RubyToken::TkSPACE +end + +class RubyToken::TkSTAR +end + +class RubyToken::TkSTAR +end + +class RubyToken::TkSTRING +end + +class RubyToken::TkSTRING +end + +class RubyToken::TkSUPER +end + +class RubyToken::TkSUPER +end + +class RubyToken::TkSYMBEG +end + +class RubyToken::TkSYMBEG +end + +class RubyToken::TkSYMBOL +end + +class RubyToken::TkSYMBOL +end + +class RubyToken::TkTHEN +end + +class RubyToken::TkTHEN +end + +class RubyToken::TkTRUE +end + +class RubyToken::TkTRUE +end + +class RubyToken::TkUMINUS +end + +class RubyToken::TkUMINUS +end + +class RubyToken::TkUNDEF +end + +class RubyToken::TkUNDEF +end + +class RubyToken::TkUNLESS +end + +class RubyToken::TkUNLESS +end + +class RubyToken::TkUNLESS_MOD +end + +class RubyToken::TkUNLESS_MOD +end + +class RubyToken::TkUNTIL +end + +class RubyToken::TkUNTIL +end + +class RubyToken::TkUNTIL_MOD +end + +class RubyToken::TkUNTIL_MOD +end + +class RubyToken::TkUPLUS +end + +class RubyToken::TkUPLUS +end + +class RubyToken::TkUnknownChar + def initialize(seek, line_no, char_no, id); end + + def name(); end +end + +class RubyToken::TkUnknownChar +end + +class RubyToken::TkVal + def initialize(seek, line_no, char_no, value=T.unsafe(nil)); end + + def value(); end +end + +class RubyToken::TkVal +end + +class RubyToken::TkWHEN +end + +class RubyToken::TkWHEN +end + +class RubyToken::TkWHILE +end + +class RubyToken::TkWHILE +end + +class RubyToken::TkWHILE_MOD +end + +class RubyToken::TkWHILE_MOD +end + +class RubyToken::TkXSTRING +end + +class RubyToken::TkXSTRING +end + +class RubyToken::TkYIELD +end + +class RubyToken::TkYIELD +end + +class RubyToken::Tk__FILE__ +end + +class RubyToken::Tk__FILE__ +end + +class RubyToken::Tk__LINE__ +end + +class RubyToken::Tk__LINE__ +end + +class RubyToken::TkfLBRACE +end + +class RubyToken::TkfLBRACE +end + +class RubyToken::TkfLBRACK +end + +class RubyToken::TkfLBRACK +end + +class RubyToken::TkfLPAREN +end + +class RubyToken::TkfLPAREN +end + +class RubyToken::TklBEGIN +end + +class RubyToken::TklBEGIN +end + +class RubyToken::TklEND +end + +class RubyToken::TklEND +end + +class RubyToken::Token + def char_no(); end + + def initialize(seek, line_no, char_no); end + + def line_no(); end + + def seek(); end +end + +class RubyToken::Token +end + +module RubyToken + def self.def_token(token_n, super_token=T.unsafe(nil), reading=T.unsafe(nil), *opts); 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 pretty_print_children(q, names=T.unsafe(nil)); end + + def type(); end +end + +class RubyVM::AbstractSyntaxTree::Node +end + +module RubyVM::AbstractSyntaxTree + def self.of(_); end + + def self.parse(_); end + + def self.parse_file(_); end +end + +module RubyVM::MJIT +end + +module RubyVM::MJIT + def self.enabled?(); end + + def self.pause(*_); end + + def self.resume(); end +end + +class RubyVM + def self.resolve_feature_path(_); end +end + +ScanError = StringScanner::Error + +class Set + def ==(other); end + + def ===(o); end + + def compare_by_identity(); end + + def compare_by_identity?(); end + + def divide(&func); end + + def eql?(o); end + + def flatten_merge(set, seen=T.unsafe(nil)); end + + def pretty_print(pp); end + + def pretty_print_cycle(pp); end + + def reset(); end + InspectKey = ::T.let(nil, ::T.untyped) +end + +module SimpleCov + VERSION = ::T.let(nil, ::T.untyped) +end + +class SimpleCov::ArrayFilter + def matches?(source_files_list); end +end + +class SimpleCov::ArrayFilter +end + +class SimpleCov::BlockFilter + def matches?(source_file); end +end + +class SimpleCov::BlockFilter +end + +module SimpleCov::Combine +end + +module SimpleCov::Combine::BranchesCombiner +end + +module SimpleCov::Combine::BranchesCombiner + def self.combine(coverage_a, coverage_b); end +end + +module SimpleCov::Combine::FilesCombiner +end + +module SimpleCov::Combine::FilesCombiner + def self.combine(coverage_a, coverage_b); end +end + +module SimpleCov::Combine::LinesCombiner +end + +module SimpleCov::Combine::LinesCombiner + def self.combine(coverage_a, coverage_b); end + + def self.merge_line_coverage(first_val, second_val); end +end + +module SimpleCov::Combine::ResultsCombiner +end + +module SimpleCov::Combine::ResultsCombiner + def self.combine(*results); end + + def self.combine_file_coverage(coverage_a, coverage_b); end + + def self.combine_result_sets(combined_results, result); end +end + +module SimpleCov::Combine + def self.combine(combiner_module, coverage_a, coverage_b); end + + def self.empty_coverage?(coverage_a, coverage_b); end + + def self.existing_coverage(coverage_a, coverage_b); end +end + +module SimpleCov::CommandGuesser +end + +module SimpleCov::CommandGuesser + def self.guess(); end + + def self.original_run_command(); end + + def self.original_run_command=(original_run_command); end +end + +module SimpleCov::Configuration + def adapters(); end + + def add_filter(filter_argument=T.unsafe(nil), &filter_proc); end + + def add_group(group_name, filter_argument=T.unsafe(nil), &filter_proc); end + + def at_exit(&block); end + + def branch_coverage?(); end + + def branch_coverage_supported?(); end + + def clear_coverage_criteria(); end + + def command_name(name=T.unsafe(nil)); end + + def configure(&block); end + + def coverage_criteria(); end + + def coverage_criterion(criterion=T.unsafe(nil)); end + + def coverage_criterion_enabled?(criterion); end + + def coverage_dir(dir=T.unsafe(nil)); end + + def coverage_path(); end + + def coverage_start_arguments_supported?(); end + + def enable_coverage(criterion); end + + def filters(); end + + def filters=(filters); end + + def formatter(formatter=T.unsafe(nil)); end + + def formatter=(formatter); end + + def formatters(); end + + def formatters=(formatters); end + + def groups(); end + + def groups=(groups); end + + def maximum_coverage_drop(coverage_drop=T.unsafe(nil)); end + + def merge_timeout(seconds=T.unsafe(nil)); end + + def minimum_coverage(coverage=T.unsafe(nil)); end + + def minimum_coverage_by_file(coverage=T.unsafe(nil)); end + + def nocov_token(nocov_token=T.unsafe(nil)); end + + def print_error_status(); end + + def print_error_status=(print_error_status); end + + def profiles(); end + + def project_name(new_name=T.unsafe(nil)); end + + def refuse_coverage_drop(); end + + def root(root=T.unsafe(nil)); end + + def skip_token(nocov_token=T.unsafe(nil)); end + + def track_files(glob); end + + def tracked_files(); end + + def use_merging(use=T.unsafe(nil)); end + DEFAULT_COVERAGE_CRITERION = ::T.let(nil, ::T.untyped) + SUPPORTED_COVERAGE_CRITERIA = ::T.let(nil, ::T.untyped) +end + +module SimpleCov::Configuration +end + +class SimpleCov::CoverageStatistics + def covered(); end + + def initialize(covered:, missed:, total_strength: T.unsafe(nil)); end + + def missed(); end + + def percent(); end + + def strength(); end + + def total(); end +end + +class SimpleCov::CoverageStatistics + def self.from(coverage_statistics); end +end + +module SimpleCov::ExitCodes + EXCEPTION = ::T.let(nil, ::T.untyped) + MAXIMUM_COVERAGE_DROP = ::T.let(nil, ::T.untyped) + MINIMUM_COVERAGE = ::T.let(nil, ::T.untyped) + SUCCESS = ::T.let(nil, ::T.untyped) +end + +module SimpleCov::ExitCodes +end + +class SimpleCov::FileList + include ::Enumerable + def branch_covered_percent(); end + + def count(*args, &block); end + + def coverage_statistics(); end + + def covered_branches(); end + + def covered_lines(); end + + def covered_percent(); end + + def covered_percentages(); end + + def covered_strength(); end + + def each(*args, &block); end + + def empty?(*args, &block); end + + def initialize(files); end + + def least_covered_file(); end + + def length(*args, &block); end + + def lines_of_code(); end + + def map(*args, &block); end + + def missed_branches(); end + + def missed_lines(); end + + def never_lines(); end + + def size(*args, &block); end + + def skipped_lines(); end + + def to_a(*args, &block); end + + def to_ary(*args, &block); end + + def total_branches(); end +end + +class SimpleCov::FileList + extend ::Forwardable +end + +class SimpleCov::Filter + def filter_argument(); end + + def initialize(filter_argument); end + + def matches?(_source_file); end + + def passes?(source_file); end +end + +class SimpleCov::Filter + def self.build_filter(filter_argument); end + + def self.class_for_argument(filter_argument); end +end + +module SimpleCov::Formatter +end + +class SimpleCov::Formatter::HTMLFormatter + def branchable_result?(); end + + def format(result); end + + def line_status?(source_file, line); end + + def output_message(result); end + VERSION = ::T.let(nil, ::T.untyped) +end + +class SimpleCov::Formatter::HTMLFormatter +end + +class SimpleCov::Formatter::MultiFormatter +end + +module SimpleCov::Formatter::MultiFormatter::InstanceMethods + def format(result); end +end + +module SimpleCov::Formatter::MultiFormatter::InstanceMethods +end + +class SimpleCov::Formatter::MultiFormatter + def self.[](*args); end + + def self.new(formatters=T.unsafe(nil)); end +end + +class SimpleCov::Formatter::SimpleFormatter + def format(result); end +end + +class SimpleCov::Formatter::SimpleFormatter +end + +module SimpleCov::Formatter +end + +module SimpleCov::LastRun +end + +module SimpleCov::LastRun + def self.last_run_path(); end + + def self.read(); end + + def self.write(json); end +end + +class SimpleCov::LinesClassifier + def classify(lines); end + COMMENT_LINE = ::T.let(nil, ::T.untyped) + NOT_RELEVANT = ::T.let(nil, ::T.untyped) + RELEVANT = ::T.let(nil, ::T.untyped) + WHITESPACE_LINE = ::T.let(nil, ::T.untyped) + WHITESPACE_OR_COMMENT_LINE = ::T.let(nil, ::T.untyped) +end + +class SimpleCov::LinesClassifier + def self.no_cov_line(); end + + def self.no_cov_line?(line); end + + def self.whitespace_line?(line); end +end + +class SimpleCov::Profiles + def define(name, &blk); end + + def load(name); end +end + +class SimpleCov::Profiles +end + +class SimpleCov::RegexFilter + def matches?(source_file); end +end + +class SimpleCov::RegexFilter +end + +class SimpleCov::Result + def command_name(); end + + def command_name=(command_name); end + + def coverage_statistics(*args, &block); end + + def covered_branches(*args, &block); end + + def covered_lines(*args, &block); end + + def covered_percent(*args, &block); end + + def covered_percentages(*args, &block); end + + def covered_strength(*args, &block); end + + def created_at(); end + + def created_at=(created_at); end + + def filenames(); end + + def files(); end + + def format!(); end + + def groups(); end + + def initialize(original_result); end + + def least_covered_file(*args, &block); end + + def missed_branches(*args, &block); end + + def missed_lines(*args, &block); end + + def original_result(); end + + def source_files(); end + + def to_hash(); end + + def total_branches(*args, &block); end + + def total_lines(*args, &block); end +end + +class SimpleCov::Result + extend ::Forwardable + def self.from_hash(hash); end +end + +class SimpleCov::ResultAdapter + def adapt(); end + + def initialize(result); end + + def result(); end +end + +class SimpleCov::ResultAdapter + def self.call(*args); end +end + +module SimpleCov::ResultMerger +end + +module SimpleCov::ResultMerger + def self.clear_resultset(); end + + def self.merge_and_store(*results); end + + def self.merge_results(*results); end + + def self.merged_result(); end + + def self.results(); end + + def self.resultset(); end + + def self.resultset_path(); end + + def self.resultset_writelock(); end + + def self.store_result(result); end + + def self.stored_data(); end + + def self.synchronize_resultset(); end +end + +module SimpleCov::SimulateCoverage +end + +module SimpleCov::SimulateCoverage + def self.call(absolute_path); end +end + +class SimpleCov::SourceFile + def branches(); end + + def branches_coverage_percent(); end + + def branches_for_line(line_number); end + + def branches_report(); end + + def coverage_data(); end + + def coverage_statistics(); end + + def covered_branches(); end + + def covered_lines(); end + + def covered_percent(); end + + def covered_strength(); end + + def filename(); end + + def initialize(filename, coverage_data); end + + def line(number); end + + def line_with_missed_branch?(line_number); end + + def lines(); end + + def lines_of_code(); end + + def missed_branches(); end + + def missed_lines(); end + + def never_lines(); end + + def no_branches?(); end + + def no_lines?(); end + + def project_filename(); end + + def relevant_lines(); end + + def skipped_lines(); end + + def source(); end + + def source_lines(); end + + def src(); end + + def total_branches(); end + RUBY_FILE_ENCODING_MAGIC_COMMENT_REGEX = ::T.let(nil, ::T.untyped) + SHEBANG_REGEX = ::T.let(nil, ::T.untyped) +end + +class SimpleCov::SourceFile::Branch + def coverage(); end + + def covered?(); end + + def end_line(); end + + def initialize(start_line:, end_line:, coverage:, inline:, type:); end + + def inline?(); end + + def missed?(); end + + def overlaps_with?(line_range); end + + def report(); end + + def report_line(); end + + def skipped!(); end + + def skipped?(); end + + def start_line(); end + + def type(); end +end + +class SimpleCov::SourceFile::Branch +end + +class SimpleCov::SourceFile::Line + def coverage(); end + + def covered?(); end + + def initialize(src, line_number, coverage); end + + def line(); end + + def line_number(); end + + def missed?(); end + + def never?(); end + + def number(); end + + def skipped(); end + + def skipped!(); end + + def skipped?(); end + + def source(); end + + def src(); end + + def status(); end +end + +class SimpleCov::SourceFile::Line +end + +class SimpleCov::SourceFile +end + +class SimpleCov::StringFilter + def matches?(source_file); end +end + +class SimpleCov::StringFilter +end + +module SimpleCov::UselessResultsRemover + ROOT_REGX = ::T.let(nil, ::T.untyped) +end + +module SimpleCov::UselessResultsRemover + def self.call(coverage_result); end +end + +module SimpleCov + extend ::SimpleCov::Configuration + def self.at_exit_behavior(); end + + def self.clear_result(); end + + def self.collate(result_filenames, profile=T.unsafe(nil), &block); end + + def self.exit_exception(); end + + def self.exit_status_from_exception(); end + + def self.external_at_exit(); end + + def self.external_at_exit=(external_at_exit); end + + def self.external_at_exit?(); end + + def self.filtered(files); end + + def self.final_result_process?(); end + + def self.grouped(files); end + + def self.load_adapter(name); end + + def self.load_profile(name); end + + def self.pid(); end + + def self.pid=(pid); end + + def self.process_result(result, exit_status); end + + def self.result(); end + + def self.result?(); end + + def self.result_exit_status(result, covered_percent); end + + def self.run_exit_tasks!(); end + + def self.running(); end + + def self.running=(running); end + + def self.set_exit_exception(); end + + def self.start(profile=T.unsafe(nil), &block); end + + def self.wait_for_other_processes(); end + + def self.write_last_run(covered_percent); end +end + +module Singleton + def _dump(depth=T.unsafe(nil)); end + + def clone(); end + + def dup(); end +end + +module Singleton::SingletonClassMethods + def _load(str); end + + def clone(); end +end + +module Singleton + def self.__init__(klass); end +end + +class Socket + AF_CCITT = ::T.let(nil, ::T.untyped) + AF_CHAOS = ::T.let(nil, ::T.untyped) + AF_CNT = ::T.let(nil, ::T.untyped) + AF_COIP = ::T.let(nil, ::T.untyped) + AF_DATAKIT = ::T.let(nil, ::T.untyped) + AF_DLI = ::T.let(nil, ::T.untyped) + AF_E164 = ::T.let(nil, ::T.untyped) + AF_ECMA = ::T.let(nil, ::T.untyped) + AF_HYLINK = ::T.let(nil, ::T.untyped) + AF_IMPLINK = ::T.let(nil, ::T.untyped) + AF_ISO = ::T.let(nil, ::T.untyped) + AF_LAT = ::T.let(nil, ::T.untyped) + AF_LINK = ::T.let(nil, ::T.untyped) + AF_NATM = ::T.let(nil, ::T.untyped) + AF_NDRV = ::T.let(nil, ::T.untyped) + AF_NETBIOS = ::T.let(nil, ::T.untyped) + AF_NS = ::T.let(nil, ::T.untyped) + AF_OSI = ::T.let(nil, ::T.untyped) + AF_PPP = ::T.let(nil, ::T.untyped) + AF_PUP = ::T.let(nil, ::T.untyped) + AF_SIP = ::T.let(nil, ::T.untyped) + AF_SYSTEM = ::T.let(nil, ::T.untyped) + AI_DEFAULT = ::T.let(nil, ::T.untyped) + AI_MASK = ::T.let(nil, ::T.untyped) + AI_V4MAPPED_CFG = ::T.let(nil, ::T.untyped) + EAI_BADHINTS = ::T.let(nil, ::T.untyped) + EAI_MAX = ::T.let(nil, ::T.untyped) + EAI_PROTOCOL = ::T.let(nil, ::T.untyped) + IFF_ALTPHYS = ::T.let(nil, ::T.untyped) + IFF_LINK0 = ::T.let(nil, ::T.untyped) + IFF_LINK1 = ::T.let(nil, ::T.untyped) + IFF_LINK2 = ::T.let(nil, ::T.untyped) + IFF_OACTIVE = ::T.let(nil, ::T.untyped) + IFF_SIMPLEX = ::T.let(nil, ::T.untyped) + IPPROTO_EON = ::T.let(nil, ::T.untyped) + IPPROTO_GGP = ::T.let(nil, ::T.untyped) + IPPROTO_HELLO = ::T.let(nil, ::T.untyped) + IPPROTO_MAX = ::T.let(nil, ::T.untyped) + IPPROTO_ND = ::T.let(nil, ::T.untyped) + IPPROTO_XTP = ::T.let(nil, ::T.untyped) + IPV6_DONTFRAG = ::T.let(nil, ::T.untyped) + IPV6_PATHMTU = ::T.let(nil, ::T.untyped) + IPV6_RECVPATHMTU = ::T.let(nil, ::T.untyped) + IPV6_USE_MIN_MTU = ::T.let(nil, ::T.untyped) + IP_PORTRANGE = ::T.let(nil, ::T.untyped) + IP_RECVDSTADDR = ::T.let(nil, ::T.untyped) + IP_RECVIF = ::T.let(nil, ::T.untyped) + LOCAL_PEERCRED = ::T.let(nil, ::T.untyped) + MSG_EOF = ::T.let(nil, ::T.untyped) + MSG_FLUSH = ::T.let(nil, ::T.untyped) + MSG_HAVEMORE = ::T.let(nil, ::T.untyped) + MSG_HOLD = ::T.let(nil, ::T.untyped) + MSG_RCVMORE = ::T.let(nil, ::T.untyped) + MSG_SEND = ::T.let(nil, ::T.untyped) + PF_CCITT = ::T.let(nil, ::T.untyped) + PF_CHAOS = ::T.let(nil, ::T.untyped) + PF_CNT = ::T.let(nil, ::T.untyped) + PF_COIP = ::T.let(nil, ::T.untyped) + PF_DATAKIT = ::T.let(nil, ::T.untyped) + PF_DLI = ::T.let(nil, ::T.untyped) + PF_ECMA = ::T.let(nil, ::T.untyped) + PF_HYLINK = ::T.let(nil, ::T.untyped) + PF_IMPLINK = ::T.let(nil, ::T.untyped) + PF_ISO = ::T.let(nil, ::T.untyped) + PF_LAT = ::T.let(nil, ::T.untyped) + PF_LINK = ::T.let(nil, ::T.untyped) + PF_NATM = ::T.let(nil, ::T.untyped) + PF_NDRV = ::T.let(nil, ::T.untyped) + PF_NETBIOS = ::T.let(nil, ::T.untyped) + PF_NS = ::T.let(nil, ::T.untyped) + PF_OSI = ::T.let(nil, ::T.untyped) + PF_PIP = ::T.let(nil, ::T.untyped) + PF_PPP = ::T.let(nil, ::T.untyped) + PF_PUP = ::T.let(nil, ::T.untyped) + PF_RTIP = ::T.let(nil, ::T.untyped) + PF_SIP = ::T.let(nil, ::T.untyped) + PF_SYSTEM = ::T.let(nil, ::T.untyped) + PF_XTP = ::T.let(nil, ::T.untyped) + SCM_CREDS = ::T.let(nil, ::T.untyped) + SO_DONTTRUNC = ::T.let(nil, ::T.untyped) + SO_NKE = ::T.let(nil, ::T.untyped) + SO_NOSIGPIPE = ::T.let(nil, ::T.untyped) + SO_NREAD = ::T.let(nil, ::T.untyped) + SO_USELOOPBACK = ::T.let(nil, ::T.untyped) + SO_WANTMORE = ::T.let(nil, ::T.untyped) + SO_WANTOOBFLAG = ::T.let(nil, ::T.untyped) + TCP_NOOPT = ::T.let(nil, ::T.untyped) + TCP_NOPUSH = ::T.let(nil, ::T.untyped) +end + +module Socket::Constants + AF_CCITT = ::T.let(nil, ::T.untyped) + AF_CHAOS = ::T.let(nil, ::T.untyped) + AF_CNT = ::T.let(nil, ::T.untyped) + AF_COIP = ::T.let(nil, ::T.untyped) + AF_DATAKIT = ::T.let(nil, ::T.untyped) + AF_DLI = ::T.let(nil, ::T.untyped) + AF_E164 = ::T.let(nil, ::T.untyped) + AF_ECMA = ::T.let(nil, ::T.untyped) + AF_HYLINK = ::T.let(nil, ::T.untyped) + AF_IMPLINK = ::T.let(nil, ::T.untyped) + AF_ISO = ::T.let(nil, ::T.untyped) + AF_LAT = ::T.let(nil, ::T.untyped) + AF_LINK = ::T.let(nil, ::T.untyped) + AF_NATM = ::T.let(nil, ::T.untyped) + AF_NDRV = ::T.let(nil, ::T.untyped) + AF_NETBIOS = ::T.let(nil, ::T.untyped) + AF_NS = ::T.let(nil, ::T.untyped) + AF_OSI = ::T.let(nil, ::T.untyped) + AF_PPP = ::T.let(nil, ::T.untyped) + AF_PUP = ::T.let(nil, ::T.untyped) + AF_SIP = ::T.let(nil, ::T.untyped) + AF_SYSTEM = ::T.let(nil, ::T.untyped) + AI_DEFAULT = ::T.let(nil, ::T.untyped) + AI_MASK = ::T.let(nil, ::T.untyped) + AI_V4MAPPED_CFG = ::T.let(nil, ::T.untyped) + EAI_BADHINTS = ::T.let(nil, ::T.untyped) + EAI_MAX = ::T.let(nil, ::T.untyped) + EAI_PROTOCOL = ::T.let(nil, ::T.untyped) + IFF_ALTPHYS = ::T.let(nil, ::T.untyped) + IFF_LINK0 = ::T.let(nil, ::T.untyped) + IFF_LINK1 = ::T.let(nil, ::T.untyped) + IFF_LINK2 = ::T.let(nil, ::T.untyped) + IFF_OACTIVE = ::T.let(nil, ::T.untyped) + IFF_SIMPLEX = ::T.let(nil, ::T.untyped) + IPPROTO_EON = ::T.let(nil, ::T.untyped) + IPPROTO_GGP = ::T.let(nil, ::T.untyped) + IPPROTO_HELLO = ::T.let(nil, ::T.untyped) + IPPROTO_MAX = ::T.let(nil, ::T.untyped) + IPPROTO_ND = ::T.let(nil, ::T.untyped) + IPPROTO_XTP = ::T.let(nil, ::T.untyped) + IPV6_DONTFRAG = ::T.let(nil, ::T.untyped) + IPV6_PATHMTU = ::T.let(nil, ::T.untyped) + IPV6_RECVPATHMTU = ::T.let(nil, ::T.untyped) + IPV6_USE_MIN_MTU = ::T.let(nil, ::T.untyped) + IP_PORTRANGE = ::T.let(nil, ::T.untyped) + IP_RECVDSTADDR = ::T.let(nil, ::T.untyped) + IP_RECVIF = ::T.let(nil, ::T.untyped) + LOCAL_PEERCRED = ::T.let(nil, ::T.untyped) + MSG_EOF = ::T.let(nil, ::T.untyped) + MSG_FLUSH = ::T.let(nil, ::T.untyped) + MSG_HAVEMORE = ::T.let(nil, ::T.untyped) + MSG_HOLD = ::T.let(nil, ::T.untyped) + MSG_RCVMORE = ::T.let(nil, ::T.untyped) + MSG_SEND = ::T.let(nil, ::T.untyped) + PF_CCITT = ::T.let(nil, ::T.untyped) + PF_CHAOS = ::T.let(nil, ::T.untyped) + PF_CNT = ::T.let(nil, ::T.untyped) + PF_COIP = ::T.let(nil, ::T.untyped) + PF_DATAKIT = ::T.let(nil, ::T.untyped) + PF_DLI = ::T.let(nil, ::T.untyped) + PF_ECMA = ::T.let(nil, ::T.untyped) + PF_HYLINK = ::T.let(nil, ::T.untyped) + PF_IMPLINK = ::T.let(nil, ::T.untyped) + PF_ISO = ::T.let(nil, ::T.untyped) + PF_LAT = ::T.let(nil, ::T.untyped) + PF_LINK = ::T.let(nil, ::T.untyped) + PF_NATM = ::T.let(nil, ::T.untyped) + PF_NDRV = ::T.let(nil, ::T.untyped) + PF_NETBIOS = ::T.let(nil, ::T.untyped) + PF_NS = ::T.let(nil, ::T.untyped) + PF_OSI = ::T.let(nil, ::T.untyped) + PF_PIP = ::T.let(nil, ::T.untyped) + PF_PPP = ::T.let(nil, ::T.untyped) + PF_PUP = ::T.let(nil, ::T.untyped) + PF_RTIP = ::T.let(nil, ::T.untyped) + PF_SIP = ::T.let(nil, ::T.untyped) + PF_SYSTEM = ::T.let(nil, ::T.untyped) + PF_XTP = ::T.let(nil, ::T.untyped) + SCM_CREDS = ::T.let(nil, ::T.untyped) + SO_DONTTRUNC = ::T.let(nil, ::T.untyped) + SO_NKE = ::T.let(nil, ::T.untyped) + SO_NOSIGPIPE = ::T.let(nil, ::T.untyped) + SO_NREAD = ::T.let(nil, ::T.untyped) + SO_USELOOPBACK = ::T.let(nil, ::T.untyped) + SO_WANTMORE = ::T.let(nil, ::T.untyped) + SO_WANTOOBFLAG = ::T.let(nil, ::T.untyped) + TCP_NOOPT = ::T.let(nil, ::T.untyped) + TCP_NOPUSH = ::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 ext(newext=T.unsafe(nil)); end + + def pathmap(spec=T.unsafe(nil), &block); end + + def pathmap_explode(); end + + def pathmap_partial(n); end + + def pathmap_replace(patterns, &block); end + + def shellescape(); end + + def shellsplit(); end +end + +class String + extend ::JSON::Ext::Generator::GeneratorMethods::String::Extend +end + +class StringScanner + def bol?(); end + + def initialize(*_); end + Id = ::T.let(nil, ::T.untyped) + Version = ::T.let(nil, ::T.untyped) +end + +class Struct + def filter(*_); end +end + +Struct::Group = Etc::Group + +Struct::Passwd = Etc::Passwd + +Struct::Tms = Process::Tms + +class TracePoint + def __enable(_, _1); end + + def eval_script(); end + + def instruction_sequence(); end + + def parameters(); end +end + +class TrueClass + include ::JSON::Ext::Generator::GeneratorMethods::TrueClass +end + +module URI + include ::URI::RFC2396_REGEXP +end + +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 + |