From 235ff6c2bd8a1fdefa0a2749a04e744154ce4512 Mon Sep 17 00:00:00 2001 From: cn Date: Fri, 28 Feb 2020 16:00:28 +0100 Subject: [PATCH] gem: add sorbet support --- .gitignore | 1 + CHANGELOG.md | 1 + Rakefile | 6 +- dyndnsd.gemspec | 2 + lib/dyndnsd.rb | 1 + lib/dyndnsd/database.rb | 1 + lib/dyndnsd/generator/bind.rb | 1 + lib/dyndnsd/helper.rb | 1 + lib/dyndnsd/responder/dyndns_style.rb | 1 + lib/dyndnsd/responder/rest_style.rb | 1 + lib/dyndnsd/textfile_reporter.rb | 1 + lib/dyndnsd/updater/command_with_bind_zone.rb | 1 + lib/dyndnsd/version.rb | 1 + sorbet/config | 2 + sorbet/rbi/hidden-definitions/hidden.rbi | 26236 ++++++++++++++++ sorbet/rbi/jaeger-client.rbi | 5 + sorbet/rbi/rack.rbi | 5 + .../sorbet-typed/lib/bundler/all/bundler.rbi | 8684 +++++ .../sorbet-typed/lib/rainbow/all/rainbow.rbi | 276 + sorbet/rbi/sorbet-typed/lib/ruby/all/gem.rbi | 4222 +++ .../rbi/sorbet-typed/lib/ruby/all/open3.rbi | 111 + .../rbi/sorbet-typed/lib/ruby/all/resolv.rbi | 543 + spec/daemon_spec.rb | 1 + spec/spec_helper.rb | 1 + spec/support/dummy_database.rb | 1 + spec/support/dummy_updater.rb | 1 + 26 files changed, 40106 insertions(+), 1 deletion(-) create mode 100644 sorbet/config create mode 100644 sorbet/rbi/hidden-definitions/hidden.rbi create mode 100644 sorbet/rbi/jaeger-client.rbi create mode 100644 sorbet/rbi/rack.rbi create mode 100644 sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi create mode 100644 sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi create mode 100644 sorbet/rbi/sorbet-typed/lib/ruby/all/gem.rbi create mode 100644 sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi create mode 100644 sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi diff --git a/.gitignore b/.gitignore index 8c23188..ede5b2a 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ .DS_Store *.lock pkg/* +sorbet/rbi/hidden-definitions/errors.txt diff --git a/CHANGELOG.md b/CHANGELOG.md index c671c2e..69813ac 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,7 @@ IMPROVEMENTS: - Add Ruby 2.7 support +- Add experimental [Sorbet](https://sorbet.org) support to development tools, fix surfaced problems ## 2.0.0 (January 25, 2019) diff --git a/Rakefile b/Rakefile index 538a5a5..3bd6982 100644 --- a/Rakefile +++ b/Rakefile @@ -7,4 +7,8 @@ RSpec::Core::RakeTask.new(:spec) RuboCop::RakeTask.new Bundler::Audit::Task.new -task default: [:rubocop, :spec, 'bundle:audit'] +task :sorbet do + sh 'srb typecheck' +end + +task default: [:rubocop, :sorbet, :spec, 'bundle:audit'] diff --git a/dyndnsd.gemspec b/dyndnsd.gemspec index 928cfa2..95f5ebc 100644 --- a/dyndnsd.gemspec +++ b/dyndnsd.gemspec @@ -26,6 +26,7 @@ Gem::Specification.new do |s| s.add_runtime_dependency 'opentracing', '~> 0.5.0' s.add_runtime_dependency 'rack-tracer', '~> 0.9.0' s.add_runtime_dependency 'jaeger-client', '~> 0.10.0' + s.add_runtime_dependency 'sorbet-runtime', '~> 0.5.0' s.add_development_dependency 'bundler' s.add_development_dependency 'rake' @@ -33,4 +34,5 @@ Gem::Specification.new do |s| s.add_development_dependency 'rack-test' s.add_development_dependency 'rubocop', '~> 0.80.0' s.add_development_dependency 'bundler-audit', '~> 0.6.0' + s.add_development_dependency 'sorbet', '~> 0.5.0' end diff --git a/lib/dyndnsd.rb b/lib/dyndnsd.rb index 2981f83..aadab3a 100755 --- a/lib/dyndnsd.rb +++ b/lib/dyndnsd.rb @@ -1,4 +1,5 @@ #!/usr/bin/env ruby +# typed: true require 'etc' require 'logger' diff --git a/lib/dyndnsd/database.rb b/lib/dyndnsd/database.rb index 7ae6c21..e3a9886 100644 --- a/lib/dyndnsd/database.rb +++ b/lib/dyndnsd/database.rb @@ -1,3 +1,4 @@ +# typed: true require 'forwardable' diff --git a/lib/dyndnsd/generator/bind.rb b/lib/dyndnsd/generator/bind.rb index 213ff85..5429018 100644 --- a/lib/dyndnsd/generator/bind.rb +++ b/lib/dyndnsd/generator/bind.rb @@ -1,3 +1,4 @@ +# typed: true module Dyndnsd module Generator diff --git a/lib/dyndnsd/helper.rb b/lib/dyndnsd/helper.rb index 0184735..dbf548a 100644 --- a/lib/dyndnsd/helper.rb +++ b/lib/dyndnsd/helper.rb @@ -1,3 +1,4 @@ +# typed: true require 'ipaddr' diff --git a/lib/dyndnsd/responder/dyndns_style.rb b/lib/dyndnsd/responder/dyndns_style.rb index 51f829a..b195a36 100644 --- a/lib/dyndnsd/responder/dyndns_style.rb +++ b/lib/dyndnsd/responder/dyndns_style.rb @@ -1,3 +1,4 @@ +# typed: true module Dyndnsd module Responder diff --git a/lib/dyndnsd/responder/rest_style.rb b/lib/dyndnsd/responder/rest_style.rb index e2e0b8d..4cf9d85 100644 --- a/lib/dyndnsd/responder/rest_style.rb +++ b/lib/dyndnsd/responder/rest_style.rb @@ -1,3 +1,4 @@ +# typed: true module Dyndnsd module Responder diff --git a/lib/dyndnsd/textfile_reporter.rb b/lib/dyndnsd/textfile_reporter.rb index a19993c..f5515f9 100644 --- a/lib/dyndnsd/textfile_reporter.rb +++ b/lib/dyndnsd/textfile_reporter.rb @@ -1,3 +1,4 @@ +# typed: true # Adapted from https://github.com/eric/metriks-graphite/blob/master/lib/metriks/reporter/graphite.rb diff --git a/lib/dyndnsd/updater/command_with_bind_zone.rb b/lib/dyndnsd/updater/command_with_bind_zone.rb index d15dfd7..4fb561c 100644 --- a/lib/dyndnsd/updater/command_with_bind_zone.rb +++ b/lib/dyndnsd/updater/command_with_bind_zone.rb @@ -1,3 +1,4 @@ +# typed: true module Dyndnsd module Updater diff --git a/lib/dyndnsd/version.rb b/lib/dyndnsd/version.rb index af416f9..7642f78 100644 --- a/lib/dyndnsd/version.rb +++ b/lib/dyndnsd/version.rb @@ -1,3 +1,4 @@ +# typed: true module Dyndnsd VERSION = '2.0.0'.freeze diff --git a/sorbet/config b/sorbet/config new file mode 100644 index 0000000..7fb7a8e --- /dev/null +++ b/sorbet/config @@ -0,0 +1,2 @@ +--dir +. diff --git a/sorbet/rbi/hidden-definitions/hidden.rbi b/sorbet/rbi/hidden-definitions/hidden.rbi new file mode 100644 index 0000000..81e48f1 --- /dev/null +++ b/sorbet/rbi/hidden-definitions/hidden.rbi @@ -0,0 +1,26236 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi hidden-definitions + +# typed: autogenerated + +module AST +end + +class AST::Node + def +(array); end + + def <<(element); end + + def ==(other); end + + def append(element); end + + def assign_properties(properties); end + + def children(); end + + def clone(); end + + def concat(array); end + + def eql?(other); end + + def fancy_type(); end + + def initialize(type, children=T.unsafe(nil), properties=T.unsafe(nil)); end + + def inspect(indent=T.unsafe(nil)); end + + def to_a(); end + + def to_ast(); end + + def to_s(indent=T.unsafe(nil)); end + + def to_sexp(indent=T.unsafe(nil)); end + + def to_sexp_array(); end + + def type(); end + + def updated(type=T.unsafe(nil), children=T.unsafe(nil), properties=T.unsafe(nil)); end +end + +class AST::Node +end + +class AST::Processor + include ::AST::Processor::Mixin +end + +module AST::Processor::Mixin + def handler_missing(node); end + + def process(node); end + + def process_all(nodes); end +end + +module AST::Processor::Mixin +end + +class AST::Processor +end + +module AST::Sexp + def s(type, *children); end +end + +module AST::Sexp +end + +module AST +end + +class Addrinfo + def connect_internal(local_addrinfo, timeout=T.unsafe(nil)); end +end + +class Array + include ::JSON::Ext::Generator::GeneratorMethods::Array + def bsearch(); end + + def bsearch_index(); end + + def collect!(); end + + def dig(*_); end + + def flatten!(*_); end + + def pack(*_); end + + def replace(_); end + + def shelljoin(); end + + def to_h(); end +end + +class Array + def self.try_convert(_); end +end + +class Atomic + def _compare_and_set(_, _1); end + + def compare_and_set(expected, new); end + + def compare_and_swap(expected, new); end + + def get(); end + + def get_and_set(_); end + + def initialize(*_); end + + def set(_); end + + def swap(_); end + + def try_update(); end + + def update(); end + + def value(); end + + def value=(value); end +end + +class Atomic::ConcurrentUpdateError + CONC_UP_ERR_BACKTRACE = ::T.let(nil, ::T.untyped) +end + +class Atomic::ConcurrentUpdateError +end + +class Atomic +end + +BasicObject::BasicObject = BasicObject + +class BasicSocket + def read_nonblock(len, str=T.unsafe(nil), exception: T.unsafe(nil)); end +end + +class BigDecimal + def clone(); end + EXCEPTION_NaN = ::T.let(nil, ::T.untyped) + SIGN_NaN = ::T.let(nil, ::T.untyped) + VERSION = ::T.let(nil, ::T.untyped) +end + +class BigDecimal + def self.new(*args, **kwargs); end +end + +class Binding + def clone(); end + + def irb(); end +end + +module Bundler::Audit + VERSION = ::T.let(nil, ::T.untyped) +end + +class Bundler::Audit::Advisory + def criticality(); end + + def cve_id(); end + + def osvdb_id(); end + + def patched?(version); end + + def unaffected?(version); end + + def vulnerable?(version); end +end + +class Bundler::Audit::Advisory + def self.load(path); end +end + +class Bundler::Audit::Database + def advisories(&block); end + + def advisories_for(name); end + + def check_gem(gem); end + + def each_advisory_path(&block); end + + def each_advisory_path_for(name, &block); end + + def initialize(path=T.unsafe(nil)); end + + def path(); end + + def size(); end + URL = ::T.let(nil, ::T.untyped) + USER_PATH = ::T.let(nil, ::T.untyped) + VENDORED_PATH = ::T.let(nil, ::T.untyped) + VENDORED_TIMESTAMP = ::T.let(nil, ::T.untyped) +end + +class Bundler::Audit::Database + def self.path(); end + + def self.update!(options=T.unsafe(nil)); end +end + +module Bundler::Audit +end + +Bundler::Deprecate = Gem::Deprecate + +class Bundler::Env +end + +class Bundler::Env + def self.environment(); end + + def self.report(options=T.unsafe(nil)); end + + def self.write(io); end +end + +class Bundler::FeatureFlag + def github_https?(); end +end + +class Bundler::Fetcher + def fetch_spec(spec); end + + def fetchers(); end + + def http_proxy(); end + + def initialize(remote); end + + def specs(gem_names, source); end + + def specs_with_retry(gem_names, source); end + + def uri(); end + + def use_api(); end + + def user_agent(); end + FAIL_ERRORS = ::T.let(nil, ::T.untyped) + FETCHERS = ::T.let(nil, ::T.untyped) + HTTP_ERRORS = ::T.let(nil, ::T.untyped) + NET_ERRORS = ::T.let(nil, ::T.untyped) +end + +class Bundler::Fetcher::AuthenticationRequiredError + def initialize(remote_uri); end +end + +class Bundler::Fetcher::BadAuthenticationError + def initialize(remote_uri); end +end + +class Bundler::Fetcher::Base + def api_fetcher?(); end + + def available?(); end + + def display_uri(); end + + def downloader(); end + + def fetch_uri(); end + + def initialize(downloader, remote, display_uri); end + + def remote(); end + + def remote_uri(); end +end + +class Bundler::Fetcher::Base +end + +class Bundler::Fetcher::CertificateFailureError + def initialize(remote_uri); end +end + +class Bundler::Fetcher::CompactIndex + def available?(*args, &blk); end + + def fetch_spec(*args, &blk); end + + def specs(*args, &blk); end + + def specs_for_names(gem_names); end +end + +class Bundler::Fetcher::CompactIndex::ClientFetcher + def call(path, headers); end + + def fetcher(); end + + def fetcher=(_); end + + def ui(); end + + def ui=(_); end +end + +class Bundler::Fetcher::CompactIndex::ClientFetcher + def self.[](*_); end + + def self.members(); end +end + +class Bundler::Fetcher::CompactIndex + def self.compact_index_request(method_name); end +end + +class Bundler::Fetcher::Dependency + def dependency_api_uri(gem_names=T.unsafe(nil)); end + + def dependency_specs(gem_names); end + + def get_formatted_specs_and_deps(gem_list); end + + def specs(gem_names, full_dependency_list=T.unsafe(nil), last_spec_list=T.unsafe(nil)); end + + def unmarshalled_dep_gems(gem_names); end +end + +class Bundler::Fetcher::Dependency +end + +class Bundler::Fetcher::Downloader + def connection(); end + + def fetch(uri, headers=T.unsafe(nil), counter=T.unsafe(nil)); end + + def initialize(connection, redirect_limit); end + + def redirect_limit(); end + + def request(uri, headers); end +end + +class Bundler::Fetcher::Downloader +end + +class Bundler::Fetcher::Index + def fetch_spec(spec); end + + def specs(_gem_names); end +end + +class Bundler::Fetcher::Index +end + +class Bundler::Fetcher::SSLError + def initialize(msg=T.unsafe(nil)); end +end + +class Bundler::Fetcher + def self.api_timeout(); end + + def self.api_timeout=(api_timeout); end + + def self.disable_endpoint(); end + + def self.disable_endpoint=(disable_endpoint); end + + def self.max_retries(); end + + def self.max_retries=(max_retries); end + + def self.redirect_limit(); end + + def self.redirect_limit=(redirect_limit); end +end + +class Bundler::GemHelper + include ::Rake::DSL + include ::Rake::FileUtilsExt + include ::FileUtils + include ::FileUtils::StreamUtils_ + def allowed_push_host(); end + + def already_tagged?(); end + + def base(); end + + def build_gem(); end + + def built_gem_path(); end + + def clean?(); end + + def committed?(); end + + def gem_key(); end + + def gem_push?(); end + + def gem_push_host(); end + + def gemspec(); end + + def git_push(remote=T.unsafe(nil)); end + + def guard_clean(); end + + def initialize(base=T.unsafe(nil), name=T.unsafe(nil)); end + + def install(); end + + def install_gem(built_gem_path=T.unsafe(nil), local=T.unsafe(nil)); end + + def name(); end + + def perform_git_push(options=T.unsafe(nil)); end + + def rubygem_push(path); end + + def sh(cmd, &block); end + + def sh_with_code(cmd, &block); end + + def spec_path(); end + + def tag_version(); end + + def version(); end + + def version_tag(); end +end + +class Bundler::GemHelper + def self.gemspec(&block); end + + def self.install_tasks(opts=T.unsafe(nil)); end + + def self.instance(); end + + def self.instance=(instance); end +end + +class Bundler::GemRemoteFetcher +end + +class Bundler::GemRemoteFetcher +end + +class Bundler::GemVersionPromoter + def initialize(locked_specs=T.unsafe(nil), unlock_gems=T.unsafe(nil)); end + + def level(); end + + def level=(value); end + + def locked_specs(); end + + def major?(); end + + def minor?(); end + + def prerelease_specified(); end + + def prerelease_specified=(prerelease_specified); end + + def sort_versions(dep, spec_groups); end + + def strict(); end + + def strict=(strict); end + + def unlock_gems(); end + DEBUG = ::T.let(nil, ::T.untyped) +end + +class Bundler::GemVersionPromoter +end + +class Bundler::Graph + def edge_options(); end + + def groups(); end + + def initialize(env, output_file, show_version=T.unsafe(nil), show_requirements=T.unsafe(nil), output_format=T.unsafe(nil), without=T.unsafe(nil)); end + + def node_options(); end + + def output_file(); end + + def output_format(); end + + def relations(); end + + def viz(); end + GRAPH_NAME = ::T.let(nil, ::T.untyped) +end + +class Bundler::Graph::GraphVizClient + def g(); end + + def initialize(graph_instance); end + + def run(); end +end + +class Bundler::Graph::GraphVizClient +end + +class Bundler::Graph +end + +class Bundler::Index + include ::Enumerable +end + +class Bundler::Injector + def initialize(deps, options=T.unsafe(nil)); end + + def inject(gemfile_path, lockfile_path); end + + def remove(gemfile_path, lockfile_path); end + INJECTED_GEMS = ::T.let(nil, ::T.untyped) +end + +class Bundler::Injector + def self.inject(new_deps, options=T.unsafe(nil)); end + + def self.remove(gems, options=T.unsafe(nil)); end +end + +class Bundler::Installer + def generate_bundler_executable_stubs(spec, options=T.unsafe(nil)); end + + def generate_standalone_bundler_executable_stubs(spec); end + + def initialize(root, definition); end + + def post_install_messages(); end + + def run(options); end +end + +class Bundler::Installer + def self.ambiguous_gems(); end + + def self.ambiguous_gems=(ambiguous_gems); end + + def self.install(root, definition, options=T.unsafe(nil)); end +end + +class Bundler::Molinillo::DependencyGraph + include ::Enumerable +end + +class Bundler::Molinillo::DependencyGraph::Log + extend ::Enumerable +end + +module Bundler::Plugin::API::Source + def ==(other); end + + def app_cache_dirname(); end + + def app_cache_path(custom_path=T.unsafe(nil)); end + + def bundler_plugin_api_source?(); end + + def cache(spec, custom_path=T.unsafe(nil)); end + + def cached!(); end + + def can_lock?(spec); end + + def dependency_names(); end + + def dependency_names=(dependency_names); end + + def double_check_for(*_); end + + def eql?(other); end + + def fetch_gemspec_files(); end + + def gem_install_dir(); end + + def hash(); end + + def include?(other); end + + def initialize(opts); end + + def install(spec, opts); end + + def install_path(); end + + def installed?(); end + + def name(); end + + def options(); end + + def options_to_lock(); end + + def post_install(spec, disable_exts=T.unsafe(nil)); end + + def remote!(); end + + def root(); end + + def specs(); end + + def to_lock(); end + + def to_s(); end + + def unlock!(); end + + def unmet_deps(); end + + def uri(); end + + def uri_hash(); end +end + +module Bundler::Plugin::API::Source +end + +module Bundler::Plugin::Events + GEM_AFTER_INSTALL = ::T.let(nil, ::T.untyped) + GEM_AFTER_INSTALL_ALL = ::T.let(nil, ::T.untyped) + GEM_BEFORE_INSTALL = ::T.let(nil, ::T.untyped) + GEM_BEFORE_INSTALL_ALL = ::T.let(nil, ::T.untyped) +end + +class Bundler::Plugin::Index::CommandConflict + def initialize(plugin, commands); end +end + +class Bundler::Plugin::Index::CommandConflict +end + +class Bundler::Plugin::Index::SourceConflict + def initialize(plugin, sources); end +end + +class Bundler::Plugin::Index::SourceConflict +end + +class Bundler::Plugin::Installer + def install(names, options); end + + def install_definition(definition); end +end + +class Bundler::Plugin::Installer::Git + def generate_bin(spec, disable_extensions=T.unsafe(nil)); end +end + +class Bundler::Plugin::Installer::Git +end + +class Bundler::Plugin::Installer::Rubygems +end + +class Bundler::Plugin::Installer::Rubygems +end + +class Bundler::Plugin::Installer +end + +class Bundler::Plugin::SourceList +end + +class Bundler::Plugin::SourceList +end + +class Bundler::ProcessLock +end + +class Bundler::ProcessLock + def self.lock(bundle_path=T.unsafe(nil)); end +end + +class Bundler::Retry + def attempt(&block); end + + def attempts(&block); end + + def current_run(); end + + def current_run=(current_run); end + + def initialize(name, exceptions=T.unsafe(nil), retries=T.unsafe(nil)); end + + def name(); end + + def name=(name); end + + def total_runs(); end + + def total_runs=(total_runs); end +end + +class Bundler::Retry + def self.attempts(); end + + def self.default_attempts(); end + + def self.default_retries(); end +end + +class Bundler::RubyGemsGemInstaller + def initialize(gem, options=T.unsafe(nil)); end +end + +class Bundler::RubyGemsGemInstaller +end + +class Bundler::Settings::Mirror + def ==(other); end + + def fallback_timeout(); end + + def fallback_timeout=(timeout); end + + def initialize(uri=T.unsafe(nil), fallback_timeout=T.unsafe(nil)); end + + def uri(); end + + def uri=(uri); end + + def valid?(); end + + def validate!(probe=T.unsafe(nil)); end + DEFAULT_FALLBACK_TIMEOUT = ::T.let(nil, ::T.untyped) +end + +class Bundler::Settings::Mirror +end + +class Bundler::Settings::Mirrors + def each(&blk); end + + def for(uri); end + + def initialize(prober=T.unsafe(nil)); end + + def parse(key, value); end +end + +class Bundler::Settings::Mirrors +end + +class Bundler::Settings::Validator +end + +class Bundler::Settings::Validator::Rule + def description(); end + + def fail!(key, value, *reasons); end + + def initialize(keys, description, &validate); end + + def k(key); end + + def set(settings, key, value, *reasons); end + + def validate!(key, value, settings); end +end + +class Bundler::Settings::Validator::Rule +end + +class Bundler::Settings::Validator + def self.validate!(key, value, settings); end +end + +class Bundler::SpecSet + include ::Enumerable +end + +class Bundler::UI::Shell + def add_color(string, *color); end + + def ask(msg); end + + def confirm(msg, newline=T.unsafe(nil)); end + + def debug(msg, newline=T.unsafe(nil)); end + + def debug?(); end + + def error(msg, newline=T.unsafe(nil)); end + + def info(msg, newline=T.unsafe(nil)); end + + def initialize(options=T.unsafe(nil)); end + + def level(name=T.unsafe(nil)); end + + def level=(level); end + + def no?(); end + + def quiet?(); end + + def shell=(shell); end + + def silence(&blk); end + + def trace(e, newline=T.unsafe(nil), force=T.unsafe(nil)); end + + def unprinted_warnings(); end + + def warn(msg, newline=T.unsafe(nil)); end + + def yes?(msg); end + LEVELS = ::T.let(nil, ::T.untyped) +end + +class Bundler::UI::Shell +end + +module Bundler::VersionRanges +end + +class Bundler::VersionRanges::NEq + def version(); end + + def version=(_); end +end + +class Bundler::VersionRanges::NEq + def self.[](*_); end + + def self.members(); end +end + +class Bundler::VersionRanges::ReqR + def cover?(v); end + + def empty?(); end + + def left(); end + + def left=(_); end + + def right(); end + + def right=(_); end + + def single?(); end + INFINITY = ::T.let(nil, ::T.untyped) + UNIVERSAL = ::T.let(nil, ::T.untyped) + ZERO = ::T.let(nil, ::T.untyped) +end + +class Bundler::VersionRanges::ReqR::Endpoint + def inclusive(); end + + def inclusive=(_); end + + def version(); end + + def version=(_); end +end + +class Bundler::VersionRanges::ReqR::Endpoint + def self.[](*_); end + + def self.members(); end +end + +class Bundler::VersionRanges::ReqR + def self.[](*_); end + + def self.members(); end +end + +module Bundler::VersionRanges + def self.empty?(ranges, neqs); end + + def self.for(requirement); end + + def self.for_many(requirements); end +end + +module CGI::HtmlExtension + def a(href=T.unsafe(nil)); end + + def base(href=T.unsafe(nil)); end + + def blockquote(cite=T.unsafe(nil)); end + + def caption(align=T.unsafe(nil)); end + + def checkbox(name=T.unsafe(nil), value=T.unsafe(nil), checked=T.unsafe(nil)); end + + def checkbox_group(name=T.unsafe(nil), *values); end + + def file_field(name=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end + + def form(method=T.unsafe(nil), action=T.unsafe(nil), enctype=T.unsafe(nil)); end + + def hidden(name=T.unsafe(nil), value=T.unsafe(nil)); end + + def html(attributes=T.unsafe(nil)); end + + def image_button(src=T.unsafe(nil), name=T.unsafe(nil), alt=T.unsafe(nil)); end + + def img(src=T.unsafe(nil), alt=T.unsafe(nil), width=T.unsafe(nil), height=T.unsafe(nil)); end + + def multipart_form(action=T.unsafe(nil), enctype=T.unsafe(nil)); end + + def password_field(name=T.unsafe(nil), value=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end + + def popup_menu(name=T.unsafe(nil), *values); end + + def radio_button(name=T.unsafe(nil), value=T.unsafe(nil), checked=T.unsafe(nil)); end + + def radio_group(name=T.unsafe(nil), *values); end + + def reset(value=T.unsafe(nil), name=T.unsafe(nil)); end + + def scrolling_list(name=T.unsafe(nil), *values); end + + def submit(value=T.unsafe(nil), name=T.unsafe(nil)); end + + def text_field(name=T.unsafe(nil), value=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end + + def textarea(name=T.unsafe(nil), cols=T.unsafe(nil), rows=T.unsafe(nil)); end +end + +module CGI::HtmlExtension +end + +class Class + def json_creatable?(); end +end + +class Complex + def self.polar(*_); end + + def self.rect(*_); end + + def self.rectangular(*_); end +end + +class ConcurrentRedBlackTree +end + +class ConcurrentRedBlackTree::ConcurrentNode + def balanced_rotate(dir); end + + def child(dir); end + + def new_child(dir, node, color=T.unsafe(nil)); end + + def new_children(dir, node, other, color=T.unsafe(nil)); end + + def new_color(color); end + + def new_value(value); end + + def rebalance_for_delete(dir); end + + def rebalance_for_insert(dir); end + + def rotate(dir); end + EMPTY_CONCURRENT = ::T.let(nil, ::T.untyped) + LEFT = ::T.let(nil, ::T.untyped) + RIGHT = ::T.let(nil, ::T.untyped) +end + +class ConcurrentRedBlackTree::ConcurrentNode::EmptyConcurrentNode +end + +class ConcurrentRedBlackTree::ConcurrentNode::EmptyConcurrentNode +end + +class ConcurrentRedBlackTree::ConcurrentNode +end + +class ConcurrentRedBlackTree +end + +class Date::Infinity + def initialize(d=T.unsafe(nil)); end +end + +class Delegator + def !=(obj); end + + def ==(obj); end + + def __getobj__(); end + + def __setobj__(obj); end + + def eql?(obj); end + + def initialize(obj); end + + def marshal_dump(); end + + def marshal_load(data); end + + def method_missing(m, *args, &block); end + + def methods(all=T.unsafe(nil)); end + + def protected_methods(all=T.unsafe(nil)); end + + def public_methods(all=T.unsafe(nil)); end +end + +class Delegator + def self.const_missing(n); end + + def self.delegating_block(mid); end + + def self.public_api(); end +end + +class DidYouMean::ClassNameChecker + def class_name(); end + + def class_names(); end + + def corrections(); end + + def initialize(exception); end + + def scopes(); end +end + +module DidYouMean::Correctable + def corrections(); end + + def original_message(); end + + def spell_checker(); end + + def to_s(); end +end + +module DidYouMean::Jaro + def self.distance(str1, str2); end +end + +module DidYouMean::JaroWinkler + def self.distance(str1, str2); end +end + +class DidYouMean::KeyErrorChecker + def corrections(); end + + def initialize(key_error); end +end + +class DidYouMean::KeyErrorChecker +end + +module DidYouMean::Levenshtein + def self.distance(str1, str2); end + + def self.min3(a, b, c); end +end + +class DidYouMean::MethodNameChecker + def corrections(); end + + def initialize(exception); end + + def method_name(); end + + def method_names(); end + + def receiver(); end + RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped) +end + +class DidYouMean::NullChecker + def corrections(); end + + def initialize(*_); end +end + +class DidYouMean::PlainFormatter + def message_for(corrections); end +end + +class DidYouMean::PlainFormatter +end + +class DidYouMean::VariableNameChecker + def corrections(); end + + def cvar_names(); end + + def initialize(exception); end + + def ivar_names(); end + + def lvar_names(); end + + def method_names(); end + + def name(); end + RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped) +end + +module DidYouMean + def self.formatter(); end + + def self.formatter=(formatter); end +end + +class Dir + def children(); end + + def each_child(); end +end + +class Dir + def self.children(*_); end + + def self.each_child(*_); end + + def self.empty?(_); end + + def self.exists?(_); end + + def self.tmpdir(); end +end + +class Dyndnsd::Database + def [](*args, &block); end + + def []=(*args, &block); end + + def each(*args, &block); end + + def has_key?(*args, &block); end +end + +class Dyndnsd::DummyDatabase + def [](*args, &block); end + + def []=(*args, &block); end + + def each(*args, &block); end + + def has_key?(*args, &block); end +end + +class ERB + def def_method(mod, methodname, fname=T.unsafe(nil)); end + + def def_module(methodname=T.unsafe(nil)); end + + def result_with_hash(hash); end +end + +class ERB::Compiler::Scanner + DEFAULT_ETAGS = ::T.let(nil, ::T.untyped) + DEFAULT_STAGS = ::T.let(nil, ::T.untyped) +end + +Emitter = Psych::Stream::Emitter + +class Encoding + def _dump(*_); end +end + +class Encoding::Converter + def convert(_); end + + def convpath(); end + + def destination_encoding(); end + + def finish(); end + + def initialize(*_); end + + def insert_output(_); end + + def last_error(); end + + def primitive_convert(*_); end + + def primitive_errinfo(); end + + def putback(*_); end + + def replacement(); end + + def replacement=(replacement); end + + def source_encoding(); end +end + +class Encoding::Converter + def self.asciicompat_encoding(_); end + + def self.search_convpath(*_); end +end + +class Encoding::InvalidByteSequenceError + def destination_encoding(); end + + def destination_encoding_name(); end + + def error_bytes(); end + + def incomplete_input?(); end + + def readagain_bytes(); end + + def source_encoding(); end + + def source_encoding_name(); end +end + +class Encoding::UndefinedConversionError + def destination_encoding(); end + + def destination_encoding_name(); end + + def error_char(); end + + def source_encoding(); end + + def source_encoding_name(); end +end + +class Encoding + def self._load(_); end + + def self.locale_charmap(); end +end + +module Enumerable + def chain(*_); end + + def chunk(); end + + def chunk_while(); end + + def each_entry(*_); end + + def grep_v(_); end + + def slice_after(*_); end + + def slice_before(*_); end + + def slice_when(); end + + def sum(*_); end + + def to_set(klass=T.unsafe(nil), *args, &block); end + + def uniq(); end +end + +class Enumerator + def +(_); end + + def each_with_index(); end +end + +class Enumerator::ArithmeticSequence + def begin(); end + + def each(&blk); end + + def end(); end + + def exclude_end?(); end + + def last(*_); end + + def step(); end +end + +class Enumerator::ArithmeticSequence +end + +class Enumerator::Chain +end + +class Enumerator::Chain +end + +class Enumerator::Generator + def each(*_, &blk); end + + def initialize(*_); end +end + +class Enumerator::Lazy + def chunk(*_); end + + def chunk_while(*_); end + + def force(*_); end + + def slice_when(*_); end +end + +Errno::EAUTH = Errno::NOERROR + +Errno::EBADARCH = Errno::NOERROR + +Errno::EBADEXEC = Errno::NOERROR + +Errno::EBADMACHO = Errno::NOERROR + +Errno::EBADRPC = Errno::NOERROR + +Errno::ECAPMODE = Errno::NOERROR + +Errno::EDEADLOCK = Errno::EDEADLK + +Errno::EDEVERR = Errno::NOERROR + +Errno::EDOOFUS = Errno::NOERROR + +Errno::EFTYPE = Errno::NOERROR + +Errno::EIPSEC = Errno::NOERROR + +Errno::ELAST = Errno::NOERROR + +Errno::ENEEDAUTH = Errno::NOERROR + +Errno::ENOATTR = Errno::NOERROR + +Errno::ENOPOLICY = Errno::NOERROR + +Errno::ENOTCAPABLE = Errno::NOERROR + +class Errno::ENOTSUP + Errno = ::T.let(nil, ::T.untyped) +end + +class Errno::ENOTSUP +end + +Errno::EPROCLIM = Errno::NOERROR + +Errno::EPROCUNAVAIL = Errno::NOERROR + +Errno::EPROGMISMATCH = Errno::NOERROR + +Errno::EPROGUNAVAIL = Errno::NOERROR + +Errno::EPWROFF = Errno::NOERROR + +Errno::EQFULL = Errno::NOERROR + +Errno::ERPCMISMATCH = Errno::NOERROR + +Errno::ESHLIBVERS = Errno::NOERROR + +class Etc::Group + def gid(); end + + def gid=(_); end + + def mem(); end + + def mem=(_); end + + def name(); end + + def name=(_); end + + def passwd(); end + + def passwd=(_); end +end + +class Etc::Group + extend ::Enumerable + def self.[](*_); end + + def self.each(&blk); end + + def self.members(); end +end + +class Etc::Passwd + def dir=(_); end + + def gecos(); end + + def gecos=(_); end + + def gid=(_); end + + def name=(_); end + + def passwd=(_); end + + def shell=(_); end + + def uid=(_); end +end + +class Etc::Passwd + extend ::Enumerable + def self.[](*_); end + + def self.each(&blk); end + + def self.members(); end +end + +class Exception + def full_message(*_); end +end + +class Exception + def self.exception(*_); end + + def self.to_tty?(); end +end + +class ExitCalledError +end + +class ExitCalledError +end + +class FalseClass + include ::JSON::Ext::Generator::GeneratorMethods::FalseClass +end + +class Fiber + def resume(*_); end +end + +class Fiber + def self.yield(*_); end +end + +class File + Separator = ::T.let(nil, ::T.untyped) +end + +class File::Stat + def size?(); end +end + +class File + def self.empty?(_); end + + def self.exists?(_); end + + def self.lutime(*_); end + + def self.mkfifo(*_); end +end + +FileList = Rake::FileList + +module FileUtils + include ::FileUtils::StreamUtils_ + def ruby(*args, **options, &block); end + + def safe_ln(*args, **options); end + + def sh(*cmd, &block); end + + def split_all(path); end + LN_SUPPORTED = ::T.let(nil, ::T.untyped) + RUBY = ::T.let(nil, ::T.untyped) +end + +module FileUtils::DryRun + include ::FileUtils + include ::FileUtils::StreamUtils_ + include ::FileUtils::LowMethods +end + +module FileUtils::DryRun + extend ::FileUtils::DryRun + extend ::FileUtils + extend ::FileUtils::StreamUtils_ + extend ::FileUtils::LowMethods +end + +module FileUtils::NoWrite + include ::FileUtils + include ::FileUtils::StreamUtils_ + include ::FileUtils::LowMethods +end + +module FileUtils::NoWrite + extend ::FileUtils::NoWrite + extend ::FileUtils + extend ::FileUtils::StreamUtils_ + extend ::FileUtils::LowMethods +end + +module FileUtils::Verbose + include ::FileUtils + include ::FileUtils::StreamUtils_ +end + +module FileUtils::Verbose + extend ::FileUtils::Verbose + extend ::FileUtils + extend ::FileUtils::StreamUtils_ +end + +module FileUtils + extend ::FileUtils::StreamUtils_ +end + +module Find +end + +module Find + def self.find(*paths, ignore_error: T.unsafe(nil)); end + + def self.prune(); end +end + +class Float + include ::JSON::Ext::Generator::GeneratorMethods::Float +end + +module Forwardable + def def_delegator(accessor, method, ali=T.unsafe(nil)); end + + def def_delegators(accessor, *methods); end + + def def_instance_delegator(accessor, method, ali=T.unsafe(nil)); end + + def def_instance_delegators(accessor, *methods); end + + def delegate(hash); end + + def instance_delegate(hash); end + VERSION = ::T.let(nil, ::T.untyped) +end + +module Forwardable + def self._compile_method(src, file, line); end + + def self._delegator_method(obj, accessor, method, ali); end + + def self._valid_method?(method); end + + def self.debug(); end + + def self.debug=(debug); end +end + +module GC + def garbage_collect(*_); end +end + +module GC + def self.latest_gc_info(*_); end + + def self.stress=(stress); end + + def self.verify_internal_consistency(); end + + def self.verify_transient_heap_internal_consistency(); end +end + +class Gem::Package::TarHeader + def self.oct_or_256based(str); end +end + +class Gem::RemoteFetcher + def s3_uri_signer(uri); end +end + +class Gem::Resolver::Molinillo::DependencyGraph::Log + extend ::Enumerable +end + +class Gem::S3URISigner + def initialize(uri); end + + def sign(expiration=T.unsafe(nil)); end + + def uri(); end + + def uri=(uri); end + BASE64_URI_TRANSLATE = ::T.let(nil, ::T.untyped) + EC2_IAM_INFO = ::T.let(nil, ::T.untyped) + EC2_IAM_SECURITY_CREDENTIALS = ::T.let(nil, ::T.untyped) +end + +class Gem::S3URISigner::ConfigurationError + def initialize(message); end +end + +class Gem::S3URISigner::ConfigurationError +end + +class Gem::S3URISigner::InstanceProfileError + def initialize(message); end +end + +class Gem::S3URISigner::InstanceProfileError +end + +class Gem::S3URISigner::S3Config + def access_key_id(); end + + def access_key_id=(_); end + + def region(); end + + def region=(_); end + + def secret_access_key(); end + + def secret_access_key=(_); end + + def security_token(); end + + def security_token=(_); end +end + +class Gem::S3URISigner::S3Config + def self.[](*_); end + + def self.members(); end +end + +class Gem::S3URISigner +end + +class Gem::Specification + extend ::Enumerable +end + +module Gem::Util + def self.correct_for_windows_path(path); end +end + +class Hash + include ::JSON::Ext::Generator::GeneratorMethods::Hash + def <(_); end + + def <=(_); end + + def >(_); end + + def >=(_); end + + def compact(); end + + def compact!(); end + + def default_proc(); end + + def default_proc=(default_proc); end + + def fetch_values(*_); end + + def flatten(*_); end + + def index(_); end + + def replace(_); end + + def slice(*_); end + + def to_h(); end + + def to_proc(); end + + def transform_keys(); end + + def transform_keys!(); end + + def transform_values(); end + + def transform_values!(); end + + def update(*_); end +end + +class Hash + def self.try_convert(_); end +end + +module Hitimes + INSTANT_CONVERSION_FACTOR = ::T.let(nil, ::T.untyped) + VERSION = ::T.let(nil, ::T.untyped) +end + +class Hitimes::Error +end + +class Hitimes::Error +end + +class Hitimes::Interval + def duration(); end + + def duration_so_far(); end + + def length(); end + + def running?(); end + + def split(); end + + def start(); end + + def start_instant(); end + + def started?(); end + + def stop(); end + + def stop_instant(); end + + def stopped?(); end + + def to_f(); end + + def to_seconds(); end +end + +class Hitimes::Interval + def self.measure(); end + + def self.now(); end +end + +class Hitimes::Metric + def additional_data(); end + + def initialize(name, additional_data=T.unsafe(nil)); end + + def name(); end + + def sampling_delta(); end + + def sampling_start_time(); end + + def sampling_stop_time(); end + + def to_hash(); end + + def utc_microseconds(); end +end + +class Hitimes::Metric +end + +class Hitimes::MutexedStats + def update(value); end +end + +class Hitimes::MutexedStats +end + +module Hitimes::Paths +end + +module Hitimes::Paths + def self.lib_path(*args); end + + def self.root_dir(); end + + def self.sub_path(sub, *args); end +end + +class Hitimes::Stats + def count(); end + + def max(); end + + def mean(); end + + def min(); end + + def rate(); end + + def stddev(); end + + def sum(); end + + def sumsq(); end + + def to_hash(*args); end + + def to_json(*args); end + + def update(_); end + STATS = ::T.let(nil, ::T.untyped) +end + +class Hitimes::Stats +end + +class Hitimes::TimedMetric + def count(*args, &block); end + + def duration(*args, &block); end + + def max(*args, &block); end + + def mean(*args, &block); end + + def measure(&block); end + + def min(*args, &block); end + + def rate(*args, &block); end + + def running?(); end + + def split(); end + + def start(); end + + def stats(); end + + def stddev(*args, &block); end + + def stop(); end + + def sum(*args, &block); end + + def sumsq(*args, &block); end +end + +class Hitimes::TimedMetric + extend ::Forwardable + def self.now(name, additional_data=T.unsafe(nil)); end +end + +class Hitimes::TimedValueMetric + def duration(); end + + def measure(value, &block); end + + def rate(); end + + def running?(); end + + def split(value); end + + def start(); end + + def stop(value); end + + def timed_stats(); end + + def unit_count(); end + + def value_stats(); end +end + +class Hitimes::TimedValueMetric + def self.now(name, additional_data=T.unsafe(nil)); end +end + +class Hitimes::ValueMetric + def count(*args, &block); end + + def max(*args, &block); end + + def mean(*args, &block); end + + def measure(value); end + + def min(*args, &block); end + + def stats(); end + + def stddev(*args, &block); end + + def sum(*args, &block); end + + def sumsq(*args, &block); end +end + +class Hitimes::ValueMetric + extend ::Forwardable +end + +module Hitimes + def self.measure(&block); end + + def self.raw_instant(); end +end + +class IO + def beep(); end + + def cooked(); end + + def cooked!(); end + + def cursor(); end + + def cursor=(); end + + def echo=(echo); end + + def echo?(); end + + def external_encoding(); end + + def getch(*_); end + + def getpass(*_); end + + def goto(); end + + def iflush(); end + + def ioflush(); end + + def noecho(); end + + def nonblock(*_); end + + def nonblock=(nonblock); end + + def nonblock?(); end + + def nread(); end + + def oflush(); end + + def pathconf(_); end + + def pread(*_); end + + def pressed?(); end + + def pwrite(_, _1); end + + def raw(*_); end + + def raw!(*_); end + + def ready?(); end + + def wait(*_); end + + def wait_readable(*_); end + + def wait_writable(*_); end + + def winsize(); end + + def winsize=(winsize); end + + def write_nonblock(buf, exception: T.unsafe(nil)); end +end + +IO::EWOULDBLOCKWaitReadable = IO::EAGAINWaitReadable + +IO::EWOULDBLOCKWaitWritable = IO::EAGAINWaitWritable + +class IO + def self.console(*_); end + + def self.foreach(*_); end +end + +class IPAddr + include ::Comparable + def &(other); end + + def <<(num); end + + def ==(other); end + + def ===(other); end + + def >>(num); end + + def eql?(other); end + + def family(); end + + def hton(); end + + def include?(other); end + + def initialize(addr=T.unsafe(nil), family=T.unsafe(nil)); end + + def ip6_arpa(); end + + def ip6_int(); end + + def ipv4?(); end + + def ipv4_compat(); end + + def ipv4_compat?(); end + + def ipv4_mapped(); end + + def ipv4_mapped?(); end + + def ipv6?(); end + + def link_local?(); end + + def loopback?(); end + + def mask(prefixlen); end + + def mask!(mask); end + + def native(); end + + def prefix(); end + + def prefix=(prefix); end + + def private?(); end + + def reverse(); end + + def set(addr, *family); end + + def succ(); end + + def to_i(); end + + def to_range(); end + + def to_string(); end + + def |(other); end + + def ~(); end + IN4MASK = ::T.let(nil, ::T.untyped) + IN6FORMAT = ::T.let(nil, ::T.untyped) + IN6MASK = ::T.let(nil, ::T.untyped) + RE_IPV4ADDRLIKE = ::T.let(nil, ::T.untyped) + RE_IPV6ADDRLIKE_COMPRESSED = ::T.let(nil, ::T.untyped) + RE_IPV6ADDRLIKE_FULL = ::T.let(nil, ::T.untyped) +end + +class IPAddr::AddressFamilyError +end + +class IPAddr::AddressFamilyError +end + +class IPAddr::Error +end + +class IPAddr::Error +end + +class IPAddr::InvalidAddressError +end + +class IPAddr::InvalidAddressError +end + +class IPAddr::InvalidPrefixError +end + +class IPAddr::InvalidPrefixError +end + +class IPAddr + def self.new_ntoh(addr); end + + def self.ntop(addr); end +end + +class Integer + include ::JSON::Ext::Generator::GeneratorMethods::Integer + def allbits?(_); end + + def anybits?(_); end + + def digits(*_); end + + def nobits?(_); end + + def pow(*_); end + + def to_bn(); end + GMP_VERSION = ::T.let(nil, ::T.untyped) +end + +class Integer + def self.sqrt(_); end +end + +class JSON::Ext::Generator::State + def self.from_state(_); end +end + +class JSON::Ext::Parser + def initialize(*_); end +end + +JSON::Parser = JSON::Ext::Parser + +JSON::State = JSON::Ext::Generator::State + +JSON::UnparserError = JSON::GeneratorError + +JSONTree = Psych::Visitors::JSONTree + +module JaroWinkler + VERSION = ::T.let(nil, ::T.untyped) +end + +class JaroWinkler::Error +end + +class JaroWinkler::Error +end + +class JaroWinkler::InvalidWeightError +end + +class JaroWinkler::InvalidWeightError +end + +module JaroWinkler + def self.distance(*_); end + + def self.jaro_distance(*_); end +end + +module Kernel + def gem(dep, *reqs); end + + def itself(); end + + def object_id(); end + + def pretty_inspect(); end + + def then(); end + + def yield_self(); end +end + +module Kernel + def self.at_exit(); end +end + +class KeyError + include ::DidYouMean::Correctable + def key(); end + + def receiver(); end +end + +class LoadError + def path(); end +end + +class LocalJumpError + def exit_value(); end + + def reason(); end +end + +class Logger + SEV_LABEL = ::T.let(nil, ::T.untyped) +end + +class Logger::Formatter + Format = ::T.let(nil, ::T.untyped) +end + +class Logger::LogDevice + include ::MonitorMixin +end + +module Logger::Period + SiD = ::T.let(nil, ::T.untyped) +end + +module Marshal + def self.restore(*_); end +end + +module Metriks + VERSION = ::T.let(nil, ::T.untyped) +end + +class Metriks::Counter + def clear(); end + + def count(); end + + def decrement(decr=T.unsafe(nil)); end + + def increment(incr=T.unsafe(nil)); end +end + +class Metriks::Counter +end + +class Metriks::EWMA + def clear(); end + + def initialize(alpha, interval); end + + def rate(); end + + def tick(); end + + def update(value); end + FIFTEEN_MINUTES = ::T.let(nil, ::T.untyped) + FIVE_MINUTES = ::T.let(nil, ::T.untyped) + INTERVAL = ::T.let(nil, ::T.untyped) + M15_ALPHA = ::T.let(nil, ::T.untyped) + M1_ALPHA = ::T.let(nil, ::T.untyped) + M5_ALPHA = ::T.let(nil, ::T.untyped) + ONE_MINUTE = ::T.let(nil, ::T.untyped) + SECONDS_PER_MINUTE = ::T.let(nil, ::T.untyped) +end + +class Metriks::EWMA + def self.new_m1(); end + + def self.new_m15(); end + + def self.new_m5(); end +end + +class Metriks::ExponentiallyDecayingSample + def clear(); end + + def initialize(reservoir_size, alpha, values=T.unsafe(nil)); end + + def rescale(now, next_time); end + + def size(); end + + def snapshot(); end + + def update(value, timestamp=T.unsafe(nil)); end + + def weight(time); end + RESCALE_THRESHOLD = ::T.let(nil, ::T.untyped) +end + +class Metriks::ExponentiallyDecayingSample +end + +class Metriks::Gauge + def initialize(callable=T.unsafe(nil), &block); end + + def set(val); end + + def value(); end +end + +class Metriks::Gauge +end + +class Metriks::Histogram + def clear(); end + + def count(); end + + def initialize(sample); end + + def max(); end + + def max=(potential_max); end + + def mean(); end + + def min(); end + + def min=(potential_min); end + + def snapshot(); end + + def stddev(); end + + def sum(); end + + def update(value); end + + def update_variance(value); end + + def variance(); end + DEFAULT_ALPHA = ::T.let(nil, ::T.untyped) + DEFAULT_SAMPLE_SIZE = ::T.let(nil, ::T.untyped) +end + +class Metriks::Histogram + def self.new_exponentially_decaying(); end + + def self.new_uniform(); end +end + +class Metriks::Meter + def clear(); end + + def count(); end + + def fifteen_minute_rate(); end + + def five_minute_rate(); end + + def initialize(averager_klass=T.unsafe(nil)); end + + def mark(val=T.unsafe(nil)); end + + def mean_rate(); end + + def one_minute_rate(); end + + def stop(); end + + def tick(); end + + def tick_if_nessesary(); end + TICK_INTERVAL = ::T.let(nil, ::T.untyped) +end + +class Metriks::Meter +end + +class Metriks::Registry + def add(name, metric); end + + def add_or_get(name, klass, &create_metric); end + + def clear(); end + + def counter(name); end + + def each(&block); end + + def gauge(name, callable=T.unsafe(nil), &block); end + + def get(name); end + + def histogram(name); end + + def meter(name); end + + def stop(); end + + def timer(name); end + + def utilization_timer(name); end +end + +class Metriks::Registry + def self.default(); end +end + +module Metriks::Reporter +end + +class Metriks::Reporter::Graphite + def host(); end + + def initialize(host, port, options=T.unsafe(nil)); end + + def port(); end + + def restart(); end + + def socket(); end + + def start(); end + + def stop(); end + + def write(); end + + def write_metric(base_name, metric, keys, snapshot_keys=T.unsafe(nil)); end +end + +class Metriks::Reporter::Graphite +end + +class Metriks::Reporter::ProcTitle + def add(name, suffix=T.unsafe(nil), &block); end + + def empty?(); end + + def generate_title(); end + + def initialize(options=T.unsafe(nil)); end + + def restart(); end + + def start(); end + + def stop(); end +end + +class Metriks::Reporter::ProcTitle +end + +module Metriks::Reporter +end + +class Metriks::Snapshot + def get_75th_percentile(); end + + def get_95th_percentile(); end + + def get_98th_percentile(); end + + def get_999th_percentile(); end + + def get_99th_percentile(); end + + def initialize(values); end + + def median(); end + + def size(); end + + def value(quantile); end + + def values(); end + MEDIAN_Q = ::T.let(nil, ::T.untyped) + P75_Q = ::T.let(nil, ::T.untyped) + P95_Q = ::T.let(nil, ::T.untyped) + P98_Q = ::T.let(nil, ::T.untyped) + P999_Q = ::T.let(nil, ::T.untyped) + P99_Q = ::T.let(nil, ::T.untyped) +end + +class Metriks::Snapshot +end + +class Metriks::Timer + def clear(); end + + def count(); end + + def fifteen_minute_rate(); end + + def five_minute_rate(); end + + def initialize(histogram=T.unsafe(nil)); end + + def max(); end + + def mean(); end + + def mean_rate(); end + + def min(); end + + def one_minute_rate(); end + + def snapshot(); end + + def stddev(); end + + def stop(); end + + def sum(); end + + def time(callable=T.unsafe(nil), &block); end + + def update(duration); end +end + +class Metriks::Timer::Context + def initialize(timer); end + + def restart(); end + + def stop(); end +end + +class Metriks::Timer::Context +end + +class Metriks::Timer +end + +class Metriks::UniformSample + def clear(); end + + def initialize(reservoir_size); end + + def size(); end + + def snapshot(); end + + def update(value); end +end + +class Metriks::UniformSample +end + +class Metriks::UtilizationTimer + def fifteen_minute_utilization(); end + + def five_minute_utilization(); end + + def initialize(); end + + def mean_utilization(); end + + def one_minute_utilization(); end +end + +class Metriks::UtilizationTimer +end + +module Metriks + def self.counter(name); end + + def self.gauge(name, callable=T.unsafe(nil), &block); end + + def self.get(name); end + + def self.histogram(name); end + + def self.meter(name); end + + def self.timer(name); end + + def self.utilization_timer(name); end +end + +class Module + def context(*a, &b); end + + def deprecate_constant(*_); end + + def describe(*a, &b); end + + def example_group(*a, &b); end + + def fcontext(*a, &b); end + + def fdescribe(*a, &b); end + + def rake_extension(method); end + + def shared_context(name, *args, &block); end + + def shared_examples(name, *args, &block); end + + def shared_examples_for(name, *args, &block); end + + def undef_method(*_); end + + def xcontext(*a, &b); end + + def xdescribe(*a, &b); end +end + +class Module + def self.used_modules(); end +end + +class Monitor + def enter(); end + + def exit(); end + + def try_enter(); end +end + +module MonitorMixin + def initialize(*args); end + + def mon_enter(); end + + def mon_exit(); end + + def mon_locked?(); end + + def mon_owned?(); end + + def mon_synchronize(); end + + def mon_try_enter(); end + + def new_cond(); end + + def synchronize(); end + + def try_mon_enter(); end + EXCEPTION_IMMEDIATE = ::T.let(nil, ::T.untyped) + EXCEPTION_NEVER = ::T.let(nil, ::T.untyped) +end + +class MonitorMixin::ConditionVariable + def broadcast(); end + + def initialize(monitor); end + + def signal(); end + + def wait(timeout=T.unsafe(nil)); end + + def wait_until(); end + + def wait_while(); end +end + +module MonitorMixin + def self.extend_object(obj); end +end + +class NameError + include ::DidYouMean::Correctable + def name(); end + + def receiver(); end +end + +class Net::BufferedIO + def write_timeout(); end + + def write_timeout=(write_timeout); end +end + +class Net::HTTP + def max_retries(); end + + def max_retries=(retries); end + + def max_version(); end + + def max_version=(max_version); end + + def min_version(); end + + def min_version=(min_version); end + + def write_timeout(); end + + def write_timeout=(sec); end + ENVIRONMENT_VARIABLE_IS_MULTIUSER_SAFE = ::T.let(nil, ::T.untyped) +end + +Net::HTTP::ProxyMod = Net::HTTP::ProxyDelta + +class Net::HTTPAlreadyReported + HAS_BODY = ::T.let(nil, ::T.untyped) +end + +class Net::HTTPAlreadyReported +end + +Net::HTTPClientError::EXCEPTION_TYPE = Net::HTTPServerException + +Net::HTTPClientErrorCode = Net::HTTPClientError + +Net::HTTPClientException = Net::HTTPServerException + +class Net::HTTPEarlyHints + HAS_BODY = ::T.let(nil, ::T.untyped) +end + +class Net::HTTPEarlyHints +end + +Net::HTTPFatalErrorCode = Net::HTTPClientError + +class Net::HTTPGatewayTimeout + HAS_BODY = ::T.let(nil, ::T.untyped) +end + +class Net::HTTPGatewayTimeout +end + +Net::HTTPInformation::EXCEPTION_TYPE = Net::HTTPError + +Net::HTTPInformationCode = Net::HTTPInformation + +class Net::HTTPLoopDetected + HAS_BODY = ::T.let(nil, ::T.untyped) +end + +class Net::HTTPLoopDetected +end + +class Net::HTTPMisdirectedRequest + HAS_BODY = ::T.let(nil, ::T.untyped) +end + +class Net::HTTPMisdirectedRequest +end + +Net::HTTPMovedTemporarily = Net::HTTPFound + +Net::HTTPMultipleChoice = Net::HTTPMultipleChoices + +class Net::HTTPNotExtended + HAS_BODY = ::T.let(nil, ::T.untyped) +end + +class Net::HTTPNotExtended +end + +class Net::HTTPPayloadTooLarge + HAS_BODY = ::T.let(nil, ::T.untyped) +end + +class Net::HTTPPayloadTooLarge +end + +class Net::HTTPProcessing + HAS_BODY = ::T.let(nil, ::T.untyped) +end + +class Net::HTTPProcessing +end + +class Net::HTTPRangeNotSatisfiable + HAS_BODY = ::T.let(nil, ::T.untyped) +end + +class Net::HTTPRangeNotSatisfiable +end + +Net::HTTPRedirection::EXCEPTION_TYPE = Net::HTTPRetriableError + +Net::HTTPRedirectionCode = Net::HTTPRedirection + +class Net::HTTPRequestTimeout + HAS_BODY = ::T.let(nil, ::T.untyped) +end + +class Net::HTTPRequestTimeout +end + +Net::HTTPRequestURITooLarge = Net::HTTPURITooLong + +Net::HTTPResponceReceiver = Net::HTTPResponse + +Net::HTTPRetriableCode = Net::HTTPRedirection + +Net::HTTPServerError::EXCEPTION_TYPE = Net::HTTPFatalError + +Net::HTTPServerErrorCode = Net::HTTPServerError + +Net::HTTPSession = Net::HTTP + +Net::HTTPSuccess::EXCEPTION_TYPE = Net::HTTPError + +Net::HTTPSuccessCode = Net::HTTPSuccess + +class Net::HTTPURITooLong + HAS_BODY = ::T.let(nil, ::T.untyped) +end + +class Net::HTTPURITooLong +end + +Net::HTTPUnknownResponse::EXCEPTION_TYPE = Net::HTTPError + +class Net::HTTPVariantAlsoNegotiates + HAS_BODY = ::T.let(nil, ::T.untyped) +end + +class Net::HTTPVariantAlsoNegotiates +end + +Net::NetPrivate::HTTPRequest = Net::HTTPRequest + +Net::NetPrivate::Socket = Net::InternetMessageIO + +Net::ProtocRetryError = Net::ProtoRetriableError + +class Net::ReadTimeout + def initialize(io=T.unsafe(nil)); end + + def io(); end +end + +class Net::WriteTimeout + def initialize(io=T.unsafe(nil)); end + + def io(); end +end + +class Net::WriteTimeout +end + +class NilClass + include ::JSON::Ext::Generator::GeneratorMethods::NilClass + def to_i(); end +end + +class NoMethodError + def args(); end + + def private_call?(); end +end + +class Object + include ::JSON::Ext::Generator::GeneratorMethods::Object + include ::PP::ObjectMixin + def dclone(); end + + def to_yaml(options=T.unsafe(nil)); end + ARGF = ::T.let(nil, ::T.untyped) + ARGV = ::T.let(nil, ::T.untyped) + CROSS_COMPILING = ::T.let(nil, ::T.untyped) + ENV = ::T.let(nil, ::T.untyped) + RUBY_COPYRIGHT = ::T.let(nil, ::T.untyped) + RUBY_DESCRIPTION = ::T.let(nil, ::T.untyped) + RUBY_ENGINE = ::T.let(nil, ::T.untyped) + RUBY_ENGINE_VERSION = ::T.let(nil, ::T.untyped) + RUBY_PATCHLEVEL = ::T.let(nil, ::T.untyped) + RUBY_PLATFORM = ::T.let(nil, ::T.untyped) + RUBY_RELEASE_DATE = ::T.let(nil, ::T.untyped) + RUBY_REVISION = ::T.let(nil, ::T.untyped) + RUBY_VERSION = ::T.let(nil, ::T.untyped) + STDERR = ::T.let(nil, ::T.untyped) + STDIN = ::T.let(nil, ::T.untyped) + STDOUT = ::T.let(nil, ::T.untyped) + TOPLEVEL_BINDING = ::T.let(nil, ::T.untyped) +end + +class Object + def self.yaml_tag(url); end +end + +class ObjectSpace::WeakMap + def [](_); end + + def []=(_, _1); end + + def each(&blk); end + + def each_key(); end + + def each_pair(); end + + def each_value(); end + + def key?(_); end + + def keys(); end + + def length(); end + + def size(); end + + def values(); end +end + +module ObjectSpace + def self.count_objects(*_); end + + def self.define_finalizer(*_); end + + def self.garbage_collect(*_); end + + def self.undefine_finalizer(_); end +end + +class OpenSSL::ASN1::ASN1Data + def indefinite_length(); end + + def indefinite_length=(indefinite_length); end +end + +class OpenSSL::BN + def +@(); end + + def -@(); end + + def /(_); end + + def negative?(); end +end + +module OpenSSL::KDF +end + +class OpenSSL::KDF::KDFError +end + +class OpenSSL::KDF::KDFError +end + +module OpenSSL::KDF + def self.hkdf(*_); end + + def self.pbkdf2_hmac(*_); end + + def self.scrypt(*_); end +end + +class OpenSSL::OCSP::Request + def signed?(); end +end + +OpenSSL::PKCS7::Signer = OpenSSL::PKCS7::SignerInfo + +class OpenSSL::PKey::EC + EXPLICIT_CURVE = ::T.let(nil, ::T.untyped) +end + +class OpenSSL::PKey::EC::Point + def to_octet_string(_); end +end + +class OpenSSL::PKey::RSA + def sign_pss(*_); end + + def verify_pss(*_); end +end + +module OpenSSL::SSL + OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION = ::T.let(nil, ::T.untyped) + OP_CRYPTOPRO_TLSEXT_BUG = ::T.let(nil, ::T.untyped) + OP_LEGACY_SERVER_CONNECT = ::T.let(nil, ::T.untyped) + OP_NO_ENCRYPT_THEN_MAC = ::T.let(nil, ::T.untyped) + OP_NO_RENEGOTIATION = ::T.let(nil, ::T.untyped) + OP_SAFARI_ECDHE_ECDSA_BUG = ::T.let(nil, ::T.untyped) + OP_TLSEXT_PADDING = ::T.let(nil, ::T.untyped) + SSL2_VERSION = ::T.let(nil, ::T.untyped) + SSL3_VERSION = ::T.let(nil, ::T.untyped) + TLS1_1_VERSION = ::T.let(nil, ::T.untyped) + TLS1_2_VERSION = ::T.let(nil, ::T.untyped) + TLS1_VERSION = ::T.let(nil, ::T.untyped) +end + +class OpenSSL::SSL::SSLContext + def add_certificate(*_); end + + def alpn_protocols(); end + + def alpn_protocols=(alpn_protocols); end + + def alpn_select_cb(); end + + def alpn_select_cb=(alpn_select_cb); end + + def enable_fallback_scsv(); end + + def max_version=(version); end + + def min_version=(version); end + DEFAULT_TMP_DH_CALLBACK = ::T.let(nil, ::T.untyped) +end + +class OpenSSL::SSL::SSLSocket + def alpn_protocol(); end + + def tmp_key(); end +end + +module OpenSSL::X509 + V_FLAG_NO_CHECK_TIME = ::T.let(nil, ::T.untyped) + V_FLAG_TRUSTED_FIRST = ::T.let(nil, ::T.untyped) +end + +class OpenSSL::X509::Attribute + def ==(other); end +end + +class OpenSSL::X509::CRL + def ==(other); end +end + +class OpenSSL::X509::Extension + def ==(other); end +end + +class OpenSSL::X509::Name + def to_utf8(); end +end + +class OpenSSL::X509::Request + def ==(other); end +end + +class OpenSSL::X509::Revoked + def ==(other); end + + def to_der(); end +end + +module OpenSSL + def self.fips_mode(); end +end + +module OpenTracing + FORMAT_BINARY = ::T.let(nil, ::T.untyped) + FORMAT_RACK = ::T.let(nil, ::T.untyped) + FORMAT_TEXT_MAP = ::T.let(nil, ::T.untyped) + VERSION = ::T.let(nil, ::T.untyped) +end + +class OpenTracing::Reference + def context(); end + + def initialize(type, context); end + + def type(); end + CHILD_OF = ::T.let(nil, ::T.untyped) + FOLLOWS_FROM = ::T.let(nil, ::T.untyped) +end + +class OpenTracing::Reference + def self.child_of(context); end + + def self.follows_from(context); end +end + +class OpenTracing::Scope + def close(); end + + def span(); end + NOOP_INSTANCE = ::T.let(nil, ::T.untyped) +end + +class OpenTracing::Scope +end + +class OpenTracing::ScopeManager + def activate(span, finish_on_close: T.unsafe(nil)); end + + def active(); end + NOOP_INSTANCE = ::T.let(nil, ::T.untyped) +end + +class OpenTracing::ScopeManager +end + +class OpenTracing::Span + def context(); end + + def finish(end_time: T.unsafe(nil)); end + + def get_baggage_item(key); end + + def log(event: T.unsafe(nil), timestamp: T.unsafe(nil), **fields); end + + def log_kv(timestamp: T.unsafe(nil), **fields); end + + def operation_name=(name); end + + def set_baggage_item(key, value); end + + def set_tag(key, value); end + NOOP_INSTANCE = ::T.let(nil, ::T.untyped) +end + +class OpenTracing::Span +end + +class OpenTracing::SpanContext + def baggage(); end + + def initialize(baggage: T.unsafe(nil)); end + NOOP_INSTANCE = ::T.let(nil, ::T.untyped) +end + +class OpenTracing::SpanContext +end + +class OpenTracing::Tracer + def active_span(); end + + def extract(format, carrier); end + + def inject(span_context, format, carrier); end + + def scope_manager(); end + + def start_active_span(operation_name, child_of: T.unsafe(nil), references: T.unsafe(nil), start_time: T.unsafe(nil), tags: T.unsafe(nil), ignore_active_scope: T.unsafe(nil), finish_on_close: T.unsafe(nil)); end + + def start_span(operation_name, child_of: T.unsafe(nil), references: T.unsafe(nil), start_time: T.unsafe(nil), tags: T.unsafe(nil), ignore_active_scope: T.unsafe(nil)); end +end + +class OpenTracing::Tracer +end + +module OpenTracing + def self.active_span(*args, &block); end + + def self.extract(*args, &block); end + + def self.global_tracer(); end + + def self.global_tracer=(global_tracer); end + + def self.inject(*args, &block); end + + def self.scope_manager(*args, &block); end + + def self.start_active_span(*args, &block); end + + def self.start_span(*args, &block); end +end + +module Parallel + Stop = ::T.let(nil, ::T.untyped) + VERSION = ::T.let(nil, ::T.untyped) + Version = ::T.let(nil, ::T.untyped) +end + +class Parallel::Break +end + +class Parallel::Break +end + +class Parallel::DeadWorker +end + +class Parallel::DeadWorker +end + +class Parallel::ExceptionWrapper + def exception(); end + + def initialize(exception); end +end + +class Parallel::ExceptionWrapper +end + +class Parallel::JobFactory + def initialize(source, mutex); end + + def next(); end + + def pack(item, index); end + + def size(); end + + def unpack(data); end +end + +class Parallel::JobFactory +end + +class Parallel::Kill +end + +class Parallel::Kill +end + +module Parallel::ProcessorCount + def physical_processor_count(); end + + def processor_count(); end +end + +module Parallel::ProcessorCount +end + +class Parallel::UndumpableException + def initialize(original); end +end + +class Parallel::UndumpableException +end + +class Parallel::UserInterruptHandler + INTERRUPT_SIGNAL = ::T.let(nil, ::T.untyped) +end + +class Parallel::UserInterruptHandler + def self.kill(thing); end + + def self.kill_on_ctrl_c(pids, options); end +end + +class Parallel::Worker + def close_pipes(); end + + def initialize(read, write, pid); end + + def pid(); end + + def read(); end + + def stop(); end + + def thread(); end + + def thread=(thread); end + + def work(data); end + + def write(); end +end + +class Parallel::Worker +end + +module Parallel + extend ::Parallel::ProcessorCount + def self.all?(*args, &block); end + + def self.any?(*args, &block); end + + def self.each(array, options=T.unsafe(nil), &block); end + + def self.each_with_index(array, options=T.unsafe(nil), &block); end + + def self.flat_map(*args, &block); end + + def self.in_processes(options=T.unsafe(nil), &block); end + + def self.in_threads(options=T.unsafe(nil)); end + + def self.map(source, options=T.unsafe(nil), &block); end + + def self.map_with_index(array, options=T.unsafe(nil), &block); end + + def self.worker_number(); end + + def self.worker_number=(worker_num); end +end + +ParseError = Racc::ParseError + +module Parser + MESSAGES = ::T.let(nil, ::T.untyped) + VERSION = ::T.let(nil, ::T.untyped) +end + +module Parser::AST +end + +class Parser::AST::Node + def loc(); end + + def location(); end +end + +class Parser::AST::Node +end + +class Parser::AST::Processor + def on_alias(node); end + + def on_and(node); end + + def on_and_asgn(node); end + + def on_arg(node); end + + def on_arg_expr(node); end + + def on_args(node); end + + def on_argument(node); end + + def on_array(node); end + + def on_array_pattern(node); end + + def on_array_pattern_with_tail(node); end + + def on_back_ref(node); end + + def on_begin(node); end + + def on_block(node); end + + def on_block_pass(node); end + + def on_blockarg(node); end + + def on_blockarg_expr(node); end + + def on_break(node); end + + def on_case(node); end + + def on_case_match(node); end + + def on_casgn(node); end + + def on_class(node); end + + def on_const(node); end + + def on_const_pattern(node); end + + def on_csend(node); end + + def on_cvar(node); end + + def on_cvasgn(node); end + + def on_def(node); end + + def on_defined?(node); end + + def on_defs(node); end + + def on_dstr(node); end + + def on_dsym(node); end + + def on_eflipflop(node); end + + def on_empty_else(node); end + + def on_ensure(node); end + + def on_erange(node); end + + def on_for(node); end + + def on_gvar(node); end + + def on_gvasgn(node); end + + def on_hash(node); end + + def on_hash_pattern(node); end + + def on_if(node); end + + def on_if_guard(node); end + + def on_iflipflop(node); end + + def on_in_match(node); end + + def on_in_pattern(node); end + + def on_index(node); end + + def on_indexasgn(node); end + + def on_irange(node); end + + def on_ivar(node); end + + def on_ivasgn(node); end + + def on_kwarg(node); end + + def on_kwbegin(node); end + + def on_kwoptarg(node); end + + def on_kwrestarg(node); end + + def on_kwsplat(node); end + + def on_lambda(node); end + + def on_lvar(node); end + + def on_lvasgn(node); end + + def on_masgn(node); end + + def on_match_alt(node); end + + def on_match_as(node); end + + def on_match_current_line(node); end + + def on_match_rest(node); end + + def on_match_var(node); end + + def on_match_with_lvasgn(node); end + + def on_mlhs(node); end + + def on_module(node); end + + def on_next(node); end + + def on_not(node); end + + def on_nth_ref(node); end + + def on_numblock(node); end + + def on_op_asgn(node); end + + def on_optarg(node); end + + def on_or(node); end + + def on_or_asgn(node); end + + def on_pair(node); end + + def on_pin(node); end + + def on_postexe(node); end + + def on_preexe(node); end + + def on_procarg0(node); end + + def on_redo(node); end + + def on_regexp(node); end + + def on_resbody(node); end + + def on_rescue(node); end + + def on_restarg(node); end + + def on_restarg_expr(node); end + + def on_retry(node); end + + def on_return(node); end + + def on_sclass(node); end + + def on_send(node); end + + def on_shadowarg(node); end + + def on_splat(node); end + + def on_super(node); end + + def on_undef(node); end + + def on_unless_guard(node); end + + def on_until(node); end + + def on_until_post(node); end + + def on_var(node); end + + def on_vasgn(node); end + + def on_when(node); end + + def on_while(node); end + + def on_while_post(node); end + + def on_xstr(node); end + + def on_yield(node); end + + def process_argument_node(node); end + + def process_regular_node(node); end + + def process_var_asgn_node(node); end + + def process_variable_node(node); end +end + +class Parser::AST::Processor +end + +module Parser::AST +end + +class Parser::Base + def builder(); end + + def context(); end + + def current_arg_stack(); end + + def diagnostics(); end + + def initialize(builder=T.unsafe(nil)); end + + def max_numparam_stack(); end + + def parse(source_buffer); end + + def parse_with_comments(source_buffer); end + + def pattern_hash_keys(); end + + def pattern_variables(); end + + def reset(); end + + def source_buffer(); end + + def static_env(); end + + def tokenize(source_buffer, recover=T.unsafe(nil)); end +end + +class Parser::Base + def self.default_parser(); end + + def self.parse(string, file=T.unsafe(nil), line=T.unsafe(nil)); end + + def self.parse_file(filename); end + + def self.parse_file_with_comments(filename); end + + def self.parse_with_comments(string, file=T.unsafe(nil), line=T.unsafe(nil)); end +end + +module Parser::Builders +end + +class Parser::Builders::Default + def __ENCODING__(__ENCODING__t); end + + def __FILE__(__FILE__t); end + + def __LINE__(__LINE__t); end + + def accessible(node); end + + def alias(alias_t, to, from); end + + def arg(name_t); end + + def arg_expr(expr); end + + def args(begin_t, args, end_t, check_args=T.unsafe(nil)); end + + def array(begin_t, elements, end_t); end + + def array_pattern(lbrack_t, elements, rbrack_t); end + + def assign(lhs, eql_t, rhs); end + + def assignable(node); end + + def associate(begin_t, pairs, end_t); end + + def attr_asgn(receiver, dot_t, selector_t); end + + def back_ref(token); end + + def begin(begin_t, body, end_t); end + + def begin_body(compound_stmt, rescue_bodies=T.unsafe(nil), else_t=T.unsafe(nil), else_=T.unsafe(nil), ensure_t=T.unsafe(nil), ensure_=T.unsafe(nil)); end + + def begin_keyword(begin_t, body, end_t); end + + def binary_op(receiver, operator_t, arg); end + + def block(method_call, begin_t, args, body, end_t); end + + def block_pass(amper_t, arg); end + + def blockarg(amper_t, name_t); end + + def blockarg_expr(amper_t, expr); end + + def call_lambda(lambda_t); end + + def call_method(receiver, dot_t, selector_t, lparen_t=T.unsafe(nil), args=T.unsafe(nil), rparen_t=T.unsafe(nil)); end + + def call_type_for_dot(dot_t); end + + def case(case_t, expr, when_bodies, else_t, else_body, end_t); end + + def case_match(case_t, expr, in_bodies, else_t, else_body, end_t); end + + def character(char_t); end + + def complex(complex_t); end + + def compstmt(statements); end + + def condition(cond_t, cond, then_t, if_true, else_t, if_false, end_t); end + + def condition_mod(if_true, if_false, cond_t, cond); end + + def const(name_t); end + + def const_fetch(scope, t_colon2, name_t); end + + def const_global(t_colon3, name_t); end + + def const_op_assignable(node); end + + def const_pattern(const, ldelim_t, pattern, rdelim_t); end + + def cvar(token); end + + def dedent_string(node, dedent_level); end + + def def_class(class_t, name, lt_t, superclass, body, end_t); end + + def def_method(def_t, name_t, args, body, end_t); end + + def def_module(module_t, name, body, end_t); end + + def def_sclass(class_t, lshft_t, expr, body, end_t); end + + def def_singleton(def_t, definee, dot_t, name_t, args, body, end_t); end + + def emit_file_line_as_literals(); end + + def emit_file_line_as_literals=(emit_file_line_as_literals); end + + def false(false_t); end + + def float(float_t); end + + def for(for_t, iterator, in_t, iteratee, do_t, body, end_t); end + + def forward_args(begin_t, dots_t, end_t); end + + def forwarded_args(dots_t); end + + def gvar(token); end + + def hash_pattern(lbrace_t, kwargs, rbrace_t); end + + def ident(token); end + + def if_guard(if_t, if_body); end + + def in_match(lhs, in_t, rhs); end + + def in_pattern(in_t, pattern, guard, then_t, body); end + + def index(receiver, lbrack_t, indexes, rbrack_t); end + + def index_asgn(receiver, lbrack_t, indexes, rbrack_t); end + + def integer(integer_t); end + + def ivar(token); end + + def keyword_cmd(type, keyword_t, lparen_t=T.unsafe(nil), args=T.unsafe(nil), rparen_t=T.unsafe(nil)); end + + def kwarg(name_t); end + + def kwnilarg(dstar_t, nil_t); end + + def kwoptarg(name_t, value); end + + def kwrestarg(dstar_t, name_t=T.unsafe(nil)); end + + def kwsplat(dstar_t, arg); end + + def logical_op(type, lhs, op_t, rhs); end + + def loop(type, keyword_t, cond, do_t, body, end_t); end + + def loop_mod(type, body, keyword_t, cond); end + + def match_alt(left, pipe_t, right); end + + def match_as(value, assoc_t, as); end + + def match_hash_var(name_t); end + + def match_hash_var_from_str(begin_t, strings, end_t); end + + def match_label(label_type, label); end + + def match_nil_pattern(dstar_t, nil_t); end + + def match_op(receiver, match_t, arg); end + + def match_pair(label_type, label, value); end + + def match_rest(star_t, name_t=T.unsafe(nil)); end + + def match_var(name_t); end + + def match_with_trailing_comma(match); end + + def multi_assign(lhs, eql_t, rhs); end + + def multi_lhs(begin_t, items, end_t); end + + def nil(nil_t); end + + def not_op(not_t, begin_t=T.unsafe(nil), receiver=T.unsafe(nil), end_t=T.unsafe(nil)); end + + def nth_ref(token); end + + def numargs(max_numparam); end + + def objc_kwarg(kwname_t, assoc_t, name_t); end + + def objc_restarg(star_t, name=T.unsafe(nil)); end + + def objc_varargs(pair, rest_of_varargs); end + + def op_assign(lhs, op_t, rhs); end + + def optarg(name_t, eql_t, value); end + + def pair(key, assoc_t, value); end + + def pair_keyword(key_t, value); end + + def pair_list_18(list); end + + def pair_quoted(begin_t, parts, end_t, value); end + + def parser(); end + + def parser=(parser); end + + def pin(pin_t, var); end + + def postexe(postexe_t, lbrace_t, compstmt, rbrace_t); end + + def preexe(preexe_t, lbrace_t, compstmt, rbrace_t); end + + def procarg0(arg); end + + def range_exclusive(lhs, dot3_t, rhs); end + + def range_inclusive(lhs, dot2_t, rhs); end + + def rational(rational_t); end + + def regexp_compose(begin_t, parts, end_t, options); end + + def regexp_options(regopt_t); end + + def rescue_body(rescue_t, exc_list, assoc_t, exc_var, then_t, compound_stmt); end + + def restarg(star_t, name_t=T.unsafe(nil)); end + + def restarg_expr(star_t, expr=T.unsafe(nil)); end + + def self(token); end + + def shadowarg(name_t); end + + def splat(star_t, arg=T.unsafe(nil)); end + + def string(string_t); end + + def string_compose(begin_t, parts, end_t); end + + def string_internal(string_t); end + + def symbol(symbol_t); end + + def symbol_compose(begin_t, parts, end_t); end + + def symbol_internal(symbol_t); end + + def symbols_compose(begin_t, parts, end_t); end + + def ternary(cond, question_t, if_true, colon_t, if_false); end + + def true(true_t); end + + def unary_num(unary_t, numeric); end + + def unary_op(op_t, receiver); end + + def undef_method(undef_t, names); end + + def unless_guard(unless_t, unless_body); end + + def when(when_t, patterns, then_t, body); end + + def word(parts); end + + def words_compose(begin_t, parts, end_t); end + + def xstring_compose(begin_t, parts, end_t); end +end + +class Parser::Builders::Default + def self.emit_arg_inside_procarg0(); end + + def self.emit_arg_inside_procarg0=(emit_arg_inside_procarg0); end + + def self.emit_encoding(); end + + def self.emit_encoding=(emit_encoding); end + + def self.emit_index(); end + + def self.emit_index=(emit_index); end + + def self.emit_lambda(); end + + def self.emit_lambda=(emit_lambda); end + + def self.emit_procarg0(); end + + def self.emit_procarg0=(emit_procarg0); end + + def self.modernize(); end +end + +module Parser::Builders +end + +class Parser::ClobberingError +end + +class Parser::ClobberingError +end + +class Parser::Context + def class_definition_allowed?(); end + + def dynamic_const_definition_allowed?(); end + + def in_block?(); end + + def in_class?(); end + + def in_dynamic_block?(); end + + def in_lambda?(); end + + def indirectly_in_def?(); end + + def module_definition_allowed?(); end + + def pop(); end + + def push(state); end + + def reset(); end + + def stack(); end +end + +class Parser::Context +end + +class Parser::CurrentArgStack + def pop(); end + + def push(value); end + + def reset(); end + + def set(value); end + + def stack(); end + + def top(); end +end + +class Parser::CurrentArgStack +end + +module Parser::Deprecation + def warn_of_deprecation(); end + + def warned_of_deprecation=(warned_of_deprecation); end +end + +module Parser::Deprecation +end + +class Parser::Diagnostic + def arguments(); end + + def highlights(); end + + def initialize(level, reason, arguments, location, highlights=T.unsafe(nil)); end + + def level(); end + + def location(); end + + def message(); end + + def reason(); end + + def render(); end + LEVELS = ::T.let(nil, ::T.untyped) +end + +class Parser::Diagnostic::Engine + def all_errors_are_fatal(); end + + def all_errors_are_fatal=(all_errors_are_fatal); end + + def consumer(); end + + def consumer=(consumer); end + + def ignore?(diagnostic); end + + def ignore_warnings(); end + + def ignore_warnings=(ignore_warnings); end + + def initialize(consumer=T.unsafe(nil)); end + + def process(diagnostic); end + + def raise?(diagnostic); end +end + +class Parser::Diagnostic::Engine +end + +class Parser::Diagnostic +end + +class Parser::Lexer + def advance(); end + + def arg_or_cmdarg(cmd_state); end + + def cmdarg(); end + + def cmdarg=(cmdarg); end + + def command_start(); end + + def command_start=(command_start); end + + def comments(); end + + def comments=(comments); end + + def cond(); end + + def cond=(cond); end + + def context(); end + + def context=(context); end + + def dedent_level(); end + + def diagnostic(type, reason, arguments=T.unsafe(nil), location=T.unsafe(nil), highlights=T.unsafe(nil)); end + + def diagnostics(); end + + def diagnostics=(diagnostics); end + + def emit(type, value=T.unsafe(nil), s=T.unsafe(nil), e=T.unsafe(nil)); end + + def emit_comment(s=T.unsafe(nil), e=T.unsafe(nil)); end + + def emit_do(do_block=T.unsafe(nil)); end + + def emit_table(table, s=T.unsafe(nil), e=T.unsafe(nil)); end + + def encode_escape(ord); end + + def encoding(); end + + def eof_codepoint?(point); end + + def force_utf32(); end + + def force_utf32=(force_utf32); end + + def in_kwarg(); end + + def in_kwarg=(in_kwarg); end + + def initialize(version); end + + def literal(); end + + def next_state_for_literal(literal); end + + def pop_cmdarg(); end + + def pop_cond(); end + + def pop_literal(); end + + def push_cmdarg(); end + + def push_cond(); end + + def push_literal(*args); end + + def range(s=T.unsafe(nil), e=T.unsafe(nil)); end + + def reset(reset_state=T.unsafe(nil)); end + + def source_buffer(); end + + def source_buffer=(source_buffer); end + + def stack_pop(); end + + def state(); end + + def state=(state); end + + def static_env(); end + + def static_env=(static_env); end + + def tok(s=T.unsafe(nil), e=T.unsafe(nil)); end + + def tokens(); end + + def tokens=(tokens); end + + def version?(*versions); end + ESCAPES = ::T.let(nil, ::T.untyped) + KEYWORDS = ::T.let(nil, ::T.untyped) + KEYWORDS_BEGIN = ::T.let(nil, ::T.untyped) + LEX_STATES = ::T.let(nil, ::T.untyped) + PUNCTUATION = ::T.let(nil, ::T.untyped) + PUNCTUATION_BEGIN = ::T.let(nil, ::T.untyped) + REGEXP_META_CHARACTERS = ::T.let(nil, ::T.untyped) +end + +class Parser::Lexer::Dedenter + def dedent(string); end + + def initialize(dedent_level); end + + def interrupt(); end + TAB_WIDTH = ::T.let(nil, ::T.untyped) +end + +class Parser::Lexer::Dedenter +end + +class Parser::Lexer::Literal + def backslash_delimited?(); end + + def clear_buffer(); end + + def coerce_encoding(string); end + + def dedent_level(); end + + def delimiter?(delimiter); end + + def emit(token, type, s, e); end + + def emit_start_tok(); end + + def end_interp_brace_and_try_closing(); end + + def extend_content(); end + + def extend_space(ts, te); end + + def extend_string(string, ts, te); end + + def flush_string(); end + + def heredoc?(); end + + def heredoc_e(); end + + def infer_indent_level(line); end + + def initialize(lexer, str_type, delimiter, str_s, heredoc_e=T.unsafe(nil), indent=T.unsafe(nil), dedent_body=T.unsafe(nil), label_allowed=T.unsafe(nil)); end + + def interpolate?(); end + + def munge_escape?(character); end + + def nest_and_try_closing(delimiter, ts, te, lookahead=T.unsafe(nil)); end + + def plain_heredoc?(); end + + def regexp?(); end + + def saved_herebody_s(); end + + def saved_herebody_s=(saved_herebody_s); end + + def squiggly_heredoc?(); end + + def start_interp_brace(); end + + def str_s(); end + + def supports_line_continuation_via_slash?(); end + + def type(); end + + def words?(); end + DELIMITERS = ::T.let(nil, ::T.untyped) + TYPES = ::T.let(nil, ::T.untyped) +end + +class Parser::Lexer::Literal +end + +class Parser::Lexer::StackState + def active?(); end + + def clear(); end + + def empty?(); end + + def initialize(name); end + + def lexpop(); end + + def pop(); end + + def push(bit); end +end + +class Parser::Lexer::StackState +end + +class Parser::Lexer + def self.lex_en_expr_arg(); end + + def self.lex_en_expr_arg=(lex_en_expr_arg); end + + def self.lex_en_expr_beg(); end + + def self.lex_en_expr_beg=(lex_en_expr_beg); end + + def self.lex_en_expr_cmdarg(); end + + def self.lex_en_expr_cmdarg=(lex_en_expr_cmdarg); end + + def self.lex_en_expr_dot(); end + + def self.lex_en_expr_dot=(lex_en_expr_dot); end + + def self.lex_en_expr_end(); end + + def self.lex_en_expr_end=(lex_en_expr_end); end + + def self.lex_en_expr_endarg(); end + + def self.lex_en_expr_endarg=(lex_en_expr_endarg); end + + def self.lex_en_expr_endfn(); end + + def self.lex_en_expr_endfn=(lex_en_expr_endfn); end + + def self.lex_en_expr_fname(); end + + def self.lex_en_expr_fname=(lex_en_expr_fname); end + + def self.lex_en_expr_labelarg(); end + + def self.lex_en_expr_labelarg=(lex_en_expr_labelarg); end + + def self.lex_en_expr_mid(); end + + def self.lex_en_expr_mid=(lex_en_expr_mid); end + + def self.lex_en_expr_value(); end + + def self.lex_en_expr_value=(lex_en_expr_value); end + + def self.lex_en_expr_variable(); end + + def self.lex_en_expr_variable=(lex_en_expr_variable); end + + def self.lex_en_interp_backslash_delimited(); end + + def self.lex_en_interp_backslash_delimited=(lex_en_interp_backslash_delimited); end + + def self.lex_en_interp_backslash_delimited_words(); end + + def self.lex_en_interp_backslash_delimited_words=(lex_en_interp_backslash_delimited_words); end + + def self.lex_en_interp_string(); end + + def self.lex_en_interp_string=(lex_en_interp_string); end + + def self.lex_en_interp_words(); end + + def self.lex_en_interp_words=(lex_en_interp_words); end + + def self.lex_en_leading_dot(); end + + def self.lex_en_leading_dot=(lex_en_leading_dot); end + + def self.lex_en_line_begin(); end + + def self.lex_en_line_begin=(lex_en_line_begin); end + + def self.lex_en_line_comment(); end + + def self.lex_en_line_comment=(lex_en_line_comment); end + + def self.lex_en_plain_backslash_delimited(); end + + def self.lex_en_plain_backslash_delimited=(lex_en_plain_backslash_delimited); end + + def self.lex_en_plain_backslash_delimited_words(); end + + def self.lex_en_plain_backslash_delimited_words=(lex_en_plain_backslash_delimited_words); end + + def self.lex_en_plain_string(); end + + def self.lex_en_plain_string=(lex_en_plain_string); end + + def self.lex_en_plain_words(); end + + def self.lex_en_plain_words=(lex_en_plain_words); end + + def self.lex_en_regexp_modifiers(); end + + def self.lex_en_regexp_modifiers=(lex_en_regexp_modifiers); end + + def self.lex_error(); end + + def self.lex_error=(lex_error); end + + def self.lex_start(); end + + def self.lex_start=(lex_start); end +end + +class Parser::MaxNumparamStack + def has_numparams?(); end + + def has_ordinary_params!(); end + + def has_ordinary_params?(); end + + def pop(); end + + def push(); end + + def register(numparam); end + + def stack(); end + + def top(); end +end + +class Parser::MaxNumparamStack +end + +module Parser::Meta + NODE_TYPES = ::T.let(nil, ::T.untyped) +end + +module Parser::Meta +end + +class Parser::Rewriter + def assignment?(node); end + + def initialize(*_); end + + def insert_after(range, content); end + + def insert_before(range, content); end + + def remove(range); end + + def replace(range, content); end + + def rewrite(source_buffer, ast); end + + def wrap(range, before, after); end + DEPRECATION_WARNING = ::T.let(nil, ::T.untyped) +end + +class Parser::Rewriter + extend ::Parser::Deprecation +end + +module Parser::Source +end + +class Parser::Source::Buffer + def column_for_position(position); end + + def decompose_position(position); end + + def first_line(); end + + def initialize(name, first_line=T.unsafe(nil)); end + + def last_line(); end + + def line_for_position(position); end + + def line_range(lineno); end + + def name(); end + + def raw_source=(input); end + + def read(); end + + def slice(range); end + + def source(); end + + def source=(input); end + + def source_line(lineno); end + + def source_lines(); end + + def source_range(); end + ENCODING_RE = ::T.let(nil, ::T.untyped) +end + +class Parser::Source::Buffer + def self.recognize_encoding(string); end + + def self.reencode_string(input); end +end + +class Parser::Source::Comment + def ==(other); end + + def document?(); end + + def initialize(range); end + + def inline?(); end + + def loc(); end + + def location(); end + + def text(); end + + def type(); end +end + +class Parser::Source::Comment::Associator + def associate(); end + + def associate_locations(); end + + def initialize(ast, comments); end + + def skip_directives(); end + + def skip_directives=(skip_directives); end + MAGIC_COMMENT_RE = ::T.let(nil, ::T.untyped) +end + +class Parser::Source::Comment::Associator +end + +class Parser::Source::Comment + def self.associate(ast, comments); end + + def self.associate_locations(ast, comments); end +end + +class Parser::Source::Map + def ==(other); end + + def column(); end + + def expression(); end + + def first_line(); end + + def initialize(expression); end + + def last_column(); end + + def last_line(); end + + def line(); end + + def node(); end + + def node=(node); end + + def to_hash(); end + + def update_expression(expression_l); end + + def with(&block); end + + def with_expression(expression_l); end +end + +class Parser::Source::Map::Collection + def begin(); end + + def end(); end + + def initialize(begin_l, end_l, expression_l); end +end + +class Parser::Source::Map::Collection +end + +class Parser::Source::Map::Condition + def begin(); end + + def else(); end + + def end(); end + + def initialize(keyword_l, begin_l, else_l, end_l, expression_l); end + + def keyword(); end +end + +class Parser::Source::Map::Condition +end + +class Parser::Source::Map::Constant + def double_colon(); end + + def initialize(double_colon, name, expression); end + + def name(); end + + def operator(); end + + def update_operator(operator_l); end + + def with_operator(operator_l); end +end + +class Parser::Source::Map::Constant +end + +class Parser::Source::Map::Definition + def end(); end + + def initialize(keyword_l, operator_l, name_l, end_l); end + + def keyword(); end + + def name(); end + + def operator(); end +end + +class Parser::Source::Map::Definition +end + +class Parser::Source::Map::For + def begin(); end + + def end(); end + + def in(); end + + def initialize(keyword_l, in_l, begin_l, end_l, expression_l); end + + def keyword(); end +end + +class Parser::Source::Map::For +end + +class Parser::Source::Map::Heredoc + def heredoc_body(); end + + def heredoc_end(); end + + def initialize(begin_l, body_l, end_l); end +end + +class Parser::Source::Map::Heredoc +end + +class Parser::Source::Map::Index + def begin(); end + + def end(); end + + def initialize(begin_l, end_l, expression_l); end + + def operator(); end + + def update_operator(operator_l); end + + def with_operator(operator_l); end +end + +class Parser::Source::Map::Index +end + +class Parser::Source::Map::Keyword + def begin(); end + + def end(); end + + def initialize(keyword_l, begin_l, end_l, expression_l); end + + def keyword(); end +end + +class Parser::Source::Map::Keyword +end + +class Parser::Source::Map::ObjcKwarg + def argument(); end + + def initialize(keyword_l, operator_l, argument_l, expression_l); end + + def keyword(); end + + def operator(); end +end + +class Parser::Source::Map::ObjcKwarg +end + +class Parser::Source::Map::Operator + def initialize(operator, expression); end + + def operator(); end +end + +class Parser::Source::Map::Operator +end + +class Parser::Source::Map::RescueBody + def assoc(); end + + def begin(); end + + def initialize(keyword_l, assoc_l, begin_l, expression_l); end + + def keyword(); end +end + +class Parser::Source::Map::RescueBody +end + +class Parser::Source::Map::Send + def begin(); end + + def dot(); end + + def end(); end + + def initialize(dot_l, selector_l, begin_l, end_l, expression_l); end + + def operator(); end + + def selector(); end + + def update_operator(operator_l); end + + def with_operator(operator_l); end +end + +class Parser::Source::Map::Send +end + +class Parser::Source::Map::Ternary + def colon(); end + + def initialize(question_l, colon_l, expression_l); end + + def question(); end +end + +class Parser::Source::Map::Ternary +end + +class Parser::Source::Map::Variable + def initialize(name_l, expression_l=T.unsafe(nil)); end + + def name(); end + + def operator(); end + + def update_operator(operator_l); end + + def with_operator(operator_l); end +end + +class Parser::Source::Map::Variable +end + +class Parser::Source::Map +end + +class Parser::Source::Range + include ::Comparable + def adjust(begin_pos: T.unsafe(nil), end_pos: T.unsafe(nil)); end + + def begin(); end + + def begin_pos(); end + + def column(); end + + def column_range(); end + + def contained?(other); end + + def contains?(other); end + + def crossing?(other); end + + def disjoint?(other); end + + def empty?(); end + + def end(); end + + def end_pos(); end + + def first_line(); end + + def initialize(source_buffer, begin_pos, end_pos); end + + def intersect(other); end + + def is?(*what); end + + def join(other); end + + def last_column(); end + + def last_line(); end + + def length(); end + + def line(); end + + def overlaps?(other); end + + def resize(new_size); end + + def size(); end + + def source(); end + + def source_buffer(); end + + def source_line(); end + + def to_a(); end + + def with(begin_pos: T.unsafe(nil), end_pos: T.unsafe(nil)); end +end + +class Parser::Source::Range +end + +class Parser::Source::Rewriter + def diagnostics(); end + + def initialize(source_buffer); end + + def insert_after(range, content); end + + def insert_after_multi(range, content); end + + def insert_before(range, content); end + + def insert_before_multi(range, content); end + + def process(); end + + def remove(range); end + + def replace(range, content); end + + def source_buffer(); end + + def transaction(); end + + def wrap(range, before, after); end + DEPRECATION_WARNING = ::T.let(nil, ::T.untyped) +end + +class Parser::Source::Rewriter::Action + include ::Comparable + def allow_multiple_insertions(); end + + def allow_multiple_insertions?(); end + + def initialize(range, replacement=T.unsafe(nil), allow_multiple_insertions=T.unsafe(nil), order=T.unsafe(nil)); end + + def order(); end + + def range(); end + + def replacement(); end +end + +class Parser::Source::Rewriter::Action +end + +class Parser::Source::Rewriter + extend ::Parser::Deprecation +end + +class Parser::Source::TreeRewriter + def diagnostics(); end + + def in_transaction?(); end + + def initialize(source_buffer, crossing_deletions: T.unsafe(nil), different_replacements: T.unsafe(nil), swallowed_insertions: T.unsafe(nil)); end + + def insert_after(range, content); end + + def insert_after_multi(range, text); end + + def insert_before(range, content); end + + def insert_before_multi(range, text); end + + def process(); end + + def remove(range); end + + def replace(range, content); end + + def source_buffer(); end + + def transaction(); end + + def wrap(range, insert_before, insert_after); end + ACTIONS = ::T.let(nil, ::T.untyped) + DEPRECATION_WARNING = ::T.let(nil, ::T.untyped) + POLICY_TO_LEVEL = ::T.let(nil, ::T.untyped) +end + +class Parser::Source::TreeRewriter::Action + def call_enforcer_for_merge(action); end + + def combine(action); end + + def do_combine(action); end + + def fuse_deletions(action, fusible, other_sibblings); end + + def initialize(range, enforcer, insert_before: T.unsafe(nil), replacement: T.unsafe(nil), insert_after: T.unsafe(nil), children: T.unsafe(nil)); end + + def insert_after(); end + + def insert_before(); end + + def insertion?(); end + + def merge(action); end + + def ordered_replacements(); end + + def place_in_hierarchy(action); end + + def range(); end + + def relationship_with(action); end + + def replacement(); end + + def swallow(children); end + + def with(range: T.unsafe(nil), children: T.unsafe(nil), insert_before: T.unsafe(nil), replacement: T.unsafe(nil), insert_after: T.unsafe(nil)); end +end + +class Parser::Source::TreeRewriter::Action +end + +class Parser::Source::TreeRewriter + extend ::Parser::Deprecation +end + +module Parser::Source +end + +class Parser::StaticEnvironment + def declare(name); end + + def declare_forward_args(); end + + def declared?(name); end + + def declared_forward_args?(); end + + def extend_dynamic(); end + + def extend_static(); end + + def reset(); end + + def unextend(); end + FORWARD_ARGS = ::T.let(nil, ::T.untyped) +end + +class Parser::StaticEnvironment +end + +class Parser::SyntaxError + def diagnostic(); end + + def initialize(diagnostic); end +end + +class Parser::SyntaxError +end + +class Parser::TreeRewriter + def assignment?(node); end + + def insert_after(range, content); end + + def insert_before(range, content); end + + def remove(range); end + + def replace(range, content); end + + def rewrite(source_buffer, ast, **policy); end + + def wrap(range, before, after); end +end + +class Parser::TreeRewriter +end + +class Parser::VariablesStack + def declare(name); end + + def declared?(name); end + + def pop(); end + + def push(); end + + def reset(); end +end + +class Parser::VariablesStack +end + +module Parser +end + +class Pathname + def empty?(); end + + def fnmatch?(*_); end + + def glob(*_); end + + def make_symlink(_); end +end + +class Proc + def <<(_); end + + def ===(*_); end + + def >>(_); end + + def clone(); end + + def yield(*_); end +end + +module Process::Sys + def self.getegid(); end +end + +class Process::Tms + def cstime(); end + + def cstime=(_); end + + def cutime(); end + + def cutime=(_); end + + def stime(); end + + def stime=(_); end + + def utime(); end + + def utime=(_); end +end + +class Process::Tms + def self.[](*_); end + + def self.members(); end +end + +module Process + def self.last_status(); end + + def self.setpgrp(); end +end + +class ProgressBar +end + +class ProgressBar::Base + def autofinish(); end + + def autofinish=(autofinish); end + + def autostart(); end + + def autostart=(autostart); end + + def bar(); end + + def bar=(bar); end + + def clear(*args, &block); end + + def decrement(); end + + def finish(); end + + def finished(); end + + def finished=(finished); end + + def finished?(); end + + def format(other); end + + def format=(other); end + + def increment(); end + + def initialize(options=T.unsafe(nil)); end + + def log(*args, &block); end + + def output(); end + + def output=(output); end + + def pause(); end + + def paused?(); end + + def percentage(); end + + def percentage=(percentage); end + + def progress(*args, &block); end + + def progress=(new_progress); end + + def progress_mark=(mark); end + + def progressable(); end + + def progressable=(progressable); end + + def rate(); end + + def rate=(rate); end + + def refresh(*args, &block); end + + def remainder_mark=(mark); end + + def reset(); end + + def resume(); end + + def start(options=T.unsafe(nil)); end + + def started?(); end + + def stop(); end + + def stopped?(); end + + def time(); end + + def time=(time); end + + def timer(); end + + def timer=(timer); end + + def title(); end + + def title=(title); end + + def title_comp(); end + + def title_comp=(title_comp); end + + def to_h(); end + + def to_s(new_format=T.unsafe(nil)); end + + def total(*args, &block); end + + def total=(new_total); end + + def update_progress(*args); end +end + +class ProgressBar::Base + extend ::Forwardable +end + +module ProgressBar::Calculators +end + +class ProgressBar::Calculators::Length + def calculate_length(); end + + def current_length(); end + + def current_length=(current_length); end + + def initialize(options=T.unsafe(nil)); end + + def length(); end + + def length_changed?(); end + + def length_override(); end + + def length_override=(other); end + + def output(); end + + def output=(output); end + + def reset_length(); end +end + +class ProgressBar::Calculators::Length +end + +class ProgressBar::Calculators::RunningAverage +end + +class ProgressBar::Calculators::RunningAverage + def self.calculate(current_average, new_value_to_average, smoothing_factor); end +end + +module ProgressBar::Calculators +end + +module ProgressBar::Components +end + +class ProgressBar::Components::Bar + def initialize(options=T.unsafe(nil)); end + + def length(); end + + def length=(length); end + + def progress(); end + + def progress=(progress); end + + def progress_mark(); end + + def progress_mark=(progress_mark); end + + def remainder_mark(); end + + def remainder_mark=(remainder_mark); end + + def to_s(options=T.unsafe(nil)); end + + def upa_steps(); end + + def upa_steps=(upa_steps); end + DEFAULT_PROGRESS_MARK = ::T.let(nil, ::T.untyped) + DEFAULT_REMAINDER_MARK = ::T.let(nil, ::T.untyped) + DEFAULT_UPA_STEPS = ::T.let(nil, ::T.untyped) +end + +class ProgressBar::Components::Bar +end + +class ProgressBar::Components::Percentage + def initialize(options=T.unsafe(nil)); end + + def progress(); end + + def progress=(progress); end +end + +class ProgressBar::Components::Percentage +end + +class ProgressBar::Components::Rate + def initialize(options=T.unsafe(nil)); end + + def progress(); end + + def progress=(progress); end + + def rate_scale(); end + + def rate_scale=(rate_scale); end + + def started_at(); end + + def started_at=(started_at); end + + def stopped_at(); end + + def stopped_at=(stopped_at); end + + def timer(); end + + def timer=(timer); end +end + +class ProgressBar::Components::Rate +end + +class ProgressBar::Components::Time + def elapsed_with_label(); end + + def estimated_with_friendly_oob(); end + + def estimated_with_label(); end + + def estimated_with_no_oob(); end + + def estimated_with_unknown_oob(); end + + def initialize(options=T.unsafe(nil)); end + + def out_of_bounds_time_format(); end + + def out_of_bounds_time_format=(format); end + + def progress(); end + + def progress=(progress); end + + def timer(); end + + def timer=(timer); end + ELAPSED_LABEL = ::T.let(nil, ::T.untyped) + ESTIMATED_LABEL = ::T.let(nil, ::T.untyped) + NO_TIME_ELAPSED_TEXT = ::T.let(nil, ::T.untyped) + OOB_FRIENDLY_TIME_TEXT = ::T.let(nil, ::T.untyped) + OOB_LIMIT_IN_HOURS = ::T.let(nil, ::T.untyped) + OOB_TIME_FORMATS = ::T.let(nil, ::T.untyped) + OOB_UNKNOWN_TIME_TEXT = ::T.let(nil, ::T.untyped) + TIME_FORMAT = ::T.let(nil, ::T.untyped) +end + +class ProgressBar::Components::Time +end + +class ProgressBar::Components::Title + def initialize(options=T.unsafe(nil)); end + + def title(); end + + def title=(title); end + DEFAULT_TITLE = ::T.let(nil, ::T.untyped) +end + +class ProgressBar::Components::Title +end + +module ProgressBar::Components +end + +module ProgressBar::Format +end + +class ProgressBar::Format::Formatter +end + +class ProgressBar::Format::Formatter + def self.process(format_string, max_length, bar); end +end + +class ProgressBar::Format::Molecule + def bar_molecule?(); end + + def full_key(); end + + def initialize(letter); end + + def key(); end + + def key=(key); end + + def lookup_value(environment, length=T.unsafe(nil)); end + + def method_name(); end + + def method_name=(method_name); end + + def non_bar_molecule?(); end + BAR_MOLECULES = ::T.let(nil, ::T.untyped) + MOLECULES = ::T.let(nil, ::T.untyped) +end + +class ProgressBar::Format::Molecule +end + +class ProgressBar::Format::String + def bar_molecule_placeholder_length(); end + + def bar_molecules(); end + + def displayable_length(); end + + def molecules(); end + + def non_bar_molecules(); end + ANSI_SGR_PATTERN = ::T.let(nil, ::T.untyped) + MOLECULE_PATTERN = ::T.let(nil, ::T.untyped) +end + +class ProgressBar::Format::String +end + +module ProgressBar::Format +end + +class ProgressBar::InvalidProgressError +end + +class ProgressBar::InvalidProgressError +end + +class ProgressBar::Output + def bar(); end + + def bar=(bar); end + + def clear_string(); end + + def initialize(options=T.unsafe(nil)); end + + def length(); end + + def length_calculator(); end + + def length_calculator=(length_calculator); end + + def log(string); end + + def refresh(options=T.unsafe(nil)); end + + def stream(); end + + def stream=(stream); end + + def throttle(); end + + def throttle=(throttle); end + + def with_refresh(); end + DEFAULT_OUTPUT_STREAM = ::T.let(nil, ::T.untyped) +end + +class ProgressBar::Output + def self.detect(options=T.unsafe(nil)); end +end + +module ProgressBar::Outputs +end + +class ProgressBar::Outputs::NonTty + def bar_update_string(); end + + def clear(); end + + def default_format(); end + + def eol(); end + + def last_update_length(); end + + def last_update_length=(last_update_length); end + + def refresh_with_format_change(*_); end + + def resolve_format(*_); end + DEFAULT_FORMAT_STRING = ::T.let(nil, ::T.untyped) +end + +class ProgressBar::Outputs::NonTty +end + +class ProgressBar::Outputs::Tty + def bar_update_string(); end + + def clear(); end + + def default_format(); end + + def eol(); end + + def refresh_with_format_change(); end + + def resolve_format(other_format); end + DEFAULT_FORMAT_STRING = ::T.let(nil, ::T.untyped) +end + +class ProgressBar::Outputs::Tty +end + +module ProgressBar::Outputs +end + +class ProgressBar::Progress + def absolute(); end + + def decrement(); end + + def finish(); end + + def finished?(); end + + def increment(); end + + def initialize(options=T.unsafe(nil)); end + + def none?(); end + + def percentage_completed(); end + + def percentage_completed_with_precision(); end + + def progress(); end + + def progress=(new_progress); end + + def reset(); end + + def running_average(); end + + def running_average=(running_average); end + + def smoothing(); end + + def smoothing=(smoothing); end + + def start(options=T.unsafe(nil)); end + + def starting_position(); end + + def starting_position=(starting_position); end + + def total(); end + + def total=(new_total); end + + def total_with_unknown_indicator(); end + + def unknown?(); end + DEFAULT_BEGINNING_POSITION = ::T.let(nil, ::T.untyped) + DEFAULT_SMOOTHING = ::T.let(nil, ::T.untyped) + DEFAULT_TOTAL = ::T.let(nil, ::T.untyped) +end + +class ProgressBar::Progress +end + +module ProgressBar::Refinements +end + +module ProgressBar::Refinements::Enumerator +end + +module ProgressBar::Refinements::Enumerator +end + +module ProgressBar::Refinements +end + +class ProgressBar::Throttle + def choke(options=T.unsafe(nil)); end + + def initialize(options=T.unsafe(nil)); end + + def rate(); end + + def rate=(rate); end + + def started_at(); end + + def started_at=(started_at); end + + def stopped_at(); end + + def stopped_at=(stopped_at); end + + def timer(); end + + def timer=(timer); end +end + +class ProgressBar::Throttle +end + +class ProgressBar::Time + def initialize(time=T.unsafe(nil)); end + + def now(); end + + def time(); end + + def time=(time); end + + def unmocked_time_method(); end + TIME_MOCKING_LIBRARY_METHODS = ::T.let(nil, ::T.untyped) +end + +class ProgressBar::Time +end + +class ProgressBar::Timer + def divide_seconds(seconds); end + + def elapsed_seconds(); end + + def elapsed_whole_seconds(); end + + def initialize(options=T.unsafe(nil)); end + + def pause(); end + + def reset(); end + + def reset?(); end + + def restart(); end + + def resume(); end + + def start(); end + + def started?(); end + + def started_at(); end + + def started_at=(started_at); end + + def stop(); end + + def stopped?(); end + + def stopped_at(); end + + def stopped_at=(stopped_at); end + + def time(); end + + def time=(time); end +end + +class ProgressBar::Timer +end + +class ProgressBar + def self.create(*args); end +end + +module Psych + LIBYAML_VERSION = ::T.let(nil, ::T.untyped) + VERSION = ::T.let(nil, ::T.untyped) +end + +class Psych::BadAlias +end + +class Psych::BadAlias +end + +class Psych::ClassLoader + def big_decimal(); end + + def complex(); end + + def date(); end + + def date_time(); end + + def exception(); end + + def load(klassname); end + + def object(); end + + def psych_omap(); end + + def psych_set(); end + + def range(); end + + def rational(); end + + def regexp(); end + + def struct(); end + + def symbol(); end + + def symbolize(sym); end + BIG_DECIMAL = ::T.let(nil, ::T.untyped) + CACHE = ::T.let(nil, ::T.untyped) + COMPLEX = ::T.let(nil, ::T.untyped) + DATE = ::T.let(nil, ::T.untyped) + DATE_TIME = ::T.let(nil, ::T.untyped) + EXCEPTION = ::T.let(nil, ::T.untyped) + OBJECT = ::T.let(nil, ::T.untyped) + PSYCH_OMAP = ::T.let(nil, ::T.untyped) + PSYCH_SET = ::T.let(nil, ::T.untyped) + RANGE = ::T.let(nil, ::T.untyped) + RATIONAL = ::T.let(nil, ::T.untyped) + REGEXP = ::T.let(nil, ::T.untyped) + STRUCT = ::T.let(nil, ::T.untyped) + SYMBOL = ::T.let(nil, ::T.untyped) +end + +class Psych::ClassLoader::Restricted + def initialize(classes, symbols); end +end + +class Psych::ClassLoader::Restricted +end + +class Psych::ClassLoader +end + +class Psych::Coder + def [](k); end + + def []=(k, v); end + + def add(k, v); end + + def implicit(); end + + def implicit=(implicit); end + + def initialize(tag); end + + def map(tag=T.unsafe(nil), style=T.unsafe(nil)); end + + def map=(map); end + + def object(); end + + def object=(object); end + + def represent_map(tag, map); end + + def represent_object(tag, obj); end + + def represent_scalar(tag, value); end + + def represent_seq(tag, list); end + + def scalar(*args); end + + def scalar=(value); end + + def seq(); end + + def seq=(list); end + + def style(); end + + def style=(style); end + + def tag(); end + + def tag=(tag); end + + def type(); end +end + +class Psych::Coder +end + +class Psych::DisallowedClass + def initialize(klass_name); end +end + +class Psych::DisallowedClass +end + +class Psych::Emitter + def alias(_); end + + def canonical(); end + + def canonical=(canonical); end + + def end_document(_); end + + def indentation(); end + + def indentation=(indentation); end + + def initialize(*_); end + + def line_width(); end + + def line_width=(line_width); end + + def scalar(_, _1, _2, _3, _4, _5); end + + def start_document(_, _1, _2); end + + def start_mapping(_, _1, _2, _3); end + + def start_sequence(_, _1, _2, _3); end + + def start_stream(_); end +end + +class Psych::Emitter +end + +class Psych::Exception +end + +class Psych::Exception +end + +class Psych::Handler + def alias(anchor); end + + def empty(); end + + def end_document(implicit); end + + def end_mapping(); end + + def end_sequence(); end + + def end_stream(); end + + def event_location(start_line, start_column, end_line, end_column); end + + def scalar(value, anchor, tag, plain, quoted, style); end + + def start_document(version, tag_directives, implicit); end + + def start_mapping(anchor, tag, implicit, style); end + + def start_sequence(anchor, tag, implicit, style); end + + def start_stream(encoding); end + + def streaming?(); end + EVENTS = ::T.let(nil, ::T.untyped) + OPTIONS = ::T.let(nil, ::T.untyped) +end + +class Psych::Handler::DumperOptions + def canonical(); end + + def canonical=(canonical); end + + def indentation(); end + + def indentation=(indentation); end + + def line_width(); end + + def line_width=(line_width); end +end + +class Psych::Handler::DumperOptions +end + +class Psych::Handler +end + +module Psych::Handlers +end + +class Psych::Handlers::DocumentStream + def initialize(&block); end +end + +class Psych::Handlers::DocumentStream +end + +module Psych::Handlers +end + +module Psych::JSON +end + +module Psych::JSON::RubyEvents + def visit_DateTime(o); end + + def visit_String(o); end + + def visit_Symbol(o); end + + def visit_Time(o); end +end + +module Psych::JSON::RubyEvents +end + +class Psych::JSON::Stream + include ::Psych::Streaming +end + +class Psych::JSON::Stream::Emitter + include ::Psych::JSON::YAMLEvents +end + +class Psych::JSON::Stream::Emitter +end + +class Psych::JSON::Stream + extend ::Psych::Streaming::ClassMethods +end + +class Psych::JSON::TreeBuilder + include ::Psych::JSON::YAMLEvents +end + +class Psych::JSON::TreeBuilder +end + +module Psych::JSON::YAMLEvents + def end_document(implicit_end=T.unsafe(nil)); end + + def scalar(value, anchor, tag, plain, quoted, style); end + + def start_document(version, tag_directives, implicit); end + + def start_mapping(anchor, tag, implicit, style); end + + def start_sequence(anchor, tag, implicit, style); end +end + +module Psych::JSON::YAMLEvents +end + +module Psych::JSON +end + +module Psych::Nodes +end + +class Psych::Nodes::Alias + def anchor(); end + + def anchor=(anchor); end + + def initialize(anchor); end +end + +class Psych::Nodes::Alias +end + +class Psych::Nodes::Document + def implicit(); end + + def implicit=(implicit); end + + def implicit_end(); end + + def implicit_end=(implicit_end); end + + def initialize(version=T.unsafe(nil), tag_directives=T.unsafe(nil), implicit=T.unsafe(nil)); end + + def root(); end + + def tag_directives(); end + + def tag_directives=(tag_directives); end + + def version(); end + + def version=(version); end +end + +class Psych::Nodes::Document +end + +class Psych::Nodes::Mapping + def anchor(); end + + def anchor=(anchor); end + + def implicit(); end + + def implicit=(implicit); end + + def initialize(anchor=T.unsafe(nil), tag=T.unsafe(nil), implicit=T.unsafe(nil), style=T.unsafe(nil)); end + + def style(); end + + def style=(style); end + + def tag=(tag); end + ANY = ::T.let(nil, ::T.untyped) + BLOCK = ::T.let(nil, ::T.untyped) + FLOW = ::T.let(nil, ::T.untyped) +end + +class Psych::Nodes::Mapping +end + +class Psych::Nodes::Node + include ::Enumerable + def alias?(); end + + def children(); end + + def document?(); end + + def each(&block); end + + def end_column(); end + + def end_column=(end_column); end + + def end_line(); end + + def end_line=(end_line); end + + def mapping?(); end + + def scalar?(); end + + def sequence?(); end + + def start_column(); end + + def start_column=(start_column); end + + def start_line(); end + + def start_line=(start_line); end + + def stream?(); end + + def tag(); end + + def to_ruby(); end + + def to_yaml(io=T.unsafe(nil), options=T.unsafe(nil)); end + + def transform(); end + + def yaml(io=T.unsafe(nil), options=T.unsafe(nil)); end +end + +class Psych::Nodes::Node +end + +class Psych::Nodes::Scalar + def anchor(); end + + def anchor=(anchor); end + + def initialize(value, anchor=T.unsafe(nil), tag=T.unsafe(nil), plain=T.unsafe(nil), quoted=T.unsafe(nil), style=T.unsafe(nil)); end + + def plain(); end + + def plain=(plain); end + + def quoted(); end + + def quoted=(quoted); end + + def style(); end + + def style=(style); end + + def tag=(tag); end + + def value(); end + + def value=(value); end + ANY = ::T.let(nil, ::T.untyped) + DOUBLE_QUOTED = ::T.let(nil, ::T.untyped) + FOLDED = ::T.let(nil, ::T.untyped) + LITERAL = ::T.let(nil, ::T.untyped) + PLAIN = ::T.let(nil, ::T.untyped) + SINGLE_QUOTED = ::T.let(nil, ::T.untyped) +end + +class Psych::Nodes::Scalar +end + +class Psych::Nodes::Sequence + def anchor(); end + + def anchor=(anchor); end + + def implicit(); end + + def implicit=(implicit); end + + def initialize(anchor=T.unsafe(nil), tag=T.unsafe(nil), implicit=T.unsafe(nil), style=T.unsafe(nil)); end + + def style(); end + + def style=(style); end + + def tag=(tag); end + ANY = ::T.let(nil, ::T.untyped) + BLOCK = ::T.let(nil, ::T.untyped) + FLOW = ::T.let(nil, ::T.untyped) +end + +class Psych::Nodes::Sequence +end + +class Psych::Nodes::Stream + def encoding(); end + + def encoding=(encoding); end + + def initialize(encoding=T.unsafe(nil)); end + ANY = ::T.let(nil, ::T.untyped) + UTF16BE = ::T.let(nil, ::T.untyped) + UTF16LE = ::T.let(nil, ::T.untyped) + UTF8 = ::T.let(nil, ::T.untyped) +end + +class Psych::Nodes::Stream +end + +module Psych::Nodes +end + +class Psych::Omap +end + +class Psych::Omap +end + +class Psych::Parser + def external_encoding=(external_encoding); end + + def handler(); end + + def handler=(handler); end + + def initialize(handler=T.unsafe(nil)); end + + def mark(); end + + def parse(*_); end + ANY = ::T.let(nil, ::T.untyped) + UTF16BE = ::T.let(nil, ::T.untyped) + UTF16LE = ::T.let(nil, ::T.untyped) + UTF8 = ::T.let(nil, ::T.untyped) +end + +class Psych::Parser::Mark +end + +class Psych::Parser::Mark +end + +class Psych::Parser +end + +class Psych::ScalarScanner + def class_loader(); end + + def initialize(class_loader); end + + def parse_int(string); end + + def parse_time(string); end + + def tokenize(string); end + FLOAT = ::T.let(nil, ::T.untyped) + INTEGER = ::T.let(nil, ::T.untyped) + TIME = ::T.let(nil, ::T.untyped) +end + +class Psych::ScalarScanner +end + +class Psych::Set +end + +class Psych::Set +end + +class Psych::Stream + include ::Psych::Streaming +end + +class Psych::Stream::Emitter + def end_document(implicit_end=T.unsafe(nil)); end +end + +class Psych::Stream::Emitter +end + +class Psych::Stream + extend ::Psych::Streaming::ClassMethods +end + +module Psych::Streaming + def start(encoding=T.unsafe(nil)); end +end + +module Psych::Streaming::ClassMethods + def new(io); end +end + +module Psych::Streaming::ClassMethods +end + +module Psych::Streaming +end + +class Psych::SyntaxError + def column(); end + + def context(); end + + def file(); end + + def initialize(file, line, col, offset, problem, context); end + + def line(); end + + def offset(); end + + def problem(); end +end + +class Psych::SyntaxError +end + +class Psych::TreeBuilder + def end_document(implicit_end=T.unsafe(nil)); end + + def root(); end +end + +class Psych::TreeBuilder +end + +module Psych::Visitors +end + +class Psych::Visitors::DepthFirst + def initialize(block); end +end + +class Psych::Visitors::DepthFirst +end + +class Psych::Visitors::Emitter + def initialize(io, options=T.unsafe(nil)); end + + def visit_Psych_Nodes_Alias(o); end + + def visit_Psych_Nodes_Document(o); end + + def visit_Psych_Nodes_Mapping(o); end + + def visit_Psych_Nodes_Scalar(o); end + + def visit_Psych_Nodes_Sequence(o); end + + def visit_Psych_Nodes_Stream(o); end +end + +class Psych::Visitors::Emitter +end + +class Psych::Visitors::JSONTree + include ::Psych::JSON::RubyEvents +end + +class Psych::Visitors::JSONTree + def self.create(options=T.unsafe(nil)); end +end + +class Psych::Visitors::NoAliasRuby +end + +class Psych::Visitors::NoAliasRuby +end + +class Psych::Visitors::ToRuby + def class_loader(); end + + def initialize(ss, class_loader); end + + def visit_Psych_Nodes_Alias(o); end + + def visit_Psych_Nodes_Document(o); end + + def visit_Psych_Nodes_Mapping(o); end + + def visit_Psych_Nodes_Scalar(o); end + + def visit_Psych_Nodes_Sequence(o); end + + def visit_Psych_Nodes_Stream(o); end + SHOVEL = ::T.let(nil, ::T.untyped) +end + +class Psych::Visitors::ToRuby + def self.create(); end +end + +class Psych::Visitors::Visitor + def accept(target); end + DISPATCH = ::T.let(nil, ::T.untyped) +end + +class Psych::Visitors::Visitor +end + +class Psych::Visitors::YAMLTree + def <<(object); end + + def finish(); end + + def finished(); end + + def finished?(); end + + def initialize(emitter, ss, options); end + + def push(object); end + + def start(encoding=T.unsafe(nil)); end + + def started(); end + + def started?(); end + + def tree(); end + + def visit_Array(o); end + + def visit_BasicObject(o); end + + def visit_BigDecimal(o); end + + def visit_Class(o); end + + def visit_Complex(o); end + + def visit_Date(o); end + + def visit_DateTime(o); end + + def visit_Delegator(o); end + + def visit_Encoding(o); end + + def visit_Enumerator(o); end + + def visit_Exception(o); end + + def visit_FalseClass(o); end + + def visit_Float(o); end + + def visit_Hash(o); end + + def visit_Integer(o); end + + def visit_Module(o); end + + def visit_NameError(o); end + + def visit_NilClass(o); end + + def visit_Object(o); end + + def visit_Psych_Omap(o); end + + def visit_Psych_Set(o); end + + def visit_Range(o); end + + def visit_Rational(o); end + + def visit_Regexp(o); end + + def visit_String(o); end + + def visit_Struct(o); end + + def visit_Symbol(o); end + + def visit_Time(o); end + + def visit_TrueClass(o); end +end + +class Psych::Visitors::YAMLTree + def self.create(options=T.unsafe(nil), emitter=T.unsafe(nil)); end +end + +module Psych::Visitors +end + +module Psych + def self.add_builtin_type(type_tag, &block); end + + def self.add_domain_type(domain, type_tag, &block); end + + def self.add_tag(tag, klass); end + + def self.domain_types(); end + + def self.domain_types=(domain_types); end + + def self.dump(o, io=T.unsafe(nil), options=T.unsafe(nil)); end + + def self.dump_stream(*objects); end + + def self.dump_tags(); end + + def self.dump_tags=(dump_tags); end + + def self.libyaml_version(); end + + def self.load(yaml, legacy_filename=T.unsafe(nil), filename: T.unsafe(nil), fallback: T.unsafe(nil), symbolize_names: T.unsafe(nil)); end + + def self.load_file(filename, fallback: T.unsafe(nil)); end + + def self.load_stream(yaml, legacy_filename=T.unsafe(nil), filename: T.unsafe(nil), fallback: T.unsafe(nil)); end + + def self.load_tags(); end + + def self.load_tags=(load_tags); end + + def self.parse(yaml, legacy_filename=T.unsafe(nil), filename: T.unsafe(nil), fallback: T.unsafe(nil)); end + + def self.parse_file(filename, fallback: T.unsafe(nil)); end + + def self.parse_stream(yaml, legacy_filename=T.unsafe(nil), filename: T.unsafe(nil), &block); end + + def self.parser(); end + + def self.remove_type(type_tag); end + + def self.safe_load(yaml, legacy_permitted_classes=T.unsafe(nil), legacy_permitted_symbols=T.unsafe(nil), legacy_aliases=T.unsafe(nil), legacy_filename=T.unsafe(nil), permitted_classes: T.unsafe(nil), permitted_symbols: T.unsafe(nil), aliases: T.unsafe(nil), filename: T.unsafe(nil), fallback: T.unsafe(nil), symbolize_names: T.unsafe(nil)); end + + def self.to_json(object); end +end + +module REXML + COPYRIGHT = ::T.let(nil, ::T.untyped) + Copyright = ::T.let(nil, ::T.untyped) + DATE = ::T.let(nil, ::T.untyped) + REVISION = ::T.let(nil, ::T.untyped) + VERSION = ::T.let(nil, ::T.untyped) + Version = ::T.let(nil, ::T.untyped) +end + +class REXML::AttlistDecl + include ::Enumerable + def [](key); end + + def each(&block); end + + def element_name(); end + + def include?(key); end + + def initialize(source); end + + def node_type(); end + + def write(out, indent=T.unsafe(nil)); end +end + +class REXML::AttlistDecl +end + +class REXML::Attribute + include ::REXML::Node + include ::REXML::Namespace + include ::REXML::XMLTokens + def ==(other); end + + def clone(); end + + def doctype(); end + + def element(); end + + def element=(element); end + + def initialize(first, second=T.unsafe(nil), parent=T.unsafe(nil)); end + + def namespace(arg=T.unsafe(nil)); end + + def node_type(); end + + def normalized=(normalized); end + + def remove(); end + + def to_s(); end + + def to_string(); end + + def value(); end + + def write(output, indent=T.unsafe(nil)); end + + def xpath(); end + NEEDS_A_SECOND_CHECK = ::T.let(nil, ::T.untyped) + PATTERN = ::T.let(nil, ::T.untyped) +end + +class REXML::Attribute +end + +class REXML::Attributes + def <<(attribute); end + + def [](name); end + + def []=(name, value); end + + def add(attribute); end + + def delete(attribute); end + + def delete_all(name); end + + def each_attribute(); end + + def get_attribute(name); end + + def get_attribute_ns(namespace, name); end + + def initialize(element); end + + def namespaces(); end + + def prefixes(); end +end + +class REXML::Attributes +end + +class REXML::CData + def initialize(first, whitespace=T.unsafe(nil), parent=T.unsafe(nil)); end + + def write(output=T.unsafe(nil), indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end + ILLEGAL = ::T.let(nil, ::T.untyped) + START = ::T.let(nil, ::T.untyped) + STOP = ::T.let(nil, ::T.untyped) +end + +class REXML::CData +end + +class REXML::Child + include ::REXML::Node + def bytes(); end + + def document(); end + + def initialize(parent=T.unsafe(nil)); end + + def next_sibling(); end + + def next_sibling=(other); end + + def parent(); end + + def parent=(other); end + + def previous_sibling(); end + + def previous_sibling=(other); end + + def remove(); end + + def replace_with(child); end +end + +class REXML::Child +end + +class REXML::Comment + include ::Comparable + def ==(other); end + + def clone(); end + + def initialize(first, second=T.unsafe(nil)); end + + def node_type(); end + + def string(); end + + def string=(string); end + + def to_s(); end + + def write(output, indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end + START = ::T.let(nil, ::T.untyped) + STOP = ::T.let(nil, ::T.untyped) +end + +class REXML::Comment +end + +class REXML::Declaration + def initialize(src); end + + def to_s(); end + + def write(output, indent); end +end + +class REXML::Declaration +end + +class REXML::DocType + include ::REXML::XMLTokens + def add(child); end + + def attribute_of(element, attribute); end + + def attributes_of(element); end + + def clone(); end + + def context(); end + + def entities(); end + + def entity(name); end + + def external_id(); end + + def initialize(first, parent=T.unsafe(nil)); end + + def name(); end + + def namespaces(); end + + def node_type(); end + + def notation(name); end + + def notations(); end + + def public(); end + + def system(); end + + def write(output, indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end + DEFAULT_ENTITIES = ::T.let(nil, ::T.untyped) + PUBLIC = ::T.let(nil, ::T.untyped) + START = ::T.let(nil, ::T.untyped) + STOP = ::T.let(nil, ::T.untyped) + SYSTEM = ::T.let(nil, ::T.untyped) +end + +class REXML::DocType +end + +class REXML::Document + def <<(child); end + + def add(child); end + + def add_element(arg=T.unsafe(nil), arg2=T.unsafe(nil)); end + + def doctype(); end + + def encoding(); end + + def entity_expansion_count(); end + + def initialize(source=T.unsafe(nil), context=T.unsafe(nil)); end + + def record_entity_expansion(); end + + def stand_alone?(); end + + def version(); end + + def write(*arguments); end + + def xml_decl(); end + DECLARATION = ::T.let(nil, ::T.untyped) +end + +class REXML::Document + def self.entity_expansion_limit(); end + + def self.entity_expansion_limit=(val); end + + def self.entity_expansion_text_limit(); end + + def self.entity_expansion_text_limit=(val); end + + def self.parse_stream(source, listener); end +end + +class REXML::Element + include ::REXML::Namespace + include ::REXML::XMLTokens + def [](name_or_index); end + + def add_attribute(key, value=T.unsafe(nil)); end + + def add_attributes(hash); end + + def add_element(element, attrs=T.unsafe(nil)); end + + def add_namespace(prefix, uri=T.unsafe(nil)); end + + def add_text(text); end + + def attribute(name, namespace=T.unsafe(nil)); end + + def attributes(); end + + def cdatas(); end + + def clone(); end + + def comments(); end + + def context(); end + + def context=(context); end + + def delete_attribute(key); end + + def delete_element(element); end + + def delete_namespace(namespace=T.unsafe(nil)); end + + def each_element(xpath=T.unsafe(nil), &block); end + + def each_element_with_attribute(key, value=T.unsafe(nil), max=T.unsafe(nil), name=T.unsafe(nil), &block); end + + def each_element_with_text(text=T.unsafe(nil), max=T.unsafe(nil), name=T.unsafe(nil), &block); end + + def elements(); end + + def get_elements(xpath); end + + def get_text(path=T.unsafe(nil)); end + + def has_attributes?(); end + + def has_elements?(); end + + def has_text?(); end + + def ignore_whitespace_nodes(); end + + def initialize(arg=T.unsafe(nil), parent=T.unsafe(nil), context=T.unsafe(nil)); end + + def instructions(); end + + def namespace(prefix=T.unsafe(nil)); end + + def namespaces(); end + + def next_element(); end + + def node_type(); end + + def prefixes(); end + + def previous_element(); end + + def raw(); end + + def root(); end + + def root_node(); end + + def text(path=T.unsafe(nil)); end + + def text=(text); end + + def texts(); end + + def whitespace(); end + + def write(output=T.unsafe(nil), indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end + + def xpath(); end + UNDEFINED = ::T.let(nil, ::T.untyped) +end + +class REXML::Element +end + +class REXML::ElementDecl +end + +class REXML::ElementDecl +end + +class REXML::Elements + include ::Enumerable + def <<(element=T.unsafe(nil)); end + + def [](index, name=T.unsafe(nil)); end + + def []=(index, element); end + + def add(element=T.unsafe(nil)); end + + def collect(xpath=T.unsafe(nil)); end + + def delete(element); end + + def delete_all(xpath); end + + def each(xpath=T.unsafe(nil), &blk); end + + def empty?(); end + + def index(element); end + + def initialize(parent); end + + def inject(xpath=T.unsafe(nil), initial=T.unsafe(nil)); end + + def size(); end + + def to_a(xpath=T.unsafe(nil)); end +end + +class REXML::Elements +end + +module REXML::Encoding + def decode(string); end + + def encode(string); end + + def encoding(); end + + def encoding=(encoding); end +end + +module REXML::Encoding +end + +class REXML::Entity + include ::REXML::XMLTokens + def external(); end + + def initialize(stream, value=T.unsafe(nil), parent=T.unsafe(nil), reference=T.unsafe(nil)); end + + def name(); end + + def ndata(); end + + def normalized(); end + + def pubid(); end + + def ref(); end + + def to_s(); end + + def unnormalized(); end + + def value(); end + + def write(out, indent=T.unsafe(nil)); end + ENTITYDECL = ::T.let(nil, ::T.untyped) + ENTITYDEF = ::T.let(nil, ::T.untyped) + ENTITYVALUE = ::T.let(nil, ::T.untyped) + EXTERNALID = ::T.let(nil, ::T.untyped) + GEDECL = ::T.let(nil, ::T.untyped) + NDATADECL = ::T.let(nil, ::T.untyped) + PEDECL = ::T.let(nil, ::T.untyped) + PEDEF = ::T.let(nil, ::T.untyped) + PEREFERENCE = ::T.let(nil, ::T.untyped) + PEREFERENCE_RE = ::T.let(nil, ::T.untyped) + PUBIDCHAR = ::T.let(nil, ::T.untyped) + PUBIDLITERAL = ::T.let(nil, ::T.untyped) + SYSTEMLITERAL = ::T.let(nil, ::T.untyped) +end + +class REXML::Entity + def self.matches?(string); end +end + +module REXML::EntityConst + AMP = ::T.let(nil, ::T.untyped) + APOS = ::T.let(nil, ::T.untyped) + GT = ::T.let(nil, ::T.untyped) + LT = ::T.let(nil, ::T.untyped) + QUOT = ::T.let(nil, ::T.untyped) +end + +module REXML::EntityConst +end + +class REXML::ExternalEntity + def initialize(src); end + + def to_s(); end + + def write(output, indent); end +end + +class REXML::ExternalEntity +end + +module REXML::Formatters +end + +class REXML::Formatters::Default + def initialize(ie_hack=T.unsafe(nil)); end + + def write(node, output); end + + def write_cdata(node, output); end + + def write_comment(node, output); end + + def write_document(node, output); end + + def write_element(node, output); end + + def write_instruction(node, output); end + + def write_text(node, output); end +end + +class REXML::Formatters::Default +end + +class REXML::Formatters::Pretty + def compact(); end + + def compact=(compact); end + + def initialize(indentation=T.unsafe(nil), ie_hack=T.unsafe(nil)); end + + def width(); end + + def width=(width); end +end + +class REXML::Formatters::Pretty +end + +module REXML::Formatters +end + +module REXML::Functions + INTERNAL_METHODS = ::T.let(nil, ::T.untyped) +end + +module REXML::Functions + def self.boolean(object=T.unsafe(nil)); end + + def self.ceiling(number); end + + def self.compare_language(lang1, lang2); end + + def self.concat(*objects); end + + def self.contains(string, test); end + + def self.context=(value); end + + def self.count(node_set); end + + def self.false(); end + + def self.floor(number); end + + def self.get_namespace(node_set=T.unsafe(nil)); end + + def self.id(object); end + + def self.lang(language); end + + def self.last(); end + + def self.local_name(node_set=T.unsafe(nil)); end + + def self.name(node_set=T.unsafe(nil)); end + + def self.namespace_context(); end + + def self.namespace_context=(x); end + + def self.namespace_uri(node_set=T.unsafe(nil)); end + + def self.normalize_space(string=T.unsafe(nil)); end + + def self.not(object); end + + def self.number(object=T.unsafe(nil)); end + + def self.position(); end + + def self.processing_instruction(node); end + + def self.round(number); end + + def self.send(name, *args); end + + def self.singleton_method_added(name); end + + def self.starts_with(string, test); end + + def self.string(object=T.unsafe(nil)); end + + def self.string_length(string); end + + def self.string_value(o); end + + def self.substring(string, start, length=T.unsafe(nil)); end + + def self.substring_after(string, test); end + + def self.substring_before(string, test); end + + def self.sum(nodes); end + + def self.text(); end + + def self.translate(string, tr1, tr2); end + + def self.true(); end + + def self.variables(); end + + def self.variables=(x); end +end + +class REXML::IOSource + def initialize(arg, block_size=T.unsafe(nil), encoding=T.unsafe(nil)); end +end + +class REXML::IOSource +end + +class REXML::Instruction + def ==(other); end + + def clone(); end + + def content(); end + + def content=(content); end + + def initialize(target, content=T.unsafe(nil)); end + + def node_type(); end + + def target(); end + + def target=(target); end + + def write(writer, indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end + START = ::T.let(nil, ::T.untyped) + STOP = ::T.let(nil, ::T.untyped) +end + +class REXML::Instruction +end + +module REXML::Namespace + include ::REXML::XMLTokens + def expanded_name(); end + + def fully_expanded_name(); end + + def has_name?(other, ns=T.unsafe(nil)); end + + def local_name(); end + + def name(); end + + def name=(name); end + + def prefix(); end + + def prefix=(prefix); end + NAMESPLIT = ::T.let(nil, ::T.untyped) +end + +module REXML::Namespace +end + +module REXML::Node + def each_recursive(&block); end + + def find_first_recursive(&block); end + + def indent(to, ind); end + + def index_in_parent(); end + + def next_sibling_node(); end + + def parent?(); end + + def previous_sibling_node(); end + + def to_s(indent=T.unsafe(nil)); end +end + +module REXML::Node +end + +class REXML::NotationDecl + def initialize(name, middle, pub, sys); end + + def name(); end + + def public(); end + + def public=(public); end + + def system(); end + + def system=(system); end + + def to_s(); end + + def write(output, indent=T.unsafe(nil)); end +end + +class REXML::NotationDecl +end + +class REXML::Output + include ::REXML::Encoding + def <<(content); end + + def initialize(real_IO, encd=T.unsafe(nil)); end +end + +class REXML::Output +end + +class REXML::Parent + include ::Enumerable + def <<(object); end + + def [](index); end + + def []=(*args); end + + def add(object); end + + def children(); end + + def deep_clone(); end + + def delete(object); end + + def delete_at(index); end + + def delete_if(&block); end + + def each(&block); end + + def each_child(&block); end + + def each_index(&block); end + + def index(child); end + + def insert_after(child1, child2); end + + def insert_before(child1, child2); end + + def length(); end + + def push(object); end + + def replace_child(to_replace, replacement); end + + def size(); end + + def to_a(); end + + def unshift(object); end +end + +class REXML::Parent +end + +class REXML::ParseException + def context(); end + + def continued_exception(); end + + def continued_exception=(continued_exception); end + + def initialize(message, source=T.unsafe(nil), parser=T.unsafe(nil), exception=T.unsafe(nil)); end + + def line(); end + + def parser(); end + + def parser=(parser); end + + def position(); end + + def source(); end + + def source=(source); end +end + +class REXML::ParseException +end + +module REXML::Parsers +end + +class REXML::Parsers::BaseParser + def add_listener(listener); end + + def empty?(); end + + def entity(reference, entities); end + + def has_next?(); end + + def initialize(source); end + + def normalize(input, entities=T.unsafe(nil), entity_filter=T.unsafe(nil)); end + + def peek(depth=T.unsafe(nil)); end + + def position(); end + + def pull(); end + + def source(); end + + def stream=(source); end + + def unnormalize(string, entities=T.unsafe(nil), filter=T.unsafe(nil)); end + + def unshift(token); end + ATTDEF = ::T.let(nil, ::T.untyped) + ATTDEF_RE = ::T.let(nil, ::T.untyped) + ATTLISTDECL_PATTERN = ::T.let(nil, ::T.untyped) + ATTLISTDECL_START = ::T.let(nil, ::T.untyped) + ATTRIBUTE_PATTERN = ::T.let(nil, ::T.untyped) + ATTTYPE = ::T.let(nil, ::T.untyped) + ATTVALUE = ::T.let(nil, ::T.untyped) + CDATA_END = ::T.let(nil, ::T.untyped) + CDATA_PATTERN = ::T.let(nil, ::T.untyped) + CDATA_START = ::T.let(nil, ::T.untyped) + CLOSE_MATCH = ::T.let(nil, ::T.untyped) + COMBININGCHAR = ::T.let(nil, ::T.untyped) + COMMENT_PATTERN = ::T.let(nil, ::T.untyped) + COMMENT_START = ::T.let(nil, ::T.untyped) + DEFAULTDECL = ::T.let(nil, ::T.untyped) + DEFAULT_ENTITIES = ::T.let(nil, ::T.untyped) + DIGIT = ::T.let(nil, ::T.untyped) + DOCTYPE_END = ::T.let(nil, ::T.untyped) + DOCTYPE_PATTERN = ::T.let(nil, ::T.untyped) + DOCTYPE_START = ::T.let(nil, ::T.untyped) + ELEMENTDECL_PATTERN = ::T.let(nil, ::T.untyped) + ELEMENTDECL_START = ::T.let(nil, ::T.untyped) + ENCODING = ::T.let(nil, ::T.untyped) + ENTITYDECL = ::T.let(nil, ::T.untyped) + ENTITYDEF = ::T.let(nil, ::T.untyped) + ENTITYVALUE = ::T.let(nil, ::T.untyped) + ENTITY_START = ::T.let(nil, ::T.untyped) + ENUMERATEDTYPE = ::T.let(nil, ::T.untyped) + ENUMERATION = ::T.let(nil, ::T.untyped) + EREFERENCE = ::T.let(nil, ::T.untyped) + EXTENDER = ::T.let(nil, ::T.untyped) + EXTERNALID = ::T.let(nil, ::T.untyped) + GEDECL = ::T.let(nil, ::T.untyped) + IDENTITY = ::T.let(nil, ::T.untyped) + INSTRUCTION_PATTERN = ::T.let(nil, ::T.untyped) + INSTRUCTION_START = ::T.let(nil, ::T.untyped) + LETTER = ::T.let(nil, ::T.untyped) + NAME = ::T.let(nil, ::T.untyped) + NAMECHAR = ::T.let(nil, ::T.untyped) + NCNAME_STR = ::T.let(nil, ::T.untyped) + NDATADECL = ::T.let(nil, ::T.untyped) + NMTOKEN = ::T.let(nil, ::T.untyped) + NMTOKENS = ::T.let(nil, ::T.untyped) + NOTATIONDECL_START = ::T.let(nil, ::T.untyped) + NOTATIONTYPE = ::T.let(nil, ::T.untyped) + PEDECL = ::T.let(nil, ::T.untyped) + PEDEF = ::T.let(nil, ::T.untyped) + PEREFERENCE = ::T.let(nil, ::T.untyped) + PUBIDCHAR = ::T.let(nil, ::T.untyped) + PUBIDLITERAL = ::T.let(nil, ::T.untyped) + PUBLIC = ::T.let(nil, ::T.untyped) + QNAME = ::T.let(nil, ::T.untyped) + QNAME_STR = ::T.let(nil, ::T.untyped) + REFERENCE = ::T.let(nil, ::T.untyped) + REFERENCE_RE = ::T.let(nil, ::T.untyped) + STANDALONE = ::T.let(nil, ::T.untyped) + SYSTEM = ::T.let(nil, ::T.untyped) + SYSTEMENTITY = ::T.let(nil, ::T.untyped) + SYSTEMLITERAL = ::T.let(nil, ::T.untyped) + TAG_MATCH = ::T.let(nil, ::T.untyped) + TEXT_PATTERN = ::T.let(nil, ::T.untyped) + UNAME_STR = ::T.let(nil, ::T.untyped) + VERSION = ::T.let(nil, ::T.untyped) + XMLDECL_PATTERN = ::T.let(nil, ::T.untyped) + XMLDECL_START = ::T.let(nil, ::T.untyped) +end + +class REXML::Parsers::BaseParser +end + +class REXML::Parsers::StreamParser + def add_listener(listener); end + + def initialize(source, listener); end + + def parse(); end +end + +class REXML::Parsers::StreamParser +end + +class REXML::Parsers::TreeParser + def add_listener(listener); end + + def initialize(source, build_context=T.unsafe(nil)); end + + def parse(); end +end + +class REXML::Parsers::TreeParser +end + +class REXML::Parsers::XPathParser + include ::REXML::XMLTokens + def abbreviate(path); end + + def expand(path); end + + def namespaces=(namespaces); end + + def parse(path); end + + def predicate(path); end + + def predicate_to_string(path, &block); end + AXIS = ::T.let(nil, ::T.untyped) + LITERAL = ::T.let(nil, ::T.untyped) + LOCAL_NAME_WILDCARD = ::T.let(nil, ::T.untyped) + NODE_TYPE = ::T.let(nil, ::T.untyped) + NT = ::T.let(nil, ::T.untyped) + NUMBER = ::T.let(nil, ::T.untyped) + PI = ::T.let(nil, ::T.untyped) + PREFIX_WILDCARD = ::T.let(nil, ::T.untyped) + QNAME = ::T.let(nil, ::T.untyped) + VARIABLE_REFERENCE = ::T.let(nil, ::T.untyped) +end + +class REXML::Parsers::XPathParser +end + +module REXML::Parsers +end + +module REXML::Security +end + +module REXML::Security + def self.entity_expansion_limit(); end + + def self.entity_expansion_limit=(val); end + + def self.entity_expansion_text_limit(); end + + def self.entity_expansion_text_limit=(val); end +end + +class REXML::Source + include ::REXML::Encoding + def buffer(); end + + def consume(pattern); end + + def current_line(); end + + def empty?(); end + + def encoding=(enc); end + + def initialize(arg, encoding=T.unsafe(nil)); end + + def line(); end + + def match(pattern, cons=T.unsafe(nil)); end + + def match_to(char, pattern); end + + def match_to_consume(char, pattern); end + + def position(); end + + def read(); end + + def scan(pattern, cons=T.unsafe(nil)); end +end + +class REXML::Source +end + +class REXML::SourceFactory +end + +class REXML::SourceFactory + def self.create_from(arg); end +end + +class REXML::Text + include ::Comparable + def <<(to_append); end + + def clone(); end + + def doctype(); end + + def empty?(); end + + def indent_text(string, level=T.unsafe(nil), style=T.unsafe(nil), indentfirstline=T.unsafe(nil)); end + + def initialize(arg, respect_whitespace=T.unsafe(nil), parent=T.unsafe(nil), raw=T.unsafe(nil), entity_filter=T.unsafe(nil), illegal=T.unsafe(nil)); end + + def node_type(); end + + def parent=(parent); end + + def raw(); end + + def raw=(raw); end + + def to_s(); end + + def value(); end + + def value=(val); end + + def wrap(string, width, addnewline=T.unsafe(nil)); end + + def write(writer, indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end + + def write_with_substitution(out, input); end + + def xpath(); end + EREFERENCE = ::T.let(nil, ::T.untyped) + NEEDS_A_SECOND_CHECK = ::T.let(nil, ::T.untyped) + NUMERICENTITY = ::T.let(nil, ::T.untyped) + REFERENCE = ::T.let(nil, ::T.untyped) + SETUTITSBUS = ::T.let(nil, ::T.untyped) + SLAICEPS = ::T.let(nil, ::T.untyped) + SPECIALS = ::T.let(nil, ::T.untyped) + SUBSTITUTES = ::T.let(nil, ::T.untyped) + VALID_CHAR = ::T.let(nil, ::T.untyped) + VALID_XML_CHARS = ::T.let(nil, ::T.untyped) +end + +class REXML::Text + def self.check(string, pattern, doctype); end + + def self.expand(ref, doctype, filter); end + + def self.normalize(input, doctype=T.unsafe(nil), entity_filter=T.unsafe(nil)); end + + def self.read_with_substitution(input, illegal=T.unsafe(nil)); end + + def self.unnormalize(string, doctype=T.unsafe(nil), filter=T.unsafe(nil), illegal=T.unsafe(nil)); end +end + +class REXML::UndefinedNamespaceException + def initialize(prefix, source, parser); end +end + +class REXML::UndefinedNamespaceException +end + +module REXML::Validation +end + +class REXML::Validation::ValidationException + def initialize(msg); end +end + +class REXML::Validation::ValidationException +end + +module REXML::Validation +end + +class REXML::XMLDecl + include ::REXML::Encoding + def ==(other); end + + def clone(); end + + def dowrite(); end + + def encoding=(enc); end + + def initialize(version=T.unsafe(nil), encoding=T.unsafe(nil), standalone=T.unsafe(nil)); end + + def node_type(); end + + def nowrite(); end + + def old_enc=(encoding); end + + def stand_alone?(); end + + def standalone(); end + + def standalone=(standalone); end + + def version(); end + + def version=(version); end + + def write(writer, indent=T.unsafe(nil), transitive=T.unsafe(nil), ie_hack=T.unsafe(nil)); end + + def writeencoding(); end + + def writethis(); end + + def xmldecl(version, encoding, standalone); end + DEFAULT_ENCODING = ::T.let(nil, ::T.untyped) + DEFAULT_STANDALONE = ::T.let(nil, ::T.untyped) + DEFAULT_VERSION = ::T.let(nil, ::T.untyped) + START = ::T.let(nil, ::T.untyped) + STOP = ::T.let(nil, ::T.untyped) +end + +class REXML::XMLDecl + def self.default(); end +end + +module REXML::XMLTokens + NAME = ::T.let(nil, ::T.untyped) + NAMECHAR = ::T.let(nil, ::T.untyped) + NAME_CHAR = ::T.let(nil, ::T.untyped) + NAME_START_CHAR = ::T.let(nil, ::T.untyped) + NAME_STR = ::T.let(nil, ::T.untyped) + NCNAME_STR = ::T.let(nil, ::T.untyped) + NMTOKEN = ::T.let(nil, ::T.untyped) + NMTOKENS = ::T.let(nil, ::T.untyped) + REFERENCE = ::T.let(nil, ::T.untyped) +end + +module REXML::XMLTokens +end + +class REXML::XPath + include ::REXML::Functions + EMPTY_HASH = ::T.let(nil, ::T.untyped) +end + +class REXML::XPath + def self.each(element, path=T.unsafe(nil), namespaces=T.unsafe(nil), variables=T.unsafe(nil), options=T.unsafe(nil), &block); end + + def self.first(element, path=T.unsafe(nil), namespaces=T.unsafe(nil), variables=T.unsafe(nil), options=T.unsafe(nil)); end + + def self.match(element, path=T.unsafe(nil), namespaces=T.unsafe(nil), variables=T.unsafe(nil), options=T.unsafe(nil)); end +end + +class REXML::XPathNode + def context(); end + + def initialize(node, context=T.unsafe(nil)); end + + def position(); end + + def raw_node(); end +end + +class REXML::XPathNode +end + +class REXML::XPathParser + include ::REXML::XMLTokens + def []=(variable_name, value); end + + def first(path_stack, node); end + + def get_first(path, nodeset); end + + def initialize(strict: T.unsafe(nil)); end + + def match(path_stack, nodeset); end + + def namespaces=(namespaces=T.unsafe(nil)); end + + def parse(path, nodeset); end + + def predicate(path, nodeset); end + + def variables=(vars=T.unsafe(nil)); end + DEBUG = ::T.let(nil, ::T.untyped) + LITERAL = ::T.let(nil, ::T.untyped) +end + +class REXML::XPathParser +end + +module REXML +end + +module RSpec + MODULES_TO_AUTOLOAD = ::T.let(nil, ::T.untyped) +end + +class RSpec::CallerFilter + ADDITIONAL_TOP_LEVEL_FILES = ::T.let(nil, ::T.untyped) + IGNORE_REGEX = ::T.let(nil, ::T.untyped) + LIB_REGEX = ::T.let(nil, ::T.untyped) + RSPEC_LIBS = ::T.let(nil, ::T.untyped) +end + +class RSpec::CallerFilter + def self.first_non_rspec_line(skip_frames=T.unsafe(nil), increment=T.unsafe(nil)); end +end + +module RSpec::Core +end + +class RSpec::Core::AnonymousExampleGroup +end + +class RSpec::Core::AnonymousExampleGroup +end + +class RSpec::Core::BacktraceFormatter + def backtrace_line(line); end + + def exclude?(line); end + + def exclusion_patterns(); end + + def exclusion_patterns=(exclusion_patterns); end + + def filter_gem(gem_name); end + + def format_backtrace(backtrace, options=T.unsafe(nil)); end + + def full_backtrace=(full_backtrace); end + + def full_backtrace?(); end + + def inclusion_patterns(); end + + def inclusion_patterns=(inclusion_patterns); end +end + +class RSpec::Core::BacktraceFormatter +end + +class RSpec::Core::Configuration + include ::RSpec::Core::Hooks + include ::RSpec::Core::Configuration::Readers + def add_formatter(formatter, output=T.unsafe(nil)); end + + def add_setting(name, opts=T.unsafe(nil)); end + + def after(scope=T.unsafe(nil), *meta, &block); end + + def alias_example_group_to(new_name, *args); end + + def alias_example_to(name, *args); end + + def alias_it_behaves_like_to(new_name, report_label=T.unsafe(nil)); end + + def alias_it_should_behave_like_to(new_name, report_label=T.unsafe(nil)); end + + def append_after(scope=T.unsafe(nil), *meta, &block); end + + def append_before(scope=T.unsafe(nil), *meta, &block); end + + def apply_derived_metadata_to(metadata); end + + def around(scope=T.unsafe(nil), *meta, &block); end + + def backtrace_exclusion_patterns(); end + + def backtrace_exclusion_patterns=(patterns); end + + def backtrace_formatter(); end + + def backtrace_inclusion_patterns(); end + + def backtrace_inclusion_patterns=(patterns); end + + def before(scope=T.unsafe(nil), *meta, &block); end + + def bisect_runner(); end + + def bisect_runner=(value); end + + def bisect_runner_class(); end + + def color(); end + + def color=(color); end + + def color_enabled?(output=T.unsafe(nil)); end + + def color_mode(); end + + def color_mode=(color_mode); end + + def configure_example(example, example_hooks); end + + def configure_expectation_framework(); end + + def configure_group(group); end + + def configure_mock_framework(); end + + def default_color=(default_color); end + + def default_color?(); end + + def default_formatter(); end + + def default_formatter=(value); end + + def default_path=(path); end + + def default_path?(); end + + def define_derived_metadata(*filters, &block); end + + def deprecation_stream=(value); end + + def detail_color=(detail_color); end + + def detail_color?(); end + + def disable_monkey_patching(); end + + def disable_monkey_patching!(); end + + def disable_monkey_patching=(disable_monkey_patching); end + + def drb=(drb); end + + def drb?(); end + + def drb_port=(drb_port); end + + def drb_port?(); end + + def dry_run=(dry_run); end + + def dry_run?(); end + + def error_stream=(error_stream); end + + def error_stream?(); end + + def example_status_persistence_file_path=(value); end + + def exclude_pattern=(value); end + + def exclusion_filter(); end + + def exclusion_filter=(filter); end + + def expect_with(*frameworks); end + + def expectation_framework=(framework); end + + def expectation_frameworks(); end + + def expose_current_running_example_as(method_name); end + + def expose_dsl_globally=(value); end + + def expose_dsl_globally?(); end + + def extend(mod, *filters); end + + def fail_fast=(value); end + + def fail_if_no_examples=(fail_if_no_examples); end + + def fail_if_no_examples?(); end + + def failure_color=(failure_color); end + + def failure_color?(); end + + def failure_exit_code=(failure_exit_code); end + + def failure_exit_code?(); end + + def files_or_directories_to_run=(*files); end + + def files_to_run(); end + + def files_to_run=(files_to_run); end + + def filter(); end + + def filter=(filter); end + + def filter_gems_from_backtrace(*gem_names); end + + def filter_manager(); end + + def filter_manager=(filter_manager); end + + def filter_run(*args); end + + def filter_run_excluding(*args); end + + def filter_run_including(*args); end + + def filter_run_when_matching(*args); end + + def fixed_color=(fixed_color); end + + def fixed_color?(); end + + def force(hash); end + + def format_docstrings(&block); end + + def format_docstrings_block(); end + + def formatter=(formatter, output=T.unsafe(nil)); end + + def formatter_loader(); end + + def formatters(); end + + def full_backtrace=(true_or_false); end + + def full_backtrace?(); end + + def full_description(); end + + def full_description=(description); end + + def in_project_source_dir_regex(); end + + def include(mod, *filters); end + + def include_context(shared_group_name, *filters); end + + def inclusion_filter(); end + + def inclusion_filter=(filter); end + + def last_run_statuses(); end + + def libs=(libs); end + + def load_spec_files(); end + + def loaded_spec_files(); end + + def max_displayed_failure_line_count=(max_displayed_failure_line_count); end + + def max_displayed_failure_line_count?(); end + + def mock_framework(); end + + def mock_framework=(framework); end + + def mock_with(framework); end + + def on_example_group_definition(&block); end + + def on_example_group_definition_callbacks(); end + + def only_failures?(); end + + def only_failures_but_not_configured?(); end + + def order=(*args, &block); end + + def ordering_manager(); end + + def ordering_registry(*args, &block); end + + def output_stream=(value); end + + def pattern=(value); end + + def pending_color=(pending_color); end + + def pending_color?(); end + + def prepend(mod, *filters); end + + def prepend_after(scope=T.unsafe(nil), *meta, &block); end + + def prepend_before(scope=T.unsafe(nil), *meta, &block); end + + def profile_examples=(profile_examples); end + + def profile_examples?(); end + + def project_source_dirs=(project_source_dirs); end + + def project_source_dirs?(); end + + def raise_errors_for_deprecations!(); end + + def raise_on_warning=(value); end + + def register_ordering(*args, &block); end + + def reporter(); end + + def requires=(paths); end + + def reset(); end + + def reset_filters(); end + + def reset_reporter(); end + + def run_all_when_everything_filtered=(run_all_when_everything_filtered); end + + def run_all_when_everything_filtered?(); end + + def seed(*args, &block); end + + def seed=(*args, &block); end + + def seed_used?(*args, &block); end + + def shared_context_metadata_behavior=(value); end + + def silence_filter_announcements=(silence_filter_announcements); end + + def silence_filter_announcements?(); end + + def spec_files_with_failures(); end + + def start_time=(start_time); end + + def start_time?(); end + + def static_config_filter_manager(); end + + def static_config_filter_manager=(static_config_filter_manager); end + + def success_color=(success_color); end + + def success_color?(); end + + def threadsafe=(threadsafe); end + + def threadsafe?(); end + + def treat_symbols_as_metadata_keys_with_true_values=(_value); end + + def tty=(tty); end + + def tty?(); end + + def warnings=(value); end + + def warnings?(); end + + def when_first_matching_example_defined(*filters); end + + def with_suite_hooks(); end + + def world(); end + + def world=(world); end + DEFAULT_FORMATTER = ::T.let(nil, ::T.untyped) + FAILED_STATUS = ::T.let(nil, ::T.untyped) + MOCKING_ADAPTERS = ::T.let(nil, ::T.untyped) + PASSED_STATUS = ::T.let(nil, ::T.untyped) + PENDING_STATUS = ::T.let(nil, ::T.untyped) + RAISE_ERROR_WARNING_NOTIFIER = ::T.let(nil, ::T.untyped) + UNKNOWN_STATUS = ::T.let(nil, ::T.untyped) + VALID_STATUSES = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Configuration::DeprecationReporterBuffer + def deprecation(*args); end + + def play_onto(reporter); end +end + +class RSpec::Core::Configuration::DeprecationReporterBuffer +end + +module RSpec::Core::Configuration::ExposeCurrentExample +end + +module RSpec::Core::Configuration::ExposeCurrentExample +end + +class RSpec::Core::Configuration::MustBeConfiguredBeforeExampleGroupsError +end + +class RSpec::Core::Configuration::MustBeConfiguredBeforeExampleGroupsError +end + +module RSpec::Core::Configuration::Readers + def default_color(); end + + def default_path(); end + + def deprecation_stream(); end + + def detail_color(); end + + def drb(); end + + def drb_port(); end + + def dry_run(); end + + def error_stream(); end + + def example_status_persistence_file_path(); end + + def exclude_pattern(); end + + def fail_fast(); end + + def fail_if_no_examples(); end + + def failure_color(); end + + def failure_exit_code(); end + + def fixed_color(); end + + def libs(); end + + def max_displayed_failure_line_count(); end + + def only_failures(); end + + def output_stream(); end + + def pattern(); end + + def pending_color(); end + + def profile_examples(); end + + def project_source_dirs(); end + + def requires(); end + + def run_all_when_everything_filtered(); end + + def shared_context_metadata_behavior(); end + + def silence_filter_announcements(); end + + def start_time(); end + + def success_color(); end + + def threadsafe(); end + + def tty(); end +end + +module RSpec::Core::Configuration::Readers +end + +class RSpec::Core::Configuration + def self.add_read_only_setting(name, opts=T.unsafe(nil)); end + + def self.add_setting(name, opts=T.unsafe(nil)); end + + def self.define_aliases(name, alias_name); end + + def self.define_predicate_for(*names); end + + def self.define_reader(name); end + + def self.delegate_to_ordering_manager(*methods); end +end + +class RSpec::Core::ConfigurationOptions + def args(); end + + def configure(config); end + + def configure_filter_manager(filter_manager); end + + def initialize(args); end + + def options(); end + OPTIONS_ORDER = ::T.let(nil, ::T.untyped) + UNFORCED_OPTIONS = ::T.let(nil, ::T.untyped) + UNPROCESSABLE_OPTIONS = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::ConfigurationOptions +end + +module RSpec::Core::DSL +end + +module RSpec::Core::DSL + def self.change_global_dsl(&changes); end + + def self.example_group_aliases(); end + + def self.expose_example_group_alias(name); end + + def self.expose_example_group_alias_globally(method_name); end + + def self.expose_globally!(); end + + def self.exposed_globally?(); end + + def self.remove_globally!(); end + + def self.top_level(); end + + def self.top_level=(top_level); end +end + +class RSpec::Core::DeprecationError +end + +class RSpec::Core::DeprecationError +end + +class RSpec::Core::DidYouMean + def call(); end + + def initialize(relative_file_name); end + + def relative_file_name(); end +end + +class RSpec::Core::DidYouMean +end + +class RSpec::Core::Example + def clock(); end + + def clock=(clock); end + + def description(); end + + def display_exception(); end + + def display_exception=(ex); end + + def duplicate_with(metadata_overrides=T.unsafe(nil)); end + + def example_group(); end + + def example_group_instance(); end + + def exception(); end + + def execution_result(); end + + def fail_with_exception(reporter, exception); end + + def file_path(); end + + def full_description(); end + + def id(); end + + def initialize(example_group_class, description, user_metadata, example_block=T.unsafe(nil)); end + + def inspect_output(); end + + def instance_exec(*args, &block); end + + def location(); end + + def location_rerun_argument(); end + + def metadata(); end + + def pending(); end + + def pending?(); end + + def reporter(); end + + def rerun_argument(); end + + def run(example_group_instance, reporter); end + + def set_aggregate_failures_exception(exception); end + + def set_exception(exception); end + + def skip(); end + + def skip_with_exception(reporter, exception); end + + def skipped?(); end + + def update_inherited_metadata(updates); end +end + +RSpec::Core::Example::AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt = RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue + +class RSpec::Core::Example::ExecutionResult + include ::RSpec::Core::HashImitatable + def ensure_timing_set(clock); end + + def example_skipped?(); end + + def exception(); end + + def exception=(exception); end + + def finished_at(); end + + def finished_at=(finished_at); end + + def pending_exception(); end + + def pending_exception=(pending_exception); end + + def pending_fixed(); end + + def pending_fixed=(pending_fixed); end + + def pending_fixed?(); end + + def pending_message(); end + + def pending_message=(pending_message); end + + def record_finished(status, finished_at); end + + def run_time(); end + + def run_time=(run_time); end + + def started_at(); end + + def started_at=(started_at); end + + def status(); end + + def status=(status); end +end + +class RSpec::Core::Example::ExecutionResult + extend ::RSpec::Core::HashImitatable::ClassMethods +end + +class RSpec::Core::Example::Procsy + def <<(*a, &b); end + + def ===(*a, &b); end + + def >>(*a, &b); end + + def [](*a, &b); end + + def arity(*a, &b); end + + def binding(*a, &b); end + + def call(*args, &block); end + + def clock(*a, &b); end + + def clock=(*a, &b); end + + def clone(*a, &b); end + + def curry(*a, &b); end + + def description(*a, &b); end + + def dup(*a, &b); end + + def duplicate_with(*a, &b); end + + def example(); end + + def example_group(*a, &b); end + + def example_group_instance(*a, &b); end + + def exception(*a, &b); end + + def executed?(); end + + def execution_result(*a, &b); end + + def file_path(*a, &b); end + + def full_description(*a, &b); end + + def hash(*a, &b); end + + def id(*a, &b); end + + def initialize(example, &block); end + + def inspect_output(*a, &b); end + + def lambda?(*a, &b); end + + def location(*a, &b); end + + def location_rerun_argument(*a, &b); end + + def metadata(*a, &b); end + + def parameters(*a, &b); end + + def pending(*a, &b); end + + def pending?(*a, &b); end + + def reporter(*a, &b); end + + def rerun_argument(*a, &b); end + + def run(*args, &block); end + + def skip(*a, &b); end + + def skipped?(*a, &b); end + + def source_location(*a, &b); end + + def to_proc(); end + + def update_inherited_metadata(*a, &b); end + + def wrap(&block); end + + def yield(*a, &b); end +end + +class RSpec::Core::Example::Procsy +end + +class RSpec::Core::Example + def self.delegate_to_metadata(key); end + + def self.parse_id(id); end +end + +class RSpec::Core::ExampleGroup + include ::RSpec::Core::MemoizedHelpers + include ::RSpec::Core::Pending + def described_class(); end + + def initialize(inspect_output=T.unsafe(nil)); end + INSTANCE_VARIABLE_TO_IGNORE = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::ExampleGroup::WrongScopeError +end + +class RSpec::Core::ExampleGroup::WrongScopeError +end + +class RSpec::Core::ExampleGroup + extend ::RSpec::Core::Hooks + extend ::RSpec::Core::MemoizedHelpers::ClassMethods + extend ::RSpec::Core::SharedExampleGroup + def self.add_example(example); end + + def self.before_context_ivars(); end + + def self.children(); end + + def self.context(*args, &example_group_block); end + + def self.currently_executing_a_context_hook?(); end + + def self.declaration_locations(); end + + def self.define_example_group_method(name, metadata=T.unsafe(nil)); end + + def self.define_example_method(name, extra_options=T.unsafe(nil)); end + + def self.define_nested_shared_group_method(new_name, report_label=T.unsafe(nil)); end + + def self.delegate_to_metadata(*names); end + + def self.descendant_filtered_examples(); end + + def self.descendants(); end + + def self.describe(*args, &example_group_block); end + + def self.described_class(); end + + def self.description(); end + + def self.each_instance_variable_for_example(group); end + + def self.ensure_example_groups_are_configured(); end + + def self.example(*all_args, &block); end + + def self.example_group(*args, &example_group_block); end + + def self.examples(); end + + def self.fcontext(*args, &example_group_block); end + + def self.fdescribe(*args, &example_group_block); end + + def self.fexample(*all_args, &block); end + + def self.file_path(); end + + def self.filtered_examples(); end + + def self.find_and_eval_shared(label, name, inclusion_location, *args, &customization_block); end + + def self.fit(*all_args, &block); end + + def self.focus(*all_args, &block); end + + def self.for_filtered_examples(reporter, &block); end + + def self.fspecify(*all_args, &block); end + + def self.id(); end + + def self.idempotently_define_singleton_method(name, &definition); end + + def self.include_context(name, *args, &block); end + + def self.include_examples(name, *args, &block); end + + def self.it(*all_args, &block); end + + def self.it_behaves_like(name, *args, &customization_block); end + + def self.it_should_behave_like(name, *args, &customization_block); end + + def self.location(); end + + def self.metadata(); end + + def self.next_runnable_index_for(file); end + + def self.ordering_strategy(); end + + def self.parent_groups(); end + + def self.pending(*all_args, &block); end + + def self.remove_example(example); end + + def self.reset_memoized(); end + + def self.run(reporter=T.unsafe(nil)); end + + def self.run_after_context_hooks(example_group_instance); end + + def self.run_before_context_hooks(example_group_instance); end + + def self.run_examples(reporter); end + + def self.set_it_up(description, args, registration_collection, &example_group_block); end + + def self.set_ivars(instance, ivars); end + + def self.skip(*all_args, &block); end + + def self.specify(*all_args, &block); end + + def self.store_before_context_ivars(example_group_instance); end + + def self.subclass(parent, description, args, registration_collection, &example_group_block); end + + def self.superclass_before_context_ivars(); end + + def self.superclass_metadata(); end + + def self.top_level?(); end + + def self.top_level_description(); end + + def self.traverse_tree_until(&block); end + + def self.update_inherited_metadata(updates); end + + def self.with_replaced_metadata(meta); end + + def self.xcontext(*args, &example_group_block); end + + def self.xdescribe(*args, &example_group_block); end + + def self.xexample(*all_args, &block); end + + def self.xit(*all_args, &block); end + + def self.xspecify(*all_args, &block); end +end + +class RSpec::Core::ExampleStatusPersister + def initialize(examples, file_name); end + + def persist(); end +end + +class RSpec::Core::ExampleStatusPersister + def self.load_from(file_name); end + + def self.persist(examples, file_name); end +end + +RSpec::Core::ExclusionRules = RSpec::Core::FilterRules + +class RSpec::Core::FilterManager + def add_ids(rerun_path, scoped_ids); end + + def add_location(file_path, line_numbers); end + + def empty?(); end + + def exclude(*args); end + + def exclude_only(*args); end + + def exclude_with_low_priority(*args); end + + def exclusions(); end + + def include(*args); end + + def include_only(*args); end + + def include_with_low_priority(*args); end + + def inclusions(); end + + def prune(examples); end +end + +class RSpec::Core::FilterManager +end + +class RSpec::Core::FilterRules + def [](key); end + + def add(updated); end + + def add_with_low_priority(updated); end + + def clear(); end + + def delete(key); end + + def description(); end + + def each_pair(&block); end + + def empty?(); end + + def fetch(*args, &block); end + + def include_example?(example); end + + def initialize(rules=T.unsafe(nil)); end + + def opposite(); end + + def opposite=(opposite); end + + def rules(); end + + def use_only(updated); end + PROC_HEX_NUMBER = ::T.let(nil, ::T.untyped) + PROJECT_DIR = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::FilterRules + def self.build(); end +end + +module RSpec::Core::FilterableItemRepository +end + +class RSpec::Core::FilterableItemRepository::QueryOptimized + def items_for(metadata); end +end + +class RSpec::Core::FilterableItemRepository::QueryOptimized +end + +class RSpec::Core::FilterableItemRepository::UpdateOptimized + def append(item, metadata); end + + def delete(item, metadata); end + + def initialize(applies_predicate); end + + def items_and_filters(); end + + def items_for(request_meta); end + + def prepend(item, metadata); end +end + +class RSpec::Core::FilterableItemRepository::UpdateOptimized +end + +module RSpec::Core::FilterableItemRepository +end + +module RSpec::Core::FlatMap +end + +module RSpec::Core::FlatMap + def self.flat_map(array, &block); end +end + +module RSpec::Core::Formatters +end + +class RSpec::Core::Formatters::BaseBisectFormatter + def example_failed(notification); end + + def example_finished(notification); end + + def initialize(expected_failures); end + + def start_dump(_notification); end +end + +class RSpec::Core::Formatters::BaseBisectFormatter + def self.inherited(formatter); end +end + +class RSpec::Core::Formatters::BaseFormatter + def close(_notification); end + + def example_group(); end + + def example_group=(example_group); end + + def example_group_started(notification); end + + def initialize(output); end + + def output(); end + + def start(notification); end +end + +class RSpec::Core::Formatters::BaseFormatter +end + +class RSpec::Core::Formatters::BaseTextFormatter + def dump_failures(notification); end + + def dump_pending(notification); end + + def dump_summary(summary); end + + def message(notification); end + + def seed(notification); end +end + +class RSpec::Core::Formatters::BaseTextFormatter +end + +class RSpec::Core::Formatters::BisectDRbFormatter + def initialize(_output); end + + def notify_results(results); end +end + +class RSpec::Core::Formatters::BisectDRbFormatter +end + +module RSpec::Core::Formatters::ConsoleCodes + VT100_CODES = ::T.let(nil, ::T.untyped) + VT100_CODE_VALUES = ::T.let(nil, ::T.untyped) +end + +module RSpec::Core::Formatters::ConsoleCodes + def self.config_colors_to_methods(); end + + def self.console_code_for(code_or_symbol); end + + def self.wrap(text, code_or_symbol); end +end + +class RSpec::Core::Formatters::DeprecationFormatter + def count(); end + + def deprecation(notification); end + + def deprecation_message_for(data); end + + def deprecation_stream(); end + + def deprecation_summary(_notification); end + + def initialize(deprecation_stream, summary_stream); end + + def output(); end + + def printer(); end + + def summary_stream(); end + DEPRECATION_STREAM_NOTICE = ::T.let(nil, ::T.untyped) + RAISE_ERROR_CONFIG_NOTICE = ::T.let(nil, ::T.untyped) + TOO_MANY_WARNINGS_NOTICE = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter + def deprecation_formatter(); end + + def deprecation_stream(); end + + def deprecation_summary(); end + + def initialize(deprecation_stream, summary_stream, deprecation_formatter); end + + def print_deferred_deprecation_warnings(); end + + def print_deprecation_message(data); end + + def stash_deprecation_message(deprecation_message); end + + def summary_stream(); end + TOO_MANY_USES_LIMIT = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter +end + +class RSpec::Core::Formatters::DeprecationFormatter::FileStream + def initialize(file); end + + def puts(*args); end + + def summarize(summary_stream, deprecation_count); end +end + +class RSpec::Core::Formatters::DeprecationFormatter::FileStream +end + +class RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage + def initialize(data); end + + def too_many_warnings_message(); end + + def type(); end + + def type=(_); end +end + +class RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage + def self.[](*_); end + + def self.members(); end +end + +class RSpec::Core::Formatters::DeprecationFormatter::ImmediatePrinter + def deprecation_formatter(); end + + def deprecation_stream(); end + + def deprecation_summary(); end + + def initialize(deprecation_stream, summary_stream, deprecation_formatter); end + + def print_deprecation_message(data); end + + def summary_stream(); end +end + +class RSpec::Core::Formatters::DeprecationFormatter::ImmediatePrinter +end + +class RSpec::Core::Formatters::DeprecationFormatter::RaiseErrorStream + def puts(message); end + + def summarize(summary_stream, deprecation_count); end +end + +class RSpec::Core::Formatters::DeprecationFormatter::RaiseErrorStream +end + +class RSpec::Core::Formatters::DeprecationFormatter::SpecifiedDeprecationMessage + def initialize(data); end + + def too_many_warnings_message(); end + + def type(); end + + def type=(_); end +end + +class RSpec::Core::Formatters::DeprecationFormatter::SpecifiedDeprecationMessage + def self.[](*_); end + + def self.members(); end +end + +class RSpec::Core::Formatters::DeprecationFormatter +end + +class RSpec::Core::Formatters::DocumentationFormatter + def example_failed(failure); end + + def example_group_finished(_notification); end + + def example_passed(passed); end + + def example_pending(pending); end + + def example_started(_notification); end +end + +class RSpec::Core::Formatters::DocumentationFormatter +end + +class RSpec::Core::Formatters::ExceptionPresenter + def colorized_formatted_backtrace(colorizer=T.unsafe(nil)); end + + def colorized_message_lines(colorizer=T.unsafe(nil)); end + + def description(); end + + def example(); end + + def exception(); end + + def formatted_backtrace(exception=T.unsafe(nil)); end + + def formatted_cause(exception); end + + def fully_formatted(failure_number, colorizer=T.unsafe(nil)); end + + def fully_formatted_lines(failure_number, colorizer); end + + def initialize(exception, example, options=T.unsafe(nil)); end + + def message_lines(); end + PENDING_DETAIL_FORMATTER = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Formatters::ExceptionPresenter::Factory + def build(); end + + def initialize(example); end +end + +class RSpec::Core::Formatters::ExceptionPresenter::Factory::CommonBacktraceTruncater + def initialize(parent); end + + def with_truncated_backtrace(child); end +end + +class RSpec::Core::Formatters::ExceptionPresenter::Factory::CommonBacktraceTruncater +end + +module RSpec::Core::Formatters::ExceptionPresenter::Factory::EmptyBacktraceFormatter +end + +module RSpec::Core::Formatters::ExceptionPresenter::Factory::EmptyBacktraceFormatter + def self.format_backtrace(*_); end +end + +class RSpec::Core::Formatters::ExceptionPresenter::Factory +end + +class RSpec::Core::Formatters::ExceptionPresenter +end + +class RSpec::Core::Formatters::FailureListFormatter + def dump_profile(_profile); end + + def example_failed(failure); end + + def message(_message); end +end + +class RSpec::Core::Formatters::FailureListFormatter +end + +class RSpec::Core::Formatters::FallbackMessageFormatter + def initialize(output); end + + def message(notification); end + + def output(); end +end + +class RSpec::Core::Formatters::FallbackMessageFormatter +end + +module RSpec::Core::Formatters::Helpers + DEFAULT_PRECISION = ::T.let(nil, ::T.untyped) + SUB_SECOND_PRECISION = ::T.let(nil, ::T.untyped) +end + +module RSpec::Core::Formatters::Helpers + def self.format_duration(duration); end + + def self.format_seconds(float, precision=T.unsafe(nil)); end + + def self.organize_ids(ids); end + + def self.pluralize(count, string); end +end + +class RSpec::Core::Formatters::HtmlFormatter + def dump_summary(summary); end + + def example_failed(failure); end + + def example_passed(passed); end + + def example_pending(pending); end + + def example_started(_notification); end + + def start_dump(_notification); end +end + +class RSpec::Core::Formatters::HtmlFormatter +end + +class RSpec::Core::Formatters::JsonFormatter + def dump_profile(profile); end + + def dump_profile_slowest_example_groups(profile); end + + def dump_profile_slowest_examples(profile); end + + def dump_summary(summary); end + + def message(notification); end + + def output_hash(); end + + def seed(notification); end + + def stop(notification); end +end + +class RSpec::Core::Formatters::JsonFormatter +end + +class RSpec::Core::Formatters::Loader + def add(formatter_to_use, *paths); end + + def default_formatter(); end + + def default_formatter=(default_formatter); end + + def formatters(); end + + def initialize(reporter); end + + def prepare_default(output_stream, deprecation_stream); end + + def reporter(); end + + def setup_default(output_stream, deprecation_stream); end +end + +class RSpec::Core::Formatters::Loader + def self.formatters(); end +end + +class RSpec::Core::Formatters::ProfileFormatter + def dump_profile(profile); end + + def initialize(output); end + + def output(); end +end + +class RSpec::Core::Formatters::ProfileFormatter +end + +class RSpec::Core::Formatters::ProgressFormatter + def example_failed(_notification); end + + def example_passed(_notification); end + + def example_pending(_notification); end + + def start_dump(_notification); end +end + +class RSpec::Core::Formatters::ProgressFormatter +end + +class RSpec::Core::Formatters::SnippetExtractor + def beginning_line_number(); end + + def expression_lines(); end + + def initialize(source, beginning_line_number, max_line_count=T.unsafe(nil)); end + + def max_line_count(); end + + def source(); end +end + +class RSpec::Core::Formatters::SnippetExtractor::NoExpressionAtLineError +end + +class RSpec::Core::Formatters::SnippetExtractor::NoExpressionAtLineError +end + +class RSpec::Core::Formatters::SnippetExtractor::NoSuchFileError +end + +class RSpec::Core::Formatters::SnippetExtractor::NoSuchFileError +end + +class RSpec::Core::Formatters::SnippetExtractor::NoSuchLineError +end + +class RSpec::Core::Formatters::SnippetExtractor::NoSuchLineError +end + +class RSpec::Core::Formatters::SnippetExtractor + def self.extract_expression_lines_at(file_path, beginning_line_number, max_line_count=T.unsafe(nil)); end + + def self.extract_line_at(file_path, line_number); end + + def self.least_indentation_from(lines); end + + def self.source_from_file(path); end +end + +class RSpec::Core::Formatters::SyntaxHighlighter + def highlight(lines); end + + def initialize(configuration); end +end + +module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation + RESET_CODE = ::T.let(nil, ::T.untyped) +end + +module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation + def self.highlight_syntax(lines); end +end + +module RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation +end + +module RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation + def self.highlight_syntax(lines); end +end + +RSpec::Core::Formatters::SyntaxHighlighter::WindowsImplementation = RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation + +class RSpec::Core::Formatters::SyntaxHighlighter + def self.attempt_to_add_rspec_terms_to_coderay_keywords(); end +end + +module RSpec::Core::Formatters + def self.register(formatter_class, *notifications); end +end + +module RSpec::Core::HashImitatable + def <(*args, &block); end + + def <=(*args, &block); end + + def >(*args, &block); end + + def >=(*args, &block); end + + def [](key); end + + def []=(key, value); end + + def all?(*args, &block); end + + def any?(*args, &block); end + + def assoc(*args, &block); end + + def chain(*args, &block); end + + def chunk(*args, &block); end + + def chunk_while(*args, &block); end + + def clear(*args, &block); end + + def collect(*args, &block); end + + def collect_concat(*args, &block); end + + def compact(*args, &block); end + + def compact!(*args, &block); end + + def compare_by_identity(*args, &block); end + + def compare_by_identity?(*args, &block); end + + def count(*args, &block); end + + def cycle(*args, &block); end + + def default(*args, &block); end + + def default=(*args, &block); end + + def default_proc(*args, &block); end + + def default_proc=(*args, &block); end + + def delete(*args, &block); end + + def delete_if(*args, &block); end + + def detect(*args, &block); end + + def dig(*args, &block); end + + def drop(*args, &block); end + + def drop_while(*args, &block); end + + def each(*args, &block); end + + def each_cons(*args, &block); end + + def each_entry(*args, &block); end + + def each_key(*args, &block); end + + def each_pair(*args, &block); end + + def each_slice(*args, &block); end + + def each_value(*args, &block); end + + def each_with_index(*args, &block); end + + def each_with_object(*args, &block); end + + def empty?(*args, &block); end + + def entries(*args, &block); end + + def fetch(*args, &block); end + + def fetch_values(*args, &block); end + + def filter(*args, &block); end + + def filter!(*args, &block); end + + def find(*args, &block); end + + def find_all(*args, &block); end + + def find_index(*args, &block); end + + def first(*args, &block); end + + def flat_map(*args, &block); end + + def flatten(*args, &block); end + + def grep(*args, &block); end + + def grep_v(*args, &block); end + + def group_by(*args, &block); end + + def has_key?(*args, &block); end + + def has_value?(*args, &block); end + + def include?(*args, &block); end + + def index(*args, &block); end + + def inject(*args, &block); end + + def invert(*args, &block); end + + def keep_if(*args, &block); end + + def key(*args, &block); end + + def key?(*args, &block); end + + def keys(*args, &block); end + + def lazy(*args, &block); end + + def length(*args, &block); end + + def map(*args, &block); end + + def max(*args, &block); end + + def max_by(*args, &block); end + + def member?(*args, &block); end + + def merge(*args, &block); end + + def merge!(*args, &block); end + + def min(*args, &block); end + + def min_by(*args, &block); end + + def minmax(*args, &block); end + + def minmax_by(*args, &block); end + + def none?(*args, &block); end + + def one?(*args, &block); end + + def partition(*args, &block); end + + def rassoc(*args, &block); end + + def reduce(*args, &block); end + + def rehash(*args, &block); end + + def reject(*args, &block); end + + def reject!(*args, &block); end + + def replace(*args, &block); end + + def reverse_each(*args, &block); end + + def select(*args, &block); end + + def select!(*args, &block); end + + def shift(*args, &block); end + + def size(*args, &block); end + + def slice(*args, &block); end + + def slice_after(*args, &block); end + + def slice_before(*args, &block); end + + def slice_when(*args, &block); end + + def sort(*args, &block); end + + def sort_by(*args, &block); end + + def store(*args, &block); end + + def sum(*args, &block); end + + def take(*args, &block); end + + def take_while(*args, &block); end + + def to_a(*args, &block); end + + def to_h(); end + + def to_hash(*args, &block); end + + def to_proc(*args, &block); end + + def to_set(*args, &block); end + + def transform_keys(*args, &block); end + + def transform_keys!(*args, &block); end + + def transform_values(*args, &block); end + + def transform_values!(*args, &block); end + + def uniq(*args, &block); end + + def update(*args, &block); end + + def value?(*args, &block); end + + def values(*args, &block); end + + def values_at(*args, &block); end + + def zip(*args, &block); end +end + +module RSpec::Core::HashImitatable::ClassMethods + def attr_accessor(*names); end + + def hash_attribute_names(); end +end + +module RSpec::Core::HashImitatable::ClassMethods +end + +module RSpec::Core::HashImitatable + def self.included(klass); end +end + +module RSpec::Core::Hooks + def after(*args, &block); end + + def append_after(*args, &block); end + + def append_before(*args, &block); end + + def around(*args, &block); end + + def before(*args, &block); end + + def hooks(); end + + def prepend_after(*args, &block); end + + def prepend_before(*args, &block); end +end + +class RSpec::Core::Hooks::AfterContextHook + def run(example); end +end + +class RSpec::Core::Hooks::AfterContextHook +end + +class RSpec::Core::Hooks::AfterHook + def run(example); end +end + +class RSpec::Core::Hooks::AfterHook +end + +class RSpec::Core::Hooks::AroundHook + def execute_with(example, procsy); end + + def hook_description(); end +end + +class RSpec::Core::Hooks::AroundHook +end + +class RSpec::Core::Hooks::BeforeHook + def run(example); end +end + +class RSpec::Core::Hooks::BeforeHook +end + +class RSpec::Core::Hooks::Hook + def block(); end + + def block=(_); end + + def options(); end + + def options=(_); end +end + +class RSpec::Core::Hooks::Hook + def self.[](*_); end + + def self.members(); end +end + +class RSpec::Core::Hooks::HookCollections + def all_hooks_for(position, scope); end + + def initialize(owner, filterable_item_repo_class); end + + def matching_hooks_for(position, scope, example_or_group); end + + def processable_hooks_for(position, scope, host); end + + def register(prepend_or_append, position, *args, &block); end + + def register_global_singleton_context_hooks(example, globals); end + + def register_globals(host, globals); end + + def run(position, scope, example_or_group); end + + def run_owned_hooks_for(position, scope, example_or_group); end + EMPTY_HOOK_ARRAY = ::T.let(nil, ::T.untyped) + HOOK_TYPES = ::T.let(nil, ::T.untyped) + SCOPES = ::T.let(nil, ::T.untyped) + SCOPE_ALIASES = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Hooks::HookCollections +end + +module RSpec::Core::Hooks +end + +class RSpec::Core::InclusionRules + def add(*args); end + + def add_with_low_priority(*args); end + + def split_file_scoped_rules(); end + + def standalone?(); end +end + +class RSpec::Core::InclusionRules +end + +module RSpec::Core::Invocations +end + +class RSpec::Core::Invocations::Bisect + def call(options, err, out); end +end + +class RSpec::Core::Invocations::Bisect +end + +class RSpec::Core::Invocations::DRbWithFallback + def call(options, err, out); end +end + +class RSpec::Core::Invocations::DRbWithFallback +end + +class RSpec::Core::Invocations::InitializeProject + def call(*_args); end +end + +class RSpec::Core::Invocations::InitializeProject +end + +class RSpec::Core::Invocations::PrintHelp + def call(_options, _err, out); end + + def hidden_options(); end + + def hidden_options=(_); end + + def parser(); end + + def parser=(_); end +end + +class RSpec::Core::Invocations::PrintHelp + def self.[](*_); end + + def self.members(); end +end + +class RSpec::Core::Invocations::PrintVersion + def call(_options, _err, out); end +end + +class RSpec::Core::Invocations::PrintVersion +end + +module RSpec::Core::Invocations +end + +class RSpec::Core::LegacyExampleGroupHash + include ::RSpec::Core::HashImitatable + def initialize(metadata); end +end + +class RSpec::Core::LegacyExampleGroupHash + extend ::RSpec::Core::HashImitatable::ClassMethods +end + +module RSpec::Core::MemoizedHelpers + def initialize(*_); end + + def is_expected(); end + + def should(matcher=T.unsafe(nil), message=T.unsafe(nil)); end + + def should_not(matcher=T.unsafe(nil), message=T.unsafe(nil)); end + + def subject(); end +end + +module RSpec::Core::MemoizedHelpers::ClassMethods + def let(name, &block); end + + def let!(name, &block); end + + def subject(name=T.unsafe(nil), &block); end + + def subject!(name=T.unsafe(nil), &block); end +end + +module RSpec::Core::MemoizedHelpers::ClassMethods +end + +class RSpec::Core::MemoizedHelpers::ContextHookMemoized +end + +class RSpec::Core::MemoizedHelpers::ContextHookMemoized::After +end + +class RSpec::Core::MemoizedHelpers::ContextHookMemoized::After + def self.article(); end + + def self.hook_expression(); end + + def self.hook_intention(); end +end + +class RSpec::Core::MemoizedHelpers::ContextHookMemoized::Before +end + +class RSpec::Core::MemoizedHelpers::ContextHookMemoized::Before + def self.article(); end + + def self.hook_expression(); end + + def self.hook_intention(); end +end + +class RSpec::Core::MemoizedHelpers::ContextHookMemoized + def self.fetch_or_store(key, &_block); end + + def self.isolate_for_context_hook(example_group_instance); end +end + +class RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized + def fetch_or_store(key); end +end + +class RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized +end + +class RSpec::Core::MemoizedHelpers::ThreadsafeMemoized + def fetch_or_store(key); end +end + +class RSpec::Core::MemoizedHelpers::ThreadsafeMemoized +end + +module RSpec::Core::MemoizedHelpers + def self.define_helpers_on(example_group); end + + def self.get_constant_or_yield(example_group, name); end + + def self.module_for(example_group); end +end + +module RSpec::Core::Metadata + RESERVED_KEYS = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Metadata::ExampleGroupHash +end + +class RSpec::Core::Metadata::ExampleGroupHash + def self.backwards_compatibility_default_proc(&example_group_selector); end + + def self.create(parent_group_metadata, user_metadata, example_group_index, *args, &block); end + + def self.hash_with_backwards_compatibility_default_proc(); end +end + +class RSpec::Core::Metadata::ExampleHash +end + +class RSpec::Core::Metadata::ExampleHash + def self.create(group_metadata, user_metadata, index_provider, description, block); end +end + +class RSpec::Core::Metadata::HashPopulator + def block(); end + + def description_args(); end + + def initialize(metadata, user_metadata, index_provider, description_args, block); end + + def metadata(); end + + def populate(); end + + def user_metadata(); end +end + +class RSpec::Core::Metadata::HashPopulator +end + +module RSpec::Core::Metadata + def self.ascend(metadata); end + + def self.ascending(metadata); end + + def self.build_hash_from(args, warn_about_example_group_filtering=T.unsafe(nil)); end + + def self.deep_hash_dup(object); end + + def self.id_from(metadata); end + + def self.location_tuple_from(metadata); end + + def self.relative_path(line); end + + def self.relative_path_regex(); end +end + +module RSpec::Core::MetadataFilter +end + +module RSpec::Core::MetadataFilter + def self.apply?(predicate, filters, metadata); end + + def self.filter_applies?(key, filter_value, metadata); end + + def self.silence_metadata_example_group_deprecations(); end +end + +class RSpec::Core::MultipleExceptionError + include ::RSpec::Core::MultipleExceptionError::InterfaceTag + def aggregation_block_label(); end + + def aggregation_metadata(); end + + def all_exceptions(); end + + def exception_count_description(); end + + def failures(); end + + def initialize(*exceptions); end + + def other_errors(); end + + def summary(); end +end + +module RSpec::Core::MultipleExceptionError::InterfaceTag + def add(exception); end +end + +module RSpec::Core::MultipleExceptionError::InterfaceTag + def self.for(ex); end +end + +class RSpec::Core::MultipleExceptionError +end + +module RSpec::Core::Notifications +end + +class RSpec::Core::Notifications::CustomNotification +end + +class RSpec::Core::Notifications::CustomNotification + def self.for(options=T.unsafe(nil)); end +end + +class RSpec::Core::Notifications::DeprecationNotification + def call_site(); end + + def call_site=(_); end + + def deprecated(); end + + def deprecated=(_); end + + def message(); end + + def message=(_); end + + def replacement(); end + + def replacement=(_); end +end + +class RSpec::Core::Notifications::DeprecationNotification + def self.[](*_); end + + def self.from_hash(data); end + + def self.members(); end +end + +class RSpec::Core::Notifications::ExampleNotification + def example(); end + + def example=(_); end +end + +class RSpec::Core::Notifications::ExampleNotification + def self.[](*_); end + + def self.for(example); end + + def self.members(); end +end + +class RSpec::Core::Notifications::ExamplesNotification + def examples(); end + + def failed_examples(); end + + def failure_notifications(); end + + def fully_formatted_failed_examples(colorizer=T.unsafe(nil)); end + + def fully_formatted_pending_examples(colorizer=T.unsafe(nil)); end + + def initialize(reporter); end + + def notifications(); end + + def pending_examples(); end + + def pending_notifications(); end +end + +class RSpec::Core::Notifications::ExamplesNotification +end + +class RSpec::Core::Notifications::FailedExampleNotification + def colorized_formatted_backtrace(colorizer=T.unsafe(nil)); end + + def colorized_message_lines(colorizer=T.unsafe(nil)); end + + def description(); end + + def exception(); end + + def formatted_backtrace(); end + + def fully_formatted(failure_number, colorizer=T.unsafe(nil)); end + + def fully_formatted_lines(failure_number, colorizer=T.unsafe(nil)); end + + def initialize(example, exception_presenter=T.unsafe(nil)); end + + def message_lines(); end +end + +class RSpec::Core::Notifications::FailedExampleNotification +end + +class RSpec::Core::Notifications::GroupNotification + def group(); end + + def group=(_); end +end + +class RSpec::Core::Notifications::GroupNotification + def self.[](*_); end + + def self.members(); end +end + +class RSpec::Core::Notifications::MessageNotification + def message(); end + + def message=(_); end +end + +class RSpec::Core::Notifications::MessageNotification + def self.[](*_); end + + def self.members(); end +end + +module RSpec::Core::Notifications::NullColorizer +end + +module RSpec::Core::Notifications::NullColorizer + def self.wrap(line, _code_or_symbol); end +end + +class RSpec::Core::Notifications::NullNotification +end + +class RSpec::Core::Notifications::NullNotification +end + +class RSpec::Core::Notifications::PendingExampleFailedAsExpectedNotification +end + +class RSpec::Core::Notifications::PendingExampleFailedAsExpectedNotification +end + +class RSpec::Core::Notifications::PendingExampleFixedNotification +end + +class RSpec::Core::Notifications::PendingExampleFixedNotification +end + +class RSpec::Core::Notifications::ProfileNotification + def duration(); end + + def examples(); end + + def initialize(duration, examples, number_of_examples, example_groups); end + + def number_of_examples(); end + + def percentage(); end + + def slow_duration(); end + + def slowest_examples(); end + + def slowest_groups(); end +end + +class RSpec::Core::Notifications::ProfileNotification +end + +class RSpec::Core::Notifications::SeedNotification + def fully_formatted(); end + + def seed(); end + + def seed=(_); end + + def seed_used?(); end + + def used=(_); end +end + +class RSpec::Core::Notifications::SeedNotification + def self.[](*_); end + + def self.members(); end +end + +class RSpec::Core::Notifications::SkippedExampleNotification + def fully_formatted(pending_number, colorizer=T.unsafe(nil)); end +end + +class RSpec::Core::Notifications::SkippedExampleNotification +end + +class RSpec::Core::Notifications::StartNotification + def count(); end + + def count=(_); end + + def load_time(); end + + def load_time=(_); end +end + +class RSpec::Core::Notifications::StartNotification + def self.[](*_); end + + def self.members(); end +end + +class RSpec::Core::Notifications::SummaryNotification + include ::RSpec::Core::ShellEscape + def colorized_rerun_commands(colorizer=T.unsafe(nil)); end + + def colorized_totals_line(colorizer=T.unsafe(nil)); end + + def duration(); end + + def duration=(_); end + + def errors_outside_of_examples_count(); end + + def errors_outside_of_examples_count=(_); end + + def example_count(); end + + def examples(); end + + def examples=(_); end + + def failed_examples(); end + + def failed_examples=(_); end + + def failure_count(); end + + def formatted_duration(); end + + def formatted_load_time(); end + + def fully_formatted(colorizer=T.unsafe(nil)); end + + def load_time(); end + + def load_time=(_); end + + def pending_count(); end + + def pending_examples(); end + + def pending_examples=(_); end + + def totals_line(); end +end + +class RSpec::Core::Notifications::SummaryNotification + def self.[](*_); end + + def self.members(); end +end + +module RSpec::Core::Notifications +end + +class RSpec::Core::NullReporter +end + +class RSpec::Core::NullReporter +end + +module RSpec::Core::Ordering +end + +class RSpec::Core::Ordering::ConfigurationManager + def force(hash); end + + def order=(type); end + + def ordering_registry(); end + + def register_ordering(name, strategy=T.unsafe(nil)); end + + def seed(); end + + def seed=(seed); end + + def seed_used?(); end +end + +class RSpec::Core::Ordering::ConfigurationManager +end + +class RSpec::Core::Ordering::Custom + def initialize(callable); end + + def order(list); end +end + +class RSpec::Core::Ordering::Custom +end + +class RSpec::Core::Ordering::Identity + def order(items); end +end + +class RSpec::Core::Ordering::Identity +end + +class RSpec::Core::Ordering::Random + def initialize(configuration); end + + def order(items); end + + def used?(); end + MAX_32_BIT = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Ordering::Random +end + +class RSpec::Core::Ordering::Registry + def fetch(name, &fallback); end + + def initialize(configuration); end + + def register(sym, strategy); end + + def used_random_seed?(); end +end + +class RSpec::Core::Ordering::Registry +end + +module RSpec::Core::Ordering +end + +class RSpec::Core::OutputWrapper + def <<(*args, &block); end + + def advise(*args, &block); end + + def autoclose=(*args, &block); end + + def autoclose?(*args, &block); end + + def binmode(*args, &block); end + + def binmode?(*args, &block); end + + def bytes(*args, &block); end + + def chars(*args, &block); end + + def close(*args, &block); end + + def close_on_exec=(*args, &block); end + + def close_on_exec?(*args, &block); end + + def close_read(*args, &block); end + + def close_write(*args, &block); end + + def closed?(*args, &block); end + + def codepoints(*args, &block); end + + def each(*args, &block); end + + def each_byte(*args, &block); end + + def each_char(*args, &block); end + + def each_codepoint(*args, &block); end + + def each_line(*args, &block); end + + def eof(*args, &block); end + + def eof?(*args, &block); end + + def external_encoding(*args, &block); end + + def fcntl(*args, &block); end + + def fdatasync(*args, &block); end + + def fileno(*args, &block); end + + def flush(*args, &block); end + + def fsync(*args, &block); end + + def getbyte(*args, &block); end + + def getc(*args, &block); end + + def gets(*args, &block); end + + def initialize(output); end + + def inspect(*args, &block); end + + def internal_encoding(*args, &block); end + + def ioctl(*args, &block); end + + def isatty(*args, &block); end + + def lineno(*args, &block); end + + def lineno=(*args, &block); end + + def lines(*args, &block); end + + def method_missing(name, *args, &block); end + + def nread(*args, &block); end + + def output(); end + + def output=(output); end + + def pathconf(*args, &block); end + + def pid(*args, &block); end + + def pos(*args, &block); end + + def pos=(*args, &block); end + + def pread(*args, &block); end + + def print(*args, &block); end + + def printf(*args, &block); end + + def putc(*args, &block); end + + def puts(*args, &block); end + + def pwrite(*args, &block); end + + def read(*args, &block); end + + def read_nonblock(*args, &block); end + + def readbyte(*args, &block); end + + def readchar(*args, &block); end + + def readline(*args, &block); end + + def readlines(*args, &block); end + + def readpartial(*args, &block); end + + def ready?(*args, &block); end + + def reopen(*args, &block); end + + def respond_to?(name, priv=T.unsafe(nil)); end + + def rewind(*args, &block); end + + def seek(*args, &block); end + + def set_encoding(*args, &block); end + + def stat(*args, &block); end + + def sync(*args, &block); end + + def sync=(*args, &block); end + + def sysread(*args, &block); end + + def sysseek(*args, &block); end + + def syswrite(*args, &block); end + + def tell(*args, &block); end + + def to_i(*args, &block); end + + def to_io(*args, &block); end + + def tty?(*args, &block); end + + def ungetbyte(*args, &block); end + + def ungetc(*args, &block); end + + def wait(*args, &block); end + + def wait_readable(*args, &block); end + + def wait_writable(*args, &block); end + + def write(*args, &block); end + + def write_nonblock(*args, &block); end +end + +class RSpec::Core::OutputWrapper +end + +class RSpec::Core::Parser + def initialize(original_args); end + + def original_args(); end + + def parse(source=T.unsafe(nil)); end +end + +class RSpec::Core::Parser + def self.parse(args, source=T.unsafe(nil)); end +end + +module RSpec::Core::Pending + def pending(message=T.unsafe(nil)); end + + def skip(message=T.unsafe(nil)); end + NOT_YET_IMPLEMENTED = ::T.let(nil, ::T.untyped) + NO_REASON_GIVEN = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Pending::PendingExampleFixedError +end + +class RSpec::Core::Pending::PendingExampleFixedError +end + +class RSpec::Core::Pending::SkipDeclaredInExample + def argument(); end + + def initialize(argument); end +end + +class RSpec::Core::Pending::SkipDeclaredInExample +end + +module RSpec::Core::Pending + def self.mark_fixed!(example); end + + def self.mark_pending!(example, message_or_bool); end + + def self.mark_skipped!(example, message_or_bool); end +end + +class RSpec::Core::Profiler + def example_group_finished(notification); end + + def example_group_started(notification); end + + def example_groups(); end + + def example_started(notification); end + NOTIFICATIONS = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Profiler +end + +class RSpec::Core::Reporter + def abort_with(msg, exit_status); end + + def close_after(); end + + def deprecation(hash); end + + def example_failed(example); end + + def example_finished(example); end + + def example_group_finished(group); end + + def example_group_started(group); end + + def example_passed(example); end + + def example_pending(example); end + + def example_started(example); end + + def examples(); end + + def exit_early(exit_code); end + + def fail_fast_limit_met?(); end + + def failed_examples(); end + + def finish(); end + + def initialize(configuration); end + + def message(message); end + + def notify(event, notification); end + + def notify_non_example_exception(exception, context_description); end + + def pending_examples(); end + + def prepare_default(loader, output_stream, deprecation_stream); end + + def publish(event, options=T.unsafe(nil)); end + + def register_listener(listener, *notifications); end + + def registered_listeners(notification); end + + def report(expected_example_count); end + + def start(expected_example_count, time=T.unsafe(nil)); end + + def stop(); end + RSPEC_NOTIFICATIONS = ::T.let(nil, ::T.untyped) +end + +class RSpec::Core::Reporter +end + +module RSpec::Core::RubyProject +end + +module RSpec::Core::RubyProject + def self.add_dir_to_load_path(dir); end + + def self.add_to_load_path(*dirs); end + + def self.ascend_until(); end + + def self.determine_root(); end + + def self.find_first_parent_containing(dir); end + + def self.root(); end +end + +class RSpec::Core::Runner + def configuration(); end + + def configure(err, out); end + + def initialize(options, configuration=T.unsafe(nil), world=T.unsafe(nil)); end + + def options(); end + + def run(err, out); end + + def run_specs(example_groups); end + + def setup(err, out); end + + def world(); end +end + +class RSpec::Core::Runner + def self.autorun(); end + + def self.autorun_disabled?(); end + + def self.disable_autorun!(); end + + def self.handle_interrupt(); end + + def self.installed_at_exit?(); end + + def self.invoke(); end + + def self.perform_at_exit(); end + + def self.run(args, err=T.unsafe(nil), out=T.unsafe(nil)); end + + def self.running_in_drb?(); end + + def self.trap_interrupt(); end +end + +class RSpec::Core::Set + include ::Enumerable + def <<(key); end + + def clear(); end + + def delete(key); end + + def each(&block); end + + def empty?(); end + + def include?(key); end + + def initialize(array=T.unsafe(nil)); end + + def merge(values); end +end + +class RSpec::Core::Set +end + +module RSpec::Core::SharedContext + def __shared_context_recordings(); end + + def after(*args, &block); end + + def append_after(*args, &block); end + + def append_before(*args, &block); end + + def around(*args, &block); end + + def before(*args, &block); end + + def context(*args, &block); end + + def describe(*args, &block); end + + def hooks(*args, &block); end + + def included(group); end + + def let(*args, &block); end + + def let!(*args, &block); end + + def prepend_after(*args, &block); end + + def prepend_before(*args, &block); end + + def subject(*args, &block); end + + def subject!(*args, &block); end +end + +class RSpec::Core::SharedContext::Recording + def args(); end + + def args=(_); end + + def block(); end + + def block=(_); end + + def method_name(); end + + def method_name=(_); end + + def playback_onto(group); end +end + +class RSpec::Core::SharedContext::Recording + def self.[](*_); end + + def self.members(); end +end + +module RSpec::Core::SharedContext + def self.record(methods); end +end + +module RSpec::Core::SharedExampleGroup + def shared_context(name, *args, &block); end + + def shared_examples(name, *args, &block); end + + def shared_examples_for(name, *args, &block); end +end + +class RSpec::Core::SharedExampleGroup::Registry + def add(context, name, *metadata_args, &block); end + + def find(lookup_contexts, name); end +end + +class RSpec::Core::SharedExampleGroup::Registry +end + +module RSpec::Core::SharedExampleGroup::TopLevelDSL +end + +module RSpec::Core::SharedExampleGroup::TopLevelDSL + def self.definitions(); end + + def self.expose_globally!(); end + + def self.exposed_globally?(); end + + def self.remove_globally!(); end +end + +module RSpec::Core::SharedExampleGroup +end + +class RSpec::Core::SharedExampleGroupInclusionStackFrame + def description(); end + + def formatted_inclusion_location(); end + + def inclusion_location(); end + + def initialize(shared_group_name, inclusion_location); end + + def shared_group_name(); end +end + +class RSpec::Core::SharedExampleGroupInclusionStackFrame + def self.current_backtrace(); end + + def self.shared_example_group_inclusions(); end + + def self.with_frame(name, location); end +end + +class RSpec::Core::SharedExampleGroupModule + def definition(); end + + def include_in(klass, inclusion_line, args, customization_block); end + + def included(klass); end + + def initialize(description, definition, metadata); end +end + +class RSpec::Core::SharedExampleGroupModule +end + +module RSpec::Core::ShellEscape + SHELLS_ALLOWING_UNQUOTED_IDS = ::T.let(nil, ::T.untyped) +end + +module RSpec::Core::ShellEscape + def self.conditionally_quote(id); end + + def self.escape(shell_command); end + + def self.quote(argument); end + + def self.shell_allows_unquoted_ids?(); end +end + +class RSpec::Core::SuiteHookContext + def initialize(hook_description, reporter); end +end + +class RSpec::Core::SuiteHookContext +end + +class RSpec::Core::Time +end + +class RSpec::Core::Time + def self.now(); end +end + +module RSpec::Core::Version + STRING = ::T.let(nil, ::T.untyped) +end + +module RSpec::Core::Version +end + +module RSpec::Core::Warnings + def deprecate(deprecated, data=T.unsafe(nil)); end + + def warn_deprecation(message, opts=T.unsafe(nil)); end + + def warn_with(message, options=T.unsafe(nil)); end +end + +module RSpec::Core::Warnings +end + +class RSpec::Core::World + def all_example_groups(); end + + def all_examples(); end + + def announce_exclusion_filter(announcements); end + + def announce_filters(); end + + def announce_inclusion_filter(announcements); end + + def everything_filtered_message(); end + + def example_count(groups=T.unsafe(nil)); end + + def example_groups(); end + + def exclusion_filter(); end + + def filter_manager(); end + + def filtered_examples(); end + + def inclusion_filter(); end + + def initialize(configuration=T.unsafe(nil)); end + + def non_example_failure(); end + + def non_example_failure=(non_example_failure); end + + def num_example_groups_defined_in(file); end + + def ordered_example_groups(); end + + def preceding_declaration_line(absolute_file_name, filter_line); end + + def prepare_example_filtering(); end + + def record(example_group); end + + def registered_example_group_files(); end + + def report_filter_message(message); end + + def reporter(); end + + def reset(); end + + def shared_example_group_registry(); end + + def source_from_file(path); end + + def syntax_highlighter(); end + + def traverse_example_group_trees_until(&block); end + + def wants_to_quit(); end + + def wants_to_quit=(wants_to_quit); end +end + +module RSpec::Core::World::Null +end + +module RSpec::Core::World::Null + def self.all_example_groups(); end + + def self.example_groups(); end + + def self.non_example_failure(); end + + def self.non_example_failure=(_); end + + def self.registered_example_group_files(); end + + def self.traverse_example_group_trees_until(); end +end + +class RSpec::Core::World +end + +module RSpec::Core + def self.path_to_executable(); end +end + +module RSpec::ExampleGroups +end + +module RSpec::ExampleGroups + extend ::RSpec::Support::RecursiveConstMethods + def self.assign_const(group); end + + def self.base_name_for(group); end + + def self.constant_scope_for(group); end + + def self.disambiguate(name, const_scope); end + + def self.remove_all_constants(); end +end + +RSpec::SharedContext = RSpec::Core::SharedContext + +module RSpec::Support + DEFAULT_FAILURE_NOTIFIER = ::T.let(nil, ::T.untyped) + DEFAULT_WARNING_NOTIFIER = ::T.let(nil, ::T.untyped) + KERNEL_METHOD_METHOD = ::T.let(nil, ::T.untyped) +end + +module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue + AVOID_RESCUING = ::T.let(nil, ::T.untyped) +end + +module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue + def self.===(exception); end +end + +class RSpec::Support::ComparableVersion + include ::Comparable + def initialize(string); end + + def segments(); end + + def string(); end +end + +class RSpec::Support::ComparableVersion +end + +class RSpec::Support::Differ + def color?(); end + + def diff(actual, expected); end + + def diff_as_object(actual, expected); end + + def diff_as_string(actual, expected); end + + def initialize(opts=T.unsafe(nil)); end +end + +class RSpec::Support::Differ +end + +class RSpec::Support::DirectoryMaker +end + +class RSpec::Support::DirectoryMaker + def self.mkdir_p(path); end +end + +class RSpec::Support::EncodedString + def <<(string); end + + def ==(*args, &block); end + + def empty?(*args, &block); end + + def encoding(*args, &block); end + + def eql?(*args, &block); end + + def initialize(string, encoding=T.unsafe(nil)); end + + def lines(*args, &block); end + + def source_encoding(); end + + def split(regex_or_string); end + + def to_str(); end + REPLACE = ::T.let(nil, ::T.untyped) + US_ASCII = ::T.let(nil, ::T.untyped) + UTF_8 = ::T.let(nil, ::T.untyped) +end + +class RSpec::Support::EncodedString + def self.pick_encoding(source_a, source_b); end +end + +RSpec::Support::Mutex = Thread::Mutex + +module RSpec::Support::OS +end + +module RSpec::Support::OS + def self.windows?(); end + + def self.windows_file_path?(); end +end + +module RSpec::Support::RecursiveConstMethods + def const_defined_on?(mod, const_name); end + + def constants_defined_on(mod); end + + def get_const_defined_on(mod, const_name); end + + def normalize_const_name(const_name); end + + def recursive_const_defined?(const_name); end + + def recursive_const_get(const_name); end +end + +module RSpec::Support::RecursiveConstMethods +end + +class RSpec::Support::ReentrantMutex + def synchronize(); end +end + +class RSpec::Support::ReentrantMutex +end + +module RSpec::Support::Ruby +end + +module RSpec::Support::Ruby + def self.jruby?(); end + + def self.jruby_9000?(); end + + def self.jruby_version(); end + + def self.mri?(); end + + def self.non_mri?(); end + + def self.rbx?(); end +end + +module RSpec::Support::RubyFeatures +end + +module RSpec::Support::RubyFeatures + def self.caller_locations_supported?(); end + + def self.fork_supported?(); end + + def self.kw_args_supported?(); end + + def self.module_prepends_supported?(); end + + def self.module_refinement_supported?(); end + + def self.optional_and_splat_args_supported?(); end + + def self.required_kw_args_supported?(); end + + def self.ripper_supported?(); end + + def self.supports_exception_cause?(); end + + def self.supports_rebinding_module_methods?(); end + + def self.supports_taint?(); end +end + +module RSpec::Support::Version + STRING = ::T.let(nil, ::T.untyped) +end + +module RSpec::Support::Version +end + +module RSpec::Support::Warnings + def deprecate(deprecated, options=T.unsafe(nil)); end + + def warn_deprecation(message, options=T.unsafe(nil)); end + + def warn_with(message, options=T.unsafe(nil)); end + + def warning(text, options=T.unsafe(nil)); end +end + +module RSpec::Support::Warnings +end + +module RSpec::Support + def self.class_of(object); end + + def self.define_optimized_require_for_rspec(lib, &require_relative); end + + def self.deregister_matcher_definition(&block); end + + def self.failure_notifier(); end + + def self.failure_notifier=(callable); end + + def self.is_a_matcher?(object); end + + def self.matcher_definitions(); end + + def self.method_handle_for(object, method_name); end + + def self.notify_failure(failure, options=T.unsafe(nil)); end + + def self.register_matcher_definition(&block); end + + def self.require_rspec_core(f); end + + def self.require_rspec_support(f); end + + def self.rspec_description_for_object(object); end + + def self.thread_local_data(); end + + def self.warning_notifier(); end + + def self.warning_notifier=(warning_notifier); end + + def self.with_failure_notifier(callable); end +end + +module RSpec::Version + STRING = ::T.let(nil, ::T.untyped) +end + +module RSpec::Version +end + +module RSpec + extend ::RSpec::Support::Warnings + extend ::RSpec::Core::Warnings + def self.clear_examples(); end + + def self.configuration(); end + + def self.configuration=(configuration); end + + def self.configure(); end + + def self.const_missing(name); end + + def self.context(*args, &example_group_block); end + + def self.current_example(); end + + def self.current_example=(example); end + + def self.describe(*args, &example_group_block); end + + def self.example_group(*args, &example_group_block); end + + def self.fcontext(*args, &example_group_block); end + + def self.fdescribe(*args, &example_group_block); end + + def self.reset(); end + + def self.world(); end + + def self.world=(world); end + + def self.xcontext(*args, &example_group_block); end + + def self.xdescribe(*args, &example_group_block); end +end + +module Racc + Racc_No_Extensions = ::T.let(nil, ::T.untyped) +end + +class Racc::CparseParams +end + +class Racc::CparseParams +end + +class Racc::Parser + Racc_Main_Parsing_Routine = ::T.let(nil, ::T.untyped) + Racc_Runtime_Core_Id_C = ::T.let(nil, ::T.untyped) + Racc_Runtime_Core_Revision = ::T.let(nil, ::T.untyped) + Racc_Runtime_Core_Revision_C = ::T.let(nil, ::T.untyped) + Racc_Runtime_Core_Revision_R = ::T.let(nil, ::T.untyped) + Racc_Runtime_Core_Version = ::T.let(nil, ::T.untyped) + Racc_Runtime_Core_Version_C = ::T.let(nil, ::T.untyped) + Racc_Runtime_Core_Version_R = ::T.let(nil, ::T.untyped) + Racc_Runtime_Revision = ::T.let(nil, ::T.untyped) + Racc_Runtime_Type = ::T.let(nil, ::T.untyped) + Racc_Runtime_Version = ::T.let(nil, ::T.untyped) + Racc_YY_Parse_Method = ::T.let(nil, ::T.untyped) +end + +module Rack + CACHE_CONTROL = ::T.let(nil, ::T.untyped) + CONTENT_LENGTH = ::T.let(nil, ::T.untyped) + CONTENT_TYPE = ::T.let(nil, ::T.untyped) + DELETE = ::T.let(nil, ::T.untyped) + ETAG = ::T.let(nil, ::T.untyped) + EXPIRES = ::T.let(nil, ::T.untyped) + GET = ::T.let(nil, ::T.untyped) + HEAD = ::T.let(nil, ::T.untyped) + HTTPS = ::T.let(nil, ::T.untyped) + HTTP_COOKIE = ::T.let(nil, ::T.untyped) + HTTP_HOST = ::T.let(nil, ::T.untyped) + HTTP_PORT = ::T.let(nil, ::T.untyped) + HTTP_VERSION = ::T.let(nil, ::T.untyped) + LINK = ::T.let(nil, ::T.untyped) + OPTIONS = ::T.let(nil, ::T.untyped) + PATCH = ::T.let(nil, ::T.untyped) + PATH_INFO = ::T.let(nil, ::T.untyped) + POST = ::T.let(nil, ::T.untyped) + PUT = ::T.let(nil, ::T.untyped) + QUERY_STRING = ::T.let(nil, ::T.untyped) + RACK_ERRORS = ::T.let(nil, ::T.untyped) + RACK_HIJACK = ::T.let(nil, ::T.untyped) + RACK_HIJACK_IO = ::T.let(nil, ::T.untyped) + RACK_INPUT = ::T.let(nil, ::T.untyped) + RACK_IS_HIJACK = ::T.let(nil, ::T.untyped) + RACK_LOGGER = ::T.let(nil, ::T.untyped) + RACK_METHODOVERRIDE_ORIGINAL_METHOD = ::T.let(nil, ::T.untyped) + RACK_MULTIPART_BUFFER_SIZE = ::T.let(nil, ::T.untyped) + RACK_MULTIPART_TEMPFILE_FACTORY = ::T.let(nil, ::T.untyped) + RACK_MULTIPROCESS = ::T.let(nil, ::T.untyped) + RACK_MULTITHREAD = ::T.let(nil, ::T.untyped) + RACK_RECURSIVE_INCLUDE = ::T.let(nil, ::T.untyped) + RACK_REQUEST_COOKIE_HASH = ::T.let(nil, ::T.untyped) + RACK_REQUEST_COOKIE_STRING = ::T.let(nil, ::T.untyped) + RACK_REQUEST_FORM_HASH = ::T.let(nil, ::T.untyped) + RACK_REQUEST_FORM_INPUT = ::T.let(nil, ::T.untyped) + RACK_REQUEST_FORM_VARS = ::T.let(nil, ::T.untyped) + RACK_REQUEST_QUERY_HASH = ::T.let(nil, ::T.untyped) + RACK_REQUEST_QUERY_STRING = ::T.let(nil, ::T.untyped) + RACK_RUNONCE = ::T.let(nil, ::T.untyped) + RACK_SESSION = ::T.let(nil, ::T.untyped) + RACK_SESSION_OPTIONS = ::T.let(nil, ::T.untyped) + RACK_SESSION_UNPACKED_COOKIE_DATA = ::T.let(nil, ::T.untyped) + RACK_SHOWSTATUS_DETAIL = ::T.let(nil, ::T.untyped) + RACK_TEMPFILES = ::T.let(nil, ::T.untyped) + RACK_URL_SCHEME = ::T.let(nil, ::T.untyped) + RACK_VERSION = ::T.let(nil, ::T.untyped) + RELEASE = ::T.let(nil, ::T.untyped) + REQUEST_METHOD = ::T.let(nil, ::T.untyped) + REQUEST_PATH = ::T.let(nil, ::T.untyped) + SCRIPT_NAME = ::T.let(nil, ::T.untyped) + SERVER_NAME = ::T.let(nil, ::T.untyped) + SERVER_PORT = ::T.let(nil, ::T.untyped) + SERVER_PROTOCOL = ::T.let(nil, ::T.untyped) + SET_COOKIE = ::T.let(nil, ::T.untyped) + TRACE = ::T.let(nil, ::T.untyped) + TRANSFER_ENCODING = ::T.let(nil, ::T.untyped) + UNLINK = ::T.let(nil, ::T.untyped) + VERSION = ::T.let(nil, ::T.untyped) +end + +module Rack::Auth +end + +class Rack::Auth::AbstractHandler + def initialize(app, realm=T.unsafe(nil), &authenticator); end + + def realm(); end + + def realm=(realm); end +end + +class Rack::Auth::AbstractHandler +end + +class Rack::Auth::AbstractRequest + def initialize(env); end + + def params(); end + + def parts(); end + + def provided?(); end + + def request(); end + + def scheme(); end + + def valid?(); end + AUTHORIZATION_KEYS = ::T.let(nil, ::T.untyped) +end + +class Rack::Auth::AbstractRequest +end + +class Rack::Auth::Basic + def call(env); end +end + +class Rack::Auth::Basic::Request + def basic?(); end + + def credentials(); end + + def username(); end +end + +class Rack::Auth::Basic::Request +end + +class Rack::Auth::Basic +end + +module Rack::Auth::Digest +end + +class Rack::Auth::Digest::MD5 + def call(env); end + + def initialize(app, realm=T.unsafe(nil), opaque=T.unsafe(nil), &authenticator); end + + def opaque(); end + + def opaque=(opaque); end + + def passwords_hashed=(passwords_hashed); end + + def passwords_hashed?(); end + QOP = ::T.let(nil, ::T.untyped) +end + +class Rack::Auth::Digest::MD5 +end + +class Rack::Auth::Digest::Nonce + def digest(); end + + def fresh?(); end + + def initialize(timestamp=T.unsafe(nil), given_digest=T.unsafe(nil)); end + + def stale?(); end + + def valid?(); end +end + +class Rack::Auth::Digest::Nonce + def self.parse(string); end + + def self.private_key(); end + + def self.private_key=(private_key); end + + def self.time_limit(); end + + def self.time_limit=(time_limit); end +end + +class Rack::Auth::Digest::Params + def [](k); end + + def []=(k, v); end + + def initialize(); end + + def quote(str); end + UNQUOTED = ::T.let(nil, ::T.untyped) +end + +class Rack::Auth::Digest::Params + def self.dequote(str); end + + def self.parse(str); end + + def self.split_header_value(str); end +end + +class Rack::Auth::Digest::Request + def correct_uri?(); end + + def digest?(); end + + def method(); end + + def method_missing(sym, *args); end + + def nonce(); end + + def respond_to?(sym, *_); end +end + +class Rack::Auth::Digest::Request +end + +module Rack::Auth::Digest +end + +module Rack::Auth +end + +class Rack::BodyProxy + def close(); end + + def closed?(); end + + def initialize(body, &block); end + + def method_missing(method_name, *args, &block); end +end + +class Rack::BodyProxy +end + +class Rack::Builder + def call(env); end + + def freeze_app(); end + + def initialize(default_app=T.unsafe(nil), &block); end + + def map(path, &block); end + + def run(app); end + + def to_app(); end + + def use(middleware, *args, &block); end + + def warmup(prc=T.unsafe(nil), &block); end + UTF_8_BOM = ::T.let(nil, ::T.untyped) +end + +class Rack::Builder + def self.app(default_app=T.unsafe(nil), &block); end + + def self.load_file(path, opts=T.unsafe(nil)); end + + def self.new_from_string(builder_script, file=T.unsafe(nil)); end + + def self.parse_file(config, opts=T.unsafe(nil)); end +end + +class Rack::Cascade + def <<(app); end + + def add(app); end + + def apps(); end + + def call(env); end + + def include?(app); end + + def initialize(apps, cascade_for=T.unsafe(nil)); end + NotFound = ::T.let(nil, ::T.untyped) +end + +class Rack::Cascade +end + +class Rack::Chunked + include ::Rack::Utils + def call(env); end + + def chunkable_version?(ver); end + + def initialize(app); end +end + +class Rack::Chunked::Body + def close(); end + + def each(&block); end + + def initialize(body); end + TAIL = ::T.let(nil, ::T.untyped) + TERM = ::T.let(nil, ::T.untyped) +end + +class Rack::Chunked::Body +end + +class Rack::Chunked::TrailerBody +end + +class Rack::Chunked::TrailerBody +end + +class Rack::Chunked +end + +class Rack::CommonLogger + def call(env); end + + def initialize(app, logger=T.unsafe(nil)); end + FORMAT = ::T.let(nil, ::T.untyped) +end + +class Rack::CommonLogger +end + +class Rack::ConditionalGet + def call(env); end + + def initialize(app); end +end + +class Rack::ConditionalGet +end + +class Rack::Config + def call(env); end + + def initialize(app, &block); end +end + +class Rack::Config +end + +class Rack::ContentLength + include ::Rack::Utils + def call(env); end + + def initialize(app); end +end + +class Rack::ContentLength +end + +class Rack::ContentType + include ::Rack::Utils + def call(env); end + + def initialize(app, content_type=T.unsafe(nil)); end +end + +class Rack::ContentType +end + +class Rack::Deflater + def call(env); end + + def initialize(app, options=T.unsafe(nil)); end +end + +class Rack::Deflater::GzipStream + def close(); end + + def each(&block); end + + def initialize(body, mtime, sync); end + + def write(data); end +end + +class Rack::Deflater::GzipStream +end + +class Rack::Deflater +end + +class Rack::Directory + def call(env); end + + def check_bad_request(path_info); end + + def check_forbidden(path_info); end + + def entity_not_found(path_info); end + + def filesize_format(int); end + + def get(env); end + + def initialize(root, app=T.unsafe(nil)); end + + def list_directory(path_info, path, script_name); end + + def list_path(env, path, path_info, script_name); end + + def root(); end + + def stat(path); end + DIR_FILE = ::T.let(nil, ::T.untyped) + DIR_PAGE_FOOTER = ::T.let(nil, ::T.untyped) + DIR_PAGE_HEADER = ::T.let(nil, ::T.untyped) + FILESIZE_FORMAT = ::T.let(nil, ::T.untyped) +end + +class Rack::Directory::DirectoryBody +end + +class Rack::Directory::DirectoryBody +end + +class Rack::Directory +end + +class Rack::ETag + def call(env); end + + def initialize(app, no_cache_control=T.unsafe(nil), cache_control=T.unsafe(nil)); end + DEFAULT_CACHE_CONTROL = ::T.let(nil, ::T.untyped) + ETAG_STRING = ::T.let(nil, ::T.untyped) +end + +class Rack::ETag +end + +class Rack::Events + def call(env); end + + def initialize(app, handlers); end +end + +module Rack::Events::Abstract + def on_commit(req, res); end + + def on_error(req, res, e); end + + def on_finish(req, res); end + + def on_send(req, res); end + + def on_start(req, res); end +end + +module Rack::Events::Abstract +end + +class Rack::Events::BufferedResponse + def body(); end + + def initialize(status, headers, body); end + + def to_a(); end +end + +class Rack::Events::BufferedResponse +end + +class Rack::Events::EventedBodyProxy + def each(&blk); end + + def initialize(body, request, response, handlers, &block); end + + def request(); end + + def response(); end +end + +class Rack::Events::EventedBodyProxy +end + +class Rack::Events +end + +Rack::File = Rack::Files + +class Rack::Files + def call(env); end + + def get(env); end + + def initialize(root, headers=T.unsafe(nil), default_mime=T.unsafe(nil)); end + + def root(); end + + def serving(request, path); end + ALLOWED_VERBS = ::T.let(nil, ::T.untyped) + ALLOW_HEADER = ::T.let(nil, ::T.untyped) + MULTIPART_BOUNDARY = ::T.let(nil, ::T.untyped) +end + +class Rack::Files::BaseIterator + def bytesize(); end + + def close(); end + + def each(&blk); end + + def initialize(path, ranges, options); end + + def options(); end + + def path(); end + + def ranges(); end +end + +class Rack::Files::BaseIterator +end + +class Rack::Files::Iterator + def to_path(); end +end + +class Rack::Files::Iterator +end + +class Rack::Files + def self.method_added(name); end +end + +class Rack::ForwardRequest + def env(); end + + def initialize(url, env=T.unsafe(nil)); end + + def url(); end +end + +class Rack::ForwardRequest +end + +module Rack::Handler +end + +class Rack::Handler::CGI +end + +class Rack::Handler::CGI + def self.run(app, **options); end + + def self.send_body(body); end + + def self.send_headers(status, headers); end + + def self.serve(app); end +end + +class Rack::Handler::WEBrick + def initialize(server, app); end +end + +class Rack::Handler::WEBrick + def self.run(app, **options); end + + def self.shutdown(); end + + def self.valid_options(); end +end + +module Rack::Handler + def self.default(); end + + def self.get(server); end + + def self.pick(server_names); end + + def self.register(server, klass); end + + def self.try_require(prefix, const_name); end +end + +class Rack::Head + def call(env); end + + def initialize(app); end +end + +class Rack::Head +end + +class Rack::Lint + include ::Rack::Lint::Assertion + def _call(env); end + + def call(env=T.unsafe(nil)); end + + def check_content_length(status, headers); end + + def check_content_type(status, headers); end + + def check_env(env); end + + def check_error(error); end + + def check_headers(header); end + + def check_hijack(env); end + + def check_hijack_response(headers, env); end + + def check_input(input); end + + def check_status(status); end + + def close(); end + + def each(&blk); end + + def initialize(app); end + + def verify_content_length(bytes); end +end + +module Rack::Lint::Assertion + def assert(message); end +end + +module Rack::Lint::Assertion +end + +class Rack::Lint::ErrorWrapper + include ::Rack::Lint::Assertion + def close(*args); end + + def flush(); end + + def initialize(error); end + + def puts(str); end + + def write(str); end +end + +class Rack::Lint::ErrorWrapper +end + +class Rack::Lint::HijackWrapper + include ::Rack::Lint::Assertion + def close(*args, &block); end + + def close_read(*args, &block); end + + def close_write(*args, &block); end + + def closed?(*args, &block); end + + def flush(*args, &block); end + + def initialize(io); end + + def read(*args, &block); end + + def read_nonblock(*args, &block); end + + def write(*args, &block); end + + def write_nonblock(*args, &block); end + REQUIRED_METHODS = ::T.let(nil, ::T.untyped) +end + +class Rack::Lint::HijackWrapper + extend ::Forwardable +end + +class Rack::Lint::InputWrapper + include ::Rack::Lint::Assertion + def close(*args); end + + def each(*args, &blk); end + + def gets(*args); end + + def initialize(input); end + + def read(*args); end + + def rewind(*args); end +end + +class Rack::Lint::InputWrapper +end + +class Rack::Lint::LintError +end + +class Rack::Lint::LintError +end + +class Rack::Lint +end + +class Rack::Lock + def call(env); end + + def initialize(app, mutex=T.unsafe(nil)); end +end + +class Rack::Lock +end + +class Rack::Logger + def call(env); end + + def initialize(app, level=T.unsafe(nil)); end +end + +class Rack::Logger +end + +class Rack::MediaType + SPLIT_PATTERN = ::T.let(nil, ::T.untyped) +end + +class Rack::MediaType + def self.params(content_type); end + + def self.type(content_type); end +end + +class Rack::MethodOverride + def call(env); end + + def initialize(app); end + + def method_override(env); end + ALLOWED_METHODS = ::T.let(nil, ::T.untyped) + HTTP_METHODS = ::T.let(nil, ::T.untyped) + HTTP_METHOD_OVERRIDE_HEADER = ::T.let(nil, ::T.untyped) + METHOD_OVERRIDE_PARAM_KEY = ::T.let(nil, ::T.untyped) +end + +class Rack::MethodOverride +end + +module Rack::Mime + MIME_TYPES = ::T.let(nil, ::T.untyped) +end + +module Rack::Mime + def self.match?(value, matcher); end + + def self.mime_type(ext, fallback=T.unsafe(nil)); end +end + +class Rack::MockRequest + def delete(uri, opts=T.unsafe(nil)); end + + def get(uri, opts=T.unsafe(nil)); end + + def head(uri, opts=T.unsafe(nil)); end + + def initialize(app); end + + def options(uri, opts=T.unsafe(nil)); end + + def patch(uri, opts=T.unsafe(nil)); end + + def post(uri, opts=T.unsafe(nil)); end + + def put(uri, opts=T.unsafe(nil)); end + + def request(method=T.unsafe(nil), uri=T.unsafe(nil), opts=T.unsafe(nil)); end + DEFAULT_ENV = ::T.let(nil, ::T.untyped) +end + +class Rack::MockRequest::FatalWarner + def flush(); end + + def puts(warning); end + + def string(); end + + def write(warning); end +end + +class Rack::MockRequest::FatalWarner +end + +class Rack::MockRequest::FatalWarning +end + +class Rack::MockRequest::FatalWarning +end + +class Rack::MockRequest + def self.env_for(uri=T.unsafe(nil), opts=T.unsafe(nil)); end + + def self.parse_uri_rfc2396(uri); end +end + +class Rack::MockResponse + def =~(other); end + + def cookie(name); end + + def cookies(); end + + def errors(); end + + def errors=(errors); end + + def initialize(status, headers, body, errors=T.unsafe(nil)); end + + def match(other); end + + def original_headers(); end +end + +class Rack::MockResponse + def self.[](*_); end +end + +class Rack::MockSession + def after_request(&block); end + + def clear_cookies(); end + + def cookie_jar(); end + + def cookie_jar=(cookie_jar); end + + def default_host(); end + + def initialize(app, default_host=T.unsafe(nil)); end + + def last_request(); end + + def last_response(); end + + def request(uri, env); end + + def set_cookie(cookie, uri=T.unsafe(nil)); end +end + +class Rack::MockSession +end + +module Rack::Multipart + ATTRIBUTE = ::T.let(nil, ::T.untyped) + ATTRIBUTE_CHAR = ::T.let(nil, ::T.untyped) + BROKEN_QUOTED = ::T.let(nil, ::T.untyped) + BROKEN_UNQUOTED = ::T.let(nil, ::T.untyped) + CONDISP = ::T.let(nil, ::T.untyped) + DISPPARM = ::T.let(nil, ::T.untyped) + EOL = ::T.let(nil, ::T.untyped) + EXTENDED_INITIAL_NAME = ::T.let(nil, ::T.untyped) + EXTENDED_INITIAL_PARAMETER = ::T.let(nil, ::T.untyped) + EXTENDED_INITIAL_VALUE = ::T.let(nil, ::T.untyped) + EXTENDED_OTHER_NAME = ::T.let(nil, ::T.untyped) + EXTENDED_OTHER_PARAMETER = ::T.let(nil, ::T.untyped) + EXTENDED_OTHER_VALUE = ::T.let(nil, ::T.untyped) + EXTENDED_PARAMETER = ::T.let(nil, ::T.untyped) + MULTIPART = ::T.let(nil, ::T.untyped) + MULTIPART_BOUNDARY = ::T.let(nil, ::T.untyped) + MULTIPART_CONTENT_DISPOSITION = ::T.let(nil, ::T.untyped) + MULTIPART_CONTENT_ID = ::T.let(nil, ::T.untyped) + MULTIPART_CONTENT_TYPE = ::T.let(nil, ::T.untyped) + REGULAR_PARAMETER = ::T.let(nil, ::T.untyped) + REGULAR_PARAMETER_NAME = ::T.let(nil, ::T.untyped) + RFC2183 = ::T.let(nil, ::T.untyped) + SECTION = ::T.let(nil, ::T.untyped) + TOKEN = ::T.let(nil, ::T.untyped) + VALUE = ::T.let(nil, ::T.untyped) +end + +class Rack::Multipart::Generator + def dump(); end + + def initialize(params, first=T.unsafe(nil)); end +end + +class Rack::Multipart::Generator +end + +class Rack::Multipart::MultipartPartLimitError +end + +class Rack::Multipart::MultipartPartLimitError +end + +class Rack::Multipart::Parser + def initialize(boundary, tempfile, bufsize, query_parser); end + + def on_read(content); end + + def result(); end + + def state(); end + BOUNDARY_REGEX = ::T.let(nil, ::T.untyped) + BUFSIZE = ::T.let(nil, ::T.untyped) + CHARSET = ::T.let(nil, ::T.untyped) + EMPTY = ::T.let(nil, ::T.untyped) + TEMPFILE_FACTORY = ::T.let(nil, ::T.untyped) + TEXT_PLAIN = ::T.let(nil, ::T.untyped) +end + +class Rack::Multipart::Parser::BoundedIO + def initialize(io, content_length); end + + def read(size, outbuf=T.unsafe(nil)); end + + def rewind(); end +end + +class Rack::Multipart::Parser::BoundedIO +end + +class Rack::Multipart::Parser::Collector + include ::Enumerable + def each(&blk); end + + def initialize(tempfile); end + + def on_mime_body(mime_index, content); end + + def on_mime_finish(mime_index); end + + def on_mime_head(mime_index, head, filename, content_type, name); end +end + +class Rack::Multipart::Parser::Collector::BufferPart + def close(); end + + def file?(); end +end + +class Rack::Multipart::Parser::Collector::BufferPart +end + +class Rack::Multipart::Parser::Collector::MimePart + def get_data(); end +end + +class Rack::Multipart::Parser::Collector::MimePart +end + +class Rack::Multipart::Parser::Collector::TempfilePart + def close(); end + + def file?(); end +end + +class Rack::Multipart::Parser::Collector::TempfilePart +end + +class Rack::Multipart::Parser::Collector +end + +class Rack::Multipart::Parser::MultipartInfo + def params(); end + + def params=(_); end + + def tmp_files(); end + + def tmp_files=(_); end +end + +class Rack::Multipart::Parser::MultipartInfo + def self.[](*_); end + + def self.members(); end +end + +class Rack::Multipart::Parser + def self.parse(io, content_length, content_type, tmpfile, bufsize, qp); end + + def self.parse_boundary(content_type); end +end + +class Rack::Multipart::UploadedFile + def content_type(); end + + def content_type=(content_type); end + + def initialize(filepath=T.unsafe(nil), ct=T.unsafe(nil), bin=T.unsafe(nil), path: T.unsafe(nil), content_type: T.unsafe(nil), binary: T.unsafe(nil), filename: T.unsafe(nil), io: T.unsafe(nil)); end + + def local_path(); end + + def method_missing(method_name, *args, &block); end + + def original_filename(); end + + def path(); end + + def respond_to?(*args); end +end + +class Rack::Multipart::UploadedFile +end + +module Rack::Multipart + def self.build_multipart(params, first=T.unsafe(nil)); end + + def self.extract_multipart(req, params=T.unsafe(nil)); end + + def self.parse_multipart(env, params=T.unsafe(nil)); end +end + +class Rack::NullLogger + def <<(msg); end + + def add(severity, message=T.unsafe(nil), progname=T.unsafe(nil), &block); end + + def call(env); end + + def close(); end + + def datetime_format(); end + + def datetime_format=(datetime_format); end + + def debug(progname=T.unsafe(nil), &block); end + + def debug?(); end + + def error(progname=T.unsafe(nil), &block); end + + def error?(); end + + def fatal(progname=T.unsafe(nil), &block); end + + def fatal?(); end + + def formatter(); end + + def formatter=(formatter); end + + def info(progname=T.unsafe(nil), &block); end + + def info?(); end + + def initialize(app); end + + def level(); end + + def level=(level); end + + def progname(); end + + def progname=(progname); end + + def sev_threshold(); end + + def sev_threshold=(sev_threshold); end + + def unknown(progname=T.unsafe(nil), &block); end + + def warn(progname=T.unsafe(nil), &block); end + + def warn?(); end +end + +class Rack::NullLogger +end + +class Rack::QueryParser + def initialize(params_class, key_space_limit, param_depth_limit); end + + def key_space_limit(); end + + def make_params(); end + + def new_depth_limit(param_depth_limit); end + + def new_space_limit(key_space_limit); end + + def normalize_params(params, name, v, depth); end + + def param_depth_limit(); end + + def parse_nested_query(qs, d=T.unsafe(nil)); end + + def parse_query(qs, d=T.unsafe(nil), &unescaper); end + COMMON_SEP = ::T.let(nil, ::T.untyped) + DEFAULT_SEP = ::T.let(nil, ::T.untyped) +end + +class Rack::QueryParser::InvalidParameterError +end + +class Rack::QueryParser::InvalidParameterError +end + +class Rack::QueryParser::ParameterTypeError +end + +class Rack::QueryParser::ParameterTypeError +end + +class Rack::QueryParser::Params + def [](key); end + + def []=(key, value); end + + def initialize(limit); end + + def key?(key); end + + def to_h(); end + + def to_params_hash(); end +end + +class Rack::QueryParser::Params +end + +class Rack::QueryParser + def self.make_default(key_space_limit, param_depth_limit); end +end + +class Rack::Recursive + def _call(env); end + + def call(env); end + + def include(env, path); end + + def initialize(app); end +end + +class Rack::Recursive +end + +class Rack::Reloader + def call(env); end + + def initialize(app, cooldown=T.unsafe(nil), backend=T.unsafe(nil)); end + + def reload!(stderr=T.unsafe(nil)); end + + def safe_load(file, mtime, stderr=T.unsafe(nil)); end +end + +module Rack::Reloader::Stat + def figure_path(file, paths); end + + def rotation(); end + + def safe_stat(file); end +end + +module Rack::Reloader::Stat +end + +class Rack::Reloader +end + +class Rack::Request + include ::Rack::Request::Env + include ::Rack::Request::Helpers + ALLOWED_SCHEMES = ::T.let(nil, ::T.untyped) + SCHEME_WHITELIST = ::T.let(nil, ::T.untyped) +end + +module Rack::Request::Env + def add_header(key, v); end + + def delete_header(name); end + + def each_header(&block); end + + def env(); end + + def fetch_header(name, &block); end + + def get_header(name); end + + def has_header?(name); end + + def initialize(env); end + + def set_header(name, v); end +end + +module Rack::Request::Env +end + +module Rack::Request::Helpers + def GET(); end + + def POST(); end + + def [](key); end + + def []=(key, value); end + + def accept_encoding(); end + + def accept_language(); end + + def authority(); end + + def base_url(); end + + def body(); end + + def content_charset(); end + + def content_length(); end + + def content_type(); end + + def cookies(); end + + def delete?(); end + + def delete_param(k); end + + def form_data?(); end + + def forwarded_authority(); end + + def forwarded_for(); end + + def forwarded_port(); end + + def fullpath(); end + + def get?(); end + + def head?(); end + + def host(); end + + def host_authority(); end + + def host_with_port(authority=T.unsafe(nil)); end + + def hostname(); end + + def ip(); end + + def link?(); end + + def logger(); end + + def media_type(); end + + def media_type_params(); end + + def multithread?(); end + + def options?(); end + + def params(); end + + def parseable_data?(); end + + def patch?(); end + + def path(); end + + def path_info(); end + + def path_info=(s); end + + def port(); end + + def post?(); end + + def put?(); end + + def query_string(); end + + def referer(); end + + def referrer(); end + + def request_method(); end + + def scheme(); end + + def script_name(); end + + def script_name=(s); end + + def server_authority(); end + + def server_name(); end + + def server_port(); end + + def session(); end + + def session_options(); end + + def ssl?(); end + + def trace?(); end + + def trusted_proxy?(ip); end + + def unlink?(); end + + def update_param(k, v); end + + def url(); end + + def user_agent(); end + + def values_at(*keys); end + + def xhr?(); end + DEFAULT_PORTS = ::T.let(nil, ::T.untyped) + FORM_DATA_MEDIA_TYPES = ::T.let(nil, ::T.untyped) + HTTP_X_FORWARDED_FOR = ::T.let(nil, ::T.untyped) + HTTP_X_FORWARDED_HOST = ::T.let(nil, ::T.untyped) + HTTP_X_FORWARDED_PORT = ::T.let(nil, ::T.untyped) + HTTP_X_FORWARDED_PROTO = ::T.let(nil, ::T.untyped) + HTTP_X_FORWARDED_SCHEME = ::T.let(nil, ::T.untyped) + HTTP_X_FORWARDED_SSL = ::T.let(nil, ::T.untyped) + PARSEABLE_DATA_MEDIA_TYPES = ::T.let(nil, ::T.untyped) +end + +module Rack::Request::Helpers +end + +class Rack::Request + def self.ip_filter(); end + + def self.ip_filter=(ip_filter); end +end + +class Rack::Response + include ::Rack::Response::Helpers + def [](key); end + + def []=(key, v); end + + def body(); end + + def body=(body); end + + def chunked?(); end + + def close(); end + + def delete_header(key); end + + def each(&callback); end + + def empty?(); end + + def finish(&block); end + + def get_header(key); end + + def has_header?(key); end + + def header(); end + + def headers(); end + + def initialize(body=T.unsafe(nil), status=T.unsafe(nil), headers=T.unsafe(nil)); end + + def length(); end + + def length=(length); end + + def redirect(target, status=T.unsafe(nil)); end + + def set_header(key, v); end + + def status(); end + + def status=(status); end + + def to_a(&block); end + + def write(chunk); end + CHUNKED = ::T.let(nil, ::T.untyped) + STATUS_WITH_NO_ENTITY_BODY = ::T.let(nil, ::T.untyped) +end + +module Rack::Response::Helpers + def accepted?(); end + + def add_header(key, v); end + + def append(chunk); end + + def bad_request?(); end + + def buffered_body!(); end + + def cache!(duration=T.unsafe(nil), directive: T.unsafe(nil)); end + + def cache_control(); end + + def cache_control=(v); end + + def client_error?(); end + + def content_length(); end + + def content_type(); end + + def content_type=(content_type); end + + def created?(); end + + def delete_cookie(key, value=T.unsafe(nil)); end + + def do_not_cache!(); end + + def etag(); end + + def etag=(v); end + + def forbidden?(); end + + def include?(header); end + + def informational?(); end + + def invalid?(); end + + def location(); end + + def location=(location); end + + def media_type(); end + + def media_type_params(); end + + def method_not_allowed?(); end + + def moved_permanently?(); end + + def no_content?(); end + + def not_found?(); end + + def ok?(); end + + def precondition_failed?(); end + + def redirect?(); end + + def redirection?(); end + + def server_error?(); end + + def set_cookie(key, value); end + + def set_cookie_header(); end + + def set_cookie_header=(v); end + + def successful?(); end + + def unauthorized?(); end + + def unprocessable?(); end +end + +module Rack::Response::Helpers +end + +class Rack::Response::Raw + include ::Rack::Response::Helpers + def delete_header(key); end + + def get_header(key); end + + def has_header?(key); end + + def headers(); end + + def initialize(status, headers); end + + def set_header(key, v); end + + def status(); end + + def status=(status); end +end + +class Rack::Response::Raw +end + +class Rack::Response + def self.[](status, headers, body); end +end + +class Rack::RewindableInput + def close(); end + + def each(&block); end + + def gets(); end + + def initialize(io); end + + def read(*args); end + + def rewind(); end +end + +class Rack::RewindableInput +end + +class Rack::Runtime + def call(env); end + + def initialize(app, name=T.unsafe(nil)); end + FORMAT_STRING = ::T.let(nil, ::T.untyped) + HEADER_NAME = ::T.let(nil, ::T.untyped) +end + +class Rack::Runtime +end + +class Rack::Sendfile + def call(env); end + + def initialize(app, variation=T.unsafe(nil), mappings=T.unsafe(nil)); end +end + +class Rack::Sendfile +end + +class Rack::Server + def app(); end + + def default_options(); end + + def initialize(options=T.unsafe(nil)); end + + def middleware(); end + + def options(); end + + def options=(options); end + + def server(); end + + def start(&block); end +end + +class Rack::Server::Options + def handler_opts(options); end + + def parse!(args); end +end + +class Rack::Server::Options +end + +class Rack::Server + def self.default_middleware_by_environment(); end + + def self.logging_middleware(); end + + def self.middleware(); end + + def self.start(options=T.unsafe(nil)); end +end + +module Rack::Session +end + +class Rack::Session::Abstract::Persisted + def call(env); end + + def commit_session(req, res); end + + def context(env, app=T.unsafe(nil)); end + + def default_options(); end + + def initialize(app, options=T.unsafe(nil)); end + + def key(); end + + def sid_secure(); end + DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped) +end + +class Rack::Session::Abstract::Persisted +end + +class Rack::Session::Abstract::PersistedSecure + def extract_session_id(*_); end + + def generate_sid(*_); end +end + +class Rack::Session::Abstract::PersistedSecure +end + +class Rack::Session::Cookie + def coder(); end +end + +class Rack::Session::Cookie::Base64 + def decode(str); end + + def encode(str); end +end + +class Rack::Session::Cookie::Base64::JSON + def encode(obj); end +end + +class Rack::Session::Cookie::Base64::JSON +end + +class Rack::Session::Cookie::Base64::Marshal +end + +class Rack::Session::Cookie::Base64::Marshal +end + +class Rack::Session::Cookie::Base64::ZipJSON + def encode(obj); end +end + +class Rack::Session::Cookie::Base64::ZipJSON +end + +class Rack::Session::Cookie::Base64 +end + +class Rack::Session::Cookie::Identity + def decode(str); end + + def encode(str); end +end + +class Rack::Session::Cookie::Identity +end + +class Rack::Session::Cookie::SessionId + def cookie_value(); end + + def initialize(session_id, cookie_value); end +end + +class Rack::Session::Cookie::SessionId +end + +class Rack::Session::Cookie +end + +class Rack::Session::Pool + def delete_session(req, session_id, options); end + + def find_session(req, sid); end + + def generate_sid(); end + + def mutex(); end + + def pool(); end + + def with_lock(req); end + + def write_session(req, session_id, new_session, options); end + DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped) +end + +class Rack::Session::Pool +end + +module Rack::Session +end + +class Rack::ShowExceptions + def call(env); end + + def dump_exception(exception); end + + def h(obj); end + + def initialize(app); end + + def prefers_plaintext?(env); end + + def pretty(env, exception); end + + def template(); end + CONTEXT = ::T.let(nil, ::T.untyped) + TEMPLATE = ::T.let(nil, ::T.untyped) +end + +class Rack::ShowExceptions +end + +class Rack::ShowStatus + def call(env); end + + def h(obj); end + + def initialize(app); end + TEMPLATE = ::T.let(nil, ::T.untyped) +end + +class Rack::ShowStatus +end + +class Rack::Static + def add_index_root?(path); end + + def applicable_rules(path); end + + def call(env); end + + def can_serve(path); end + + def initialize(app, options=T.unsafe(nil)); end + + def overwrite_file_path(path); end + + def route_file(path); end +end + +class Rack::Static +end + +class Rack::TempfileReaper + def call(env); end + + def initialize(app); end +end + +class Rack::TempfileReaper +end + +module Rack::Test + DEFAULT_HOST = ::T.let(nil, ::T.untyped) + MULTIPART_BOUNDARY = ::T.let(nil, ::T.untyped) + VERSION = ::T.let(nil, ::T.untyped) +end + +class Rack::Test::Cookie + include ::Rack::Utils + def default_uri(); end + + def domain(); end + + def empty?(); end + + def expired?(); end + + def expires(); end + + def http_only?(); end + + def initialize(raw, uri=T.unsafe(nil), default_host=T.unsafe(nil)); end + + def matches?(uri); end + + def name(); end + + def path(); end + + def raw(); end + + def replaces?(other); end + + def secure?(); end + + def to_h(); end + + def to_hash(); end + + def valid?(uri); end + + def value(); end +end + +class Rack::Test::Cookie +end + +class Rack::Test::CookieJar + def <<(new_cookie); end + + def [](name); end + + def []=(name, value); end + + def delete(name); end + + def for(uri); end + + def get_cookie(name); end + + def hash_for(uri=T.unsafe(nil)); end + + def initialize(cookies=T.unsafe(nil), default_host=T.unsafe(nil)); end + + def merge(raw_cookies, uri=T.unsafe(nil)); end + + def to_hash(); end + DELIMITER = ::T.let(nil, ::T.untyped) +end + +class Rack::Test::CookieJar +end + +class Rack::Test::Error +end + +class Rack::Test::Error +end + +module Rack::Test::Methods + def _current_session_names(); end + + def authorize(*args, &block); end + + def basic_authorize(*args, &block); end + + def build_rack_mock_session(); end + + def build_rack_test_session(name); end + + def clear_cookies(*args, &block); end + + def current_session(); end + + def custom_request(*args, &block); end + + def delete(*args, &block); end + + def digest_authorize(*args, &block); end + + def env(*args, &block); end + + def follow_redirect!(*args, &block); end + + def get(*args, &block); end + + def head(*args, &block); end + + def header(*args, &block); end + + def last_request(*args, &block); end + + def last_response(*args, &block); end + + def options(*args, &block); end + + def patch(*args, &block); end + + def post(*args, &block); end + + def put(*args, &block); end + + def rack_mock_session(name=T.unsafe(nil)); end + + def rack_test_session(name=T.unsafe(nil)); end + + def request(*args, &block); end + + def set_cookie(*args, &block); end + + def with_session(name); end + METHODS = ::T.let(nil, ::T.untyped) +end + +module Rack::Test::Methods + extend ::Forwardable +end + +class Rack::Test::MockDigestRequest + def initialize(params); end + + def method(); end + + def method_missing(sym); end + + def response(password); end +end + +class Rack::Test::MockDigestRequest +end + +class Rack::Test::Session + include ::Rack::Test::Utils + include ::Rack::Utils + def authorize(username, password); end + + def basic_authorize(username, password); end + + def clear_cookies(*args, &block); end + + def custom_request(verb, uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end + + def delete(uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end + + def digest_authorize(username, password); end + + def env(name, value); end + + def follow_redirect!(); end + + def get(uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end + + def head(uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end + + def header(name, value); end + + def initialize(mock_session); end + + def last_request(*args, &block); end + + def last_response(*args, &block); end + + def options(uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end + + def patch(uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end + + def post(uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end + + def put(uri, params=T.unsafe(nil), env=T.unsafe(nil), &block); end + + def request(uri, env=T.unsafe(nil), &block); end + + def set_cookie(*args, &block); end +end + +class Rack::Test::Session + extend ::Forwardable +end + +class Rack::Test::UploadedFile + def content_type(); end + + def content_type=(content_type); end + + def initialize(content, content_type=T.unsafe(nil), binary=T.unsafe(nil), original_filename: T.unsafe(nil)); end + + def local_path(); end + + def method_missing(method_name, *args, &block); end + + def original_filename(); end + + def path(); end + + def tempfile(); end +end + +class Rack::Test::UploadedFile + def self.actually_finalize(file); end + + def self.finalize(file); end +end + +module Rack::Test::Utils + include ::Rack::Utils +end + +module Rack::Test::Utils + extend ::Rack::Utils + def self.build_file_part(parameter_name, uploaded_file); end + + def self.build_multipart(params, first=T.unsafe(nil), multipart=T.unsafe(nil)); end + + def self.build_parts(parameters); end + + def self.build_primitive_part(parameter_name, value); end + + def self.get_parts(parameters); end +end + +module Rack::Test + def self.encoding_aware_strings?(); end +end + +class Rack::Tracer + def call(env); end + + def initialize(app, tracer: T.unsafe(nil), on_start_span: T.unsafe(nil), on_finish_span: T.unsafe(nil), trust_incoming_span: T.unsafe(nil), errors: T.unsafe(nil)); end + REQUEST_METHOD = ::T.let(nil, ::T.untyped) + REQUEST_URI = ::T.let(nil, ::T.untyped) +end + +class Rack::Tracer +end + +class Rack::URLMap + def call(env); end + + def initialize(map=T.unsafe(nil)); end + + def remap(map); end +end + +class Rack::URLMap +end + +module Rack::Utils + COMMON_SEP = ::T.let(nil, ::T.untyped) + DEFAULT_SEP = ::T.let(nil, ::T.untyped) + ESCAPE_HTML = ::T.let(nil, ::T.untyped) + ESCAPE_HTML_PATTERN = ::T.let(nil, ::T.untyped) + HTTP_STATUS_CODES = ::T.let(nil, ::T.untyped) + NULL_BYTE = ::T.let(nil, ::T.untyped) + PATH_SEPS = ::T.let(nil, ::T.untyped) + STATUS_WITH_NO_ENTITY_BODY = ::T.let(nil, ::T.untyped) + SYMBOL_TO_STATUS_CODE = ::T.let(nil, ::T.untyped) +end + +class Rack::Utils::Context + def app(); end + + def call(env); end + + def context(env, app=T.unsafe(nil)); end + + def for(); end + + def initialize(app_f, app_r); end + + def recontext(app); end +end + +class Rack::Utils::Context +end + +class Rack::Utils::HeaderHash + def [](k); end + + def []=(k, v); end + + def delete(k); end + + def has_key?(k); end + + def include?(k); end + + def initialize(hash=T.unsafe(nil)); end + + def key?(k); end + + def member?(k); end + + def merge(other); end + + def merge!(other); end + + def names(); end + + def replace(other); end +end + +class Rack::Utils::HeaderHash + def self.[](headers); end +end + +Rack::Utils::InvalidParameterError = Rack::QueryParser::InvalidParameterError + +Rack::Utils::KeySpaceConstrainedParams = Rack::QueryParser::Params + +Rack::Utils::ParameterTypeError = Rack::QueryParser::ParameterTypeError + +module Rack::Utils + def self.add_cookie_to_header(header, key, value); end + + def self.add_remove_cookie_to_header(header, key, value=T.unsafe(nil)); end + + def self.best_q_match(q_value_header, available_mimes); end + + def self.build_nested_query(value, prefix=T.unsafe(nil)); end + + def self.build_query(params); end + + def self.byte_ranges(env, size); end + + def self.clean_path_info(path_info); end + + def self.clock_time(); end + + def self.default_query_parser(); end + + def self.default_query_parser=(default_query_parser); end + + def self.delete_cookie_header!(header, key, value=T.unsafe(nil)); end + + def self.escape(s); end + + def self.escape_html(string); end + + def self.escape_path(s); end + + def self.get_byte_ranges(http_range, size); end + + def self.key_space_limit(); end + + def self.key_space_limit=(v); end + + def self.make_delete_cookie_header(header, key, value); end + + def self.multipart_part_limit(); end + + def self.multipart_part_limit=(multipart_part_limit); end + + def self.param_depth_limit(); end + + def self.param_depth_limit=(v); end + + def self.parse_cookies(env); end + + def self.parse_cookies_header(header); end + + def self.parse_nested_query(qs, d=T.unsafe(nil)); end + + def self.parse_query(qs, d=T.unsafe(nil), &unescaper); end + + def self.q_values(q_value_header); end + + def self.rfc2109(time); end + + def self.rfc2822(time); end + + def self.secure_compare(a, b); end + + def self.select_best_encoding(available_encodings, accept_encoding); end + + def self.set_cookie_header!(header, key, value); end + + def self.status_code(status); end + + def self.unescape(s, encoding=T.unsafe(nil)); end + + def self.unescape_path(s); end + + def self.valid_path?(path); end +end + +module Rack + def self.release(); end + + def self.version(); end +end + +class Rainbow::Color::RGB + def self.to_ansi_domain(value); end +end + +class Rainbow::NullPresenter + def method_missing(method_name, *args); end +end + +class Rainbow::Presenter + def method_missing(method_name, *args); end +end + +class Rainbow::StringUtils + def self.uncolor(string); end +end + +module Rainbow + def self.new(); end +end + +module Rake + EARLY = ::T.let(nil, ::T.untyped) + EMPTY_TASK_ARGS = ::T.let(nil, ::T.untyped) + LATE = ::T.let(nil, ::T.untyped) + VERSION = ::T.let(nil, ::T.untyped) +end + +class Rake::Application + include ::Rake::TaskManager + include ::Rake::TraceOutput + def add_import(fn); end + + def add_loader(ext, loader); end + + def collect_command_line_tasks(args); end + + def default_task_name(); end + + def deprecate(old_usage, new_usage, call_site); end + + def display_cause_details(ex); end + + def display_error_message(ex); end + + def display_exception_backtrace(ex); end + + def display_exception_details(ex); end + + def display_exception_details_seen(); end + + def display_exception_message_details(ex); end + + def display_prerequisites(); end + + def display_tasks_and_comments(); end + + def dynamic_width(); end + + def dynamic_width_stty(); end + + def dynamic_width_tput(); end + + def exit_because_of_exception(ex); end + + def find_rakefile_location(); end + + def handle_options(argv); end + + def has_cause?(ex); end + + def have_rakefile(); end + + def init(app_name=T.unsafe(nil), argv=T.unsafe(nil)); end + + def invoke_task(task_string); end + + def load_imports(); end + + def load_rakefile(); end + + def name(); end + + def options(); end + + def original_dir(); end + + def parse_task_string(string); end + + def print_rakefile_directory(location); end + + def rake_require(file_name, paths=T.unsafe(nil), loaded=T.unsafe(nil)); end + + def rakefile(); end + + def rakefile_location(backtrace=T.unsafe(nil)); end + + def raw_load_rakefile(); end + + def run(argv=T.unsafe(nil)); end + + def run_with_threads(); end + + def set_default_options(); end + + def standard_exception_handling(); end + + def standard_rake_options(); end + + def system_dir(); end + + def terminal_columns(); end + + def terminal_columns=(terminal_columns); end + + def terminal_width(); end + + def thread_pool(); end + + def top_level(); end + + def top_level_tasks(); end + + def trace(*strings); end + + def truncate(string, width); end + + def truncate_output?(); end + + def tty_output=(tty_output); end + + def tty_output?(); end + + def unix?(); end + + def windows?(); end + DEFAULT_RAKEFILES = ::T.let(nil, ::T.untyped) +end + +class Rake::Application +end + +module Rake::Backtrace + SUPPRESSED_PATHS = ::T.let(nil, ::T.untyped) + SUPPRESSED_PATHS_RE = ::T.let(nil, ::T.untyped) + SUPPRESS_PATTERN = ::T.let(nil, ::T.untyped) + SYS_KEYS = ::T.let(nil, ::T.untyped) + SYS_PATHS = ::T.let(nil, ::T.untyped) +end + +module Rake::Backtrace + def self.collapse(backtrace); end +end + +module Rake::Cloneable +end + +module Rake::Cloneable +end + +class Rake::CommandLineOptionError +end + +class Rake::CommandLineOptionError +end + +class Rake::CpuCounter + def count(); end + + def count_with_default(default=T.unsafe(nil)); end +end + +class Rake::CpuCounter + def self.count(); end +end + +module Rake::DSL + include ::Rake::FileUtilsExt + include ::FileUtils + include ::FileUtils::StreamUtils_ +end + +module Rake::DSL +end + +class Rake::DefaultLoader + def load(fn); end +end + +class Rake::DefaultLoader +end + +class Rake::EarlyTime + include ::Comparable + include ::Singleton +end + +class Rake::EarlyTime + extend ::Singleton::SingletonClassMethods + def self.instance(); end +end + +class Rake::FileCreationTask +end + +class Rake::FileCreationTask +end + +class Rake::FileList + include ::Rake::Cloneable + def &(*args, &block); end + + def *(other); end + + def +(*args, &block); end + + def -(*args, &block); end + + def <<(obj); end + + def ==(array); end + + def [](*args, &block); end + + def []=(*args, &block); end + + def add(*filenames); end + + def all?(*args, &block); end + + def any?(*args, &block); end + + def append(*args, &block); end + + def assoc(*args, &block); end + + def at(*args, &block); end + + def bsearch(*args, &block); end + + def bsearch_index(*args, &block); end + + def chain(*args, &block); end + + def chunk(*args, &block); end + + def chunk_while(*args, &block); end + + def clear(*args, &block); end + + def clear_exclude(); end + + def collect(*args, &block); end + + def collect!(*args, &block); end + + def collect_concat(*args, &block); end + + def combination(*args, &block); end + + def compact(*args, &block); end + + def compact!(*args, &block); end + + def concat(*args, &block); end + + def count(*args, &block); end + + def cycle(*args, &block); end + + def delete(*args, &block); end + + def delete_at(*args, &block); end + + def delete_if(*args, &block); end + + def detect(*args, &block); end + + def difference(*args, &block); end + + def dig(*args, &block); end + + def drop(*args, &block); end + + def drop_while(*args, &block); end + + def each(*args, &block); end + + def each_cons(*args, &block); end + + def each_entry(*args, &block); end + + def each_index(*args, &block); end + + def each_slice(*args, &block); end + + def each_with_index(*args, &block); end + + def each_with_object(*args, &block); end + + def egrep(pattern, *options); end + + def empty?(*args, &block); end + + def entries(*args, &block); end + + def exclude(*patterns, &block); end + + def excluded_from_list?(fn); end + + def existing(); end + + def existing!(); end + + def ext(newext=T.unsafe(nil)); end + + def fetch(*args, &block); end + + def fill(*args, &block); end + + def filter(*args, &block); end + + def filter!(*args, &block); end + + def find(*args, &block); end + + def find_all(*args, &block); end + + def find_index(*args, &block); end + + def first(*args, &block); end + + def flat_map(*args, &block); end + + def flatten(*args, &block); end + + def flatten!(*args, &block); end + + def grep(*args, &block); end + + def grep_v(*args, &block); end + + def group_by(*args, &block); end + + def gsub(pat, rep); end + + def gsub!(pat, rep); end + + def import(array); end + + def include(*filenames); end + + def include?(*args, &block); end + + def index(*args, &block); end + + def initialize(*patterns); end + + def inject(*args, &block); end + + def insert(*args, &block); end + + def inspect(*args, &block); end + + def is_a?(klass); end + + def join(*args, &block); end + + def keep_if(*args, &block); end + + def kind_of?(klass); end + + def last(*args, &block); end + + def lazy(*args, &block); end + + def length(*args, &block); end + + def map(*args, &block); end + + def map!(*args, &block); end + + def max(*args, &block); end + + def max_by(*args, &block); end + + def member?(*args, &block); end + + def min(*args, &block); end + + def min_by(*args, &block); end + + def minmax(*args, &block); end + + def minmax_by(*args, &block); end + + def none?(*args, &block); end + + def one?(*args, &block); end + + def pack(*args, &block); end + + def partition(&block); end + + def pathmap(spec=T.unsafe(nil), &block); end + + def permutation(*args, &block); end + + def pop(*args, &block); end + + def prepend(*args, &block); end + + def product(*args, &block); end + + def push(*args, &block); end + + def rassoc(*args, &block); end + + def reduce(*args, &block); end + + def reject(*args, &block); end + + def reject!(*args, &block); end + + def repeated_combination(*args, &block); end + + def repeated_permutation(*args, &block); end + + def replace(*args, &block); end + + def resolve(); end + + def reverse(*args, &block); end + + def reverse!(*args, &block); end + + def reverse_each(*args, &block); end + + def rindex(*args, &block); end + + def rotate(*args, &block); end + + def rotate!(*args, &block); end + + def sample(*args, &block); end + + def select(*args, &block); end + + def select!(*args, &block); end + + def shift(*args, &block); end + + def shuffle(*args, &block); end + + def shuffle!(*args, &block); end + + def size(*args, &block); end + + def slice(*args, &block); end + + def slice!(*args, &block); end + + def slice_after(*args, &block); end + + def slice_before(*args, &block); end + + def slice_when(*args, &block); end + + def sort(*args, &block); end + + def sort!(*args, &block); end + + def sort_by(*args, &block); end + + def sort_by!(*args, &block); end + + def sub(pat, rep); end + + def sub!(pat, rep); end + + def sum(*args, &block); end + + def take(*args, &block); end + + def take_while(*args, &block); end + + def to_a(); end + + def to_ary(); end + + def to_h(*args, &block); end + + def to_set(*args, &block); end + + def transpose(*args, &block); end + + def union(*args, &block); end + + def uniq(*args, &block); end + + def uniq!(*args, &block); end + + def unshift(*args, &block); end + + def values_at(*args, &block); end + + def zip(*args, &block); end + + def |(*args, &block); end + ARRAY_METHODS = ::T.let(nil, ::T.untyped) + DEFAULT_IGNORE_PATTERNS = ::T.let(nil, ::T.untyped) + DEFAULT_IGNORE_PROCS = ::T.let(nil, ::T.untyped) + DELEGATING_METHODS = ::T.let(nil, ::T.untyped) + GLOB_PATTERN = ::T.let(nil, ::T.untyped) + MUST_DEFINE = ::T.let(nil, ::T.untyped) + MUST_NOT_DEFINE = ::T.let(nil, ::T.untyped) + SPECIAL_RETURN = ::T.let(nil, ::T.untyped) +end + +class Rake::FileList + def self.[](*args); end + + def self.glob(pattern, *args); end +end + +class Rake::FileTask +end + +class Rake::FileTask +end + +module Rake::FileUtilsExt + include ::FileUtils + include ::FileUtils::StreamUtils_ + def cd(*args, **options, &block); end + + def chdir(*args, **options, &block); end + + def chmod(*args, **options, &block); end + + def chmod_R(*args, **options, &block); end + + def chown(*args, **options, &block); end + + def chown_R(*args, **options, &block); end + + def copy(*args, **options, &block); end + + def cp(*args, **options, &block); end + + def cp_lr(*args, **options, &block); end + + def cp_r(*args, **options, &block); end + + def install(*args, **options, &block); end + + def link(*args, **options, &block); end + + def ln(*args, **options, &block); end + + def ln_s(*args, **options, &block); end + + def ln_sf(*args, **options, &block); end + + def makedirs(*args, **options, &block); end + + def mkdir(*args, **options, &block); end + + def mkdir_p(*args, **options, &block); end + + def mkpath(*args, **options, &block); end + + def move(*args, **options, &block); end + + def mv(*args, **options, &block); end + + def nowrite(value=T.unsafe(nil)); end + + def rake_check_options(options, *optdecl); end + + def rake_output_message(message); end + + def remove(*args, **options, &block); end + + def rm(*args, **options, &block); end + + def rm_f(*args, **options, &block); end + + def rm_r(*args, **options, &block); end + + def rm_rf(*args, **options, &block); end + + def rmdir(*args, **options, &block); end + + def rmtree(*args, **options, &block); end + + def safe_unlink(*args, **options, &block); end + + def symlink(*args, **options, &block); end + + def touch(*args, **options, &block); end + + def verbose(value=T.unsafe(nil)); end + + def when_writing(msg=T.unsafe(nil)); end + DEFAULT = ::T.let(nil, ::T.untyped) +end + +module Rake::FileUtilsExt + extend ::Rake::FileUtilsExt + extend ::FileUtils + extend ::FileUtils::StreamUtils_ + def self.nowrite_flag(); end + + def self.nowrite_flag=(nowrite_flag); end + + def self.verbose_flag(); end + + def self.verbose_flag=(verbose_flag); end +end + +class Rake::InvocationChain + def append(invocation); end + + def member?(invocation); end + EMPTY = ::T.let(nil, ::T.untyped) +end + +class Rake::InvocationChain::EmptyInvocationChain + def append(invocation); end + + def member?(obj); end +end + +class Rake::InvocationChain::EmptyInvocationChain +end + +class Rake::InvocationChain + def self.append(invocation, chain); end +end + +module Rake::InvocationExceptionMixin + def chain(); end + + def chain=(value); end +end + +module Rake::InvocationExceptionMixin +end + +class Rake::LateTime + include ::Comparable + include ::Singleton +end + +class Rake::LateTime + extend ::Singleton::SingletonClassMethods + def self.instance(); end +end + +class Rake::LinkedList + include ::Enumerable + def ==(other); end + + def conj(item); end + + def each(&blk); end + + def empty?(); end + + def head(); end + + def initialize(head, tail=T.unsafe(nil)); end + + def tail(); end + EMPTY = ::T.let(nil, ::T.untyped) +end + +class Rake::LinkedList::EmptyLinkedList + def initialize(); end +end + +class Rake::LinkedList::EmptyLinkedList +end + +class Rake::LinkedList + def self.cons(head, tail); end + + def self.empty(); end + + def self.make(*args); end +end + +class Rake::MultiTask +end + +class Rake::MultiTask +end + +class Rake::NameSpace + def [](name); end + + def initialize(task_manager, scope_list); end + + def scope(); end + + def tasks(); end +end + +class Rake::NameSpace +end + +module Rake::PrivateReader +end + +module Rake::PrivateReader::ClassMethods + def private_reader(*names); end +end + +module Rake::PrivateReader::ClassMethods +end + +module Rake::PrivateReader + def self.included(base); end +end + +class Rake::Promise + def initialize(args, &block); end + + def recorder(); end + + def recorder=(recorder); end + + def value(); end + + def work(); end + NOT_SET = ::T.let(nil, ::T.untyped) +end + +class Rake::Promise +end + +class Rake::PseudoStatus + def >>(n); end + + def exited?(); end + + def exitstatus(); end + + def initialize(code=T.unsafe(nil)); end + + def stopped?(); end + + def to_i(); end +end + +class Rake::PseudoStatus +end + +class Rake::RuleRecursionOverflowError + def add_target(target); end + + def initialize(*args); end +end + +class Rake::RuleRecursionOverflowError +end + +class Rake::Scope + def path(); end + + def path_with_task_name(task_name); end + + def trim(n); end + EMPTY = ::T.let(nil, ::T.untyped) +end + +class Rake::Scope::EmptyScope + def path(); end + + def path_with_task_name(task_name); end +end + +class Rake::Scope::EmptyScope +end + +class Rake::Scope +end + +class Rake::Task + def actions(); end + + def add_description(description); end + + def all_prerequisite_tasks(); end + + def already_invoked(); end + + def application(); end + + def application=(application); end + + def arg_description(); end + + def arg_names(); end + + def clear(); end + + def clear_actions(); end + + def clear_args(); end + + def clear_comments(); end + + def clear_prerequisites(); end + + def collect_prerequisites(seen); end + + def comment(); end + + def comment=(comment); end + + def enhance(deps=T.unsafe(nil), &block); end + + def execute(args=T.unsafe(nil)); end + + def full_comment(); end + + def initialize(task_name, app); end + + def investigation(); end + + def invoke(*args); end + + def invoke_prerequisites(task_args, invocation_chain); end + + def invoke_prerequisites_concurrently(task_args, invocation_chain); end + + def invoke_with_call_chain(task_args, invocation_chain); end + + def locations(); end + + def name(); end + + def name_with_args(); end + + def needed?(); end + + def order_only_prerequisites(); end + + def prereqs(); end + + def prerequisite_tasks(); end + + def prerequisites(); end + + def reenable(); end + + def scope(); end + + def set_arg_names(args); end + + def source(); end + + def sources(); end + + def sources=(sources); end + + def timestamp(); end + + def |(deps); end +end + +class Rake::Task + def self.[](task_name); end + + def self.clear(); end + + def self.create_rule(*args, &block); end + + def self.define_task(*args, &block); end + + def self.format_deps(deps); end + + def self.scope_name(scope, task_name); end + + def self.task_defined?(task_name); end + + def self.tasks(); end +end + +class Rake::TaskArgumentError +end + +class Rake::TaskArgumentError +end + +class Rake::TaskArguments + include ::Enumerable + def [](index); end + + def each(&block); end + + def extras(); end + + def fetch(*args, &block); end + + def has_key?(key); end + + def initialize(names, values, parent=T.unsafe(nil)); end + + def key?(key); end + + def lookup(name); end + + def method_missing(sym, *args); end + + def names(); end + + def new_scope(names); end + + def to_a(); end + + def to_hash(); end + + def values_at(*keys); end + + def with_defaults(defaults); end +end + +class Rake::TaskArguments +end + +module Rake::TaskManager + def [](task_name, scopes=T.unsafe(nil)); end + + def clear(); end + + def create_rule(*args, &block); end + + def current_scope(); end + + def define_task(task_class, *args, &block); end + + def enhance_with_matching_rule(task_name, level=T.unsafe(nil)); end + + def generate_did_you_mean_suggestions(task_name); end + + def generate_message_for_undefined_task(task_name); end + + def in_namespace(name); end + + def initialize(); end + + def intern(task_class, task_name); end + + def last_description(); end + + def last_description=(last_description); end + + def lookup(task_name, initial_scope=T.unsafe(nil)); end + + def resolve_args(args); end + + def synthesize_file_task(task_name); end + + def tasks(); end + + def tasks_in_scope(scope); end +end + +module Rake::TaskManager + def self.record_task_metadata(); end + + def self.record_task_metadata=(record_task_metadata); end +end + +class Rake::ThreadHistoryDisplay + include ::Rake::PrivateReader + def initialize(stats); end + + def show(); end +end + +class Rake::ThreadHistoryDisplay + extend ::Rake::PrivateReader::ClassMethods +end + +class Rake::ThreadPool + def future(*args, &block); end + + def gather_history(); end + + def history(); end + + def initialize(thread_count); end + + def join(); end + + def statistics(); end +end + +class Rake::ThreadPool +end + +module Rake::TraceOutput + def trace_on(out, *strings); end +end + +module Rake::TraceOutput +end + +module Rake::Version + BUILD = ::T.let(nil, ::T.untyped) + MAJOR = ::T.let(nil, ::T.untyped) + MINOR = ::T.let(nil, ::T.untyped) + NUMBERS = ::T.let(nil, ::T.untyped) + OTHER = ::T.let(nil, ::T.untyped) +end + +module Rake::Version +end + +module Rake::Win32 +end + +class Rake::Win32::Win32HomeError +end + +class Rake::Win32::Win32HomeError +end + +module Rake::Win32 + def self.normalize(path); end + + def self.win32_system_dir(); end + + def self.windows?(); end +end + +module Rake + extend ::Rake::FileUtilsExt + extend ::FileUtils + extend ::FileUtils::StreamUtils_ + def self.add_rakelib(*files); end + + def self.application(); end + + def self.application=(app); end + + def self.each_dir_parent(dir); end + + def self.from_pathname(path); end + + def self.load_rakefile(path); end + + def self.original_dir(); end + + def self.suggested_thread_count(); end + + def self.with_application(block_application=T.unsafe(nil)); end +end + +RakeFileUtils = Rake::FileUtilsExt + +module Random::Formatter + def alphanumeric(n=T.unsafe(nil)); end + + ALPHANUMERIC = ::T.let(nil, ::T.untyped) +end + +class Random + def self.bytes(_); end + + def self.urandom(_); end +end + +class Range + def %(_); end + + def entries(); end + + def to_a(); end +end + +module RbConfig + def self.expand(val, config=T.unsafe(nil)); end + + def self.fire_update!(key, val, mkconf=T.unsafe(nil), conf=T.unsafe(nil)); end + + def self.ruby(); end +end + +class RedBlackTree + include ::Enumerable + def [](key); end + + def []=(key, value); end + + def clear(); end + + def default(); end + + def default=(default); end + + def default_proc(); end + + def delete(key); end + + def dump_sexp(); end + + def dump_tree(io=T.unsafe(nil)); end + + def each(&block); end + + def each_key(); end + + def each_pair(&block); end + + def each_value(); end + + def empty?(); end + + def has_key?(key); end + + def initialize(default=T.unsafe(nil), &block); end + + def insert(key, value); end + + def key?(key); end + + def keys(); end + + def length(); end + + def root(); end + + def size(); end + + def to_hash(); end + + def values(); end + DEFAULT = ::T.let(nil, ::T.untyped) +end + +class RedBlackTree::Node + def balanced_rotate_left(); end + + def balanced_rotate_right(); end + + def black?(); end + + def check_height(); end + + def children_color?(color); end + + def color(); end + + def color=(color); end + + def color_flip(other); end + + def delete(key); end + + def delete_min(); end + + def dump_sexp(); end + + def dump_tree(io, indent=T.unsafe(nil)); end + + def each(&block); end + + def each_key(); end + + def each_value(); end + + def empty?(); end + + def initialize(key, value, left, right, color=T.unsafe(nil)); end + + def insert(key, value); end + + def key(); end + + def keys(); end + + def left(); end + + def left=(left); end + + def pullup_red(); end + + def rebalance_for_left_delete(); end + + def rebalance_for_right_delete(); end + + def red?(); end + + def retrieve(key); end + + def right(); end + + def right=(right); end + + def rotate_left(); end + + def rotate_right(); end + + def set_root(); end + + def size(); end + + def value(); end + + def values(); end + EMPTY = ::T.let(nil, ::T.untyped) + UNDEFINED = ::T.let(nil, ::T.untyped) +end + +class RedBlackTree::Node::EmptyNode + def initialize(); end +end + +class RedBlackTree::Node::EmptyNode +end + +class RedBlackTree::Node +end + +class RedBlackTree +end + +class Resolv::DNS + def extract_resources(msg, name, typeclass); end + + def fetch_resource(name, typeclass); end + + def lazy_initialize(); end + + def make_tcp_requester(host, port); end + + def make_udp_requester(); end + RequestID = ::T.let(nil, ::T.untyped) + RequestIDMutex = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Config + def generate_candidates(name); end + + def generate_timeouts(); end + + def initialize(config_info=T.unsafe(nil)); end + + def lazy_initialize(); end + + def nameserver_port(); end + + def resolv(name); end + + def single?(); end + + def timeouts=(values); end + InitialTimeout = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Config::NXDomain +end + +class Resolv::DNS::Config::NXDomain +end + +class Resolv::DNS::Config::OtherResolvError +end + +class Resolv::DNS::Config::OtherResolvError +end + +class Resolv::DNS::Config + def self.default_config_hash(filename=T.unsafe(nil)); end + + def self.parse_resolv_conf(filename); end +end + +module Resolv::DNS::Label +end + +class Resolv::DNS::Label::Str + def ==(other); end + + def downcase(); end + + def eql?(other); end + + def initialize(string); end + + def string(); end +end + +class Resolv::DNS::Label::Str +end + +module Resolv::DNS::Label + def self.split(arg); end +end + +class Resolv::DNS::Message + def ==(other); end + + def aa(); end + + def aa=(aa); end + + def add_additional(name, ttl, data); end + + def add_answer(name, ttl, data); end + + def add_authority(name, ttl, data); end + + def add_question(name, typeclass); end + + def additional(); end + + def answer(); end + + def authority(); end + + def each_additional(); end + + def each_answer(); end + + def each_authority(); end + + def each_question(); end + + def each_resource(); end + + def encode(); end + + def id(); end + + def id=(id); end + + def initialize(id=T.unsafe(nil)); end + + def opcode(); end + + def opcode=(opcode); end + + def qr(); end + + def qr=(qr); end + + def question(); end + + def ra(); end + + def ra=(ra); end + + def rcode(); end + + def rcode=(rcode); end + + def rd(); end + + def rd=(rd); end + + def tc(); end + + def tc=(tc); end +end + +class Resolv::DNS::Message::MessageDecoder + def get_bytes(len=T.unsafe(nil)); end + + def get_label(); end + + def get_labels(); end + + def get_length16(); end + + def get_name(); end + + def get_question(); end + + def get_rr(); end + + def get_string(); end + + def get_string_list(); end + + def get_unpack(template); end + + def initialize(data); end +end + +class Resolv::DNS::Message::MessageDecoder +end + +class Resolv::DNS::Message::MessageEncoder + def put_bytes(d); end + + def put_label(d); end + + def put_labels(d); end + + def put_length16(); end + + def put_name(d); end + + def put_pack(template, *d); end + + def put_string(d); end + + def put_string_list(ds); end +end + +class Resolv::DNS::Message::MessageEncoder +end + +class Resolv::DNS::Message + def self.decode(m); end +end + +class Resolv::DNS::Name + def ==(other); end + + def [](i); end + + def eql?(other); end + + def length(); end + + def to_a(); end +end + +module Resolv::DNS::OpCode + IQuery = ::T.let(nil, ::T.untyped) + Notify = ::T.let(nil, ::T.untyped) + Query = ::T.let(nil, ::T.untyped) + Status = ::T.let(nil, ::T.untyped) + Update = ::T.let(nil, ::T.untyped) +end + +module Resolv::DNS::OpCode +end + +class Resolv::DNS::Query + def encode_rdata(msg); end +end + +class Resolv::DNS::Query + def self.decode_rdata(msg); end +end + +module Resolv::DNS::RCode + BADALG = ::T.let(nil, ::T.untyped) + BADKEY = ::T.let(nil, ::T.untyped) + BADMODE = ::T.let(nil, ::T.untyped) + BADNAME = ::T.let(nil, ::T.untyped) + BADSIG = ::T.let(nil, ::T.untyped) + BADTIME = ::T.let(nil, ::T.untyped) + BADVERS = ::T.let(nil, ::T.untyped) + FormErr = ::T.let(nil, ::T.untyped) + NXDomain = ::T.let(nil, ::T.untyped) + NXRRSet = ::T.let(nil, ::T.untyped) + NoError = ::T.let(nil, ::T.untyped) + NotAuth = ::T.let(nil, ::T.untyped) + NotImp = ::T.let(nil, ::T.untyped) + NotZone = ::T.let(nil, ::T.untyped) + Refused = ::T.let(nil, ::T.untyped) + ServFail = ::T.let(nil, ::T.untyped) + YXDomain = ::T.let(nil, ::T.untyped) + YXRRSet = ::T.let(nil, ::T.untyped) +end + +module Resolv::DNS::RCode +end + +class Resolv::DNS::Requester + def close(); end + + def request(sender, tout); end + + def sender_for(addr, msg); end +end + +class Resolv::DNS::Requester::ConnectedUDP + def initialize(host, port=T.unsafe(nil)); end + + def lazy_initialize(); end + + def recv_reply(readable_socks); end + + def sender(msg, data, host=T.unsafe(nil), port=T.unsafe(nil)); end +end + +class Resolv::DNS::Requester::ConnectedUDP::Sender + def data(); end + + def send(); end +end + +class Resolv::DNS::Requester::ConnectedUDP::Sender +end + +class Resolv::DNS::Requester::ConnectedUDP +end + +class Resolv::DNS::Requester::MDNSOneShot +end + +class Resolv::DNS::Requester::MDNSOneShot +end + +class Resolv::DNS::Requester::RequestError +end + +class Resolv::DNS::Requester::RequestError +end + +class Resolv::DNS::Requester::Sender + def initialize(msg, data, sock); end +end + +class Resolv::DNS::Requester::Sender +end + +class Resolv::DNS::Requester::TCP + def initialize(host, port=T.unsafe(nil)); end + + def recv_reply(readable_socks); end + + def sender(msg, data, host=T.unsafe(nil), port=T.unsafe(nil)); end +end + +class Resolv::DNS::Requester::TCP::Sender + def data(); end + + def send(); end +end + +class Resolv::DNS::Requester::TCP::Sender +end + +class Resolv::DNS::Requester::TCP +end + +class Resolv::DNS::Requester::UnconnectedUDP + def initialize(*nameserver_port); end + + def lazy_initialize(); end + + def recv_reply(readable_socks); end + + def sender(msg, data, host, port=T.unsafe(nil)); end +end + +class Resolv::DNS::Requester::UnconnectedUDP::Sender + def data(); end + + def initialize(msg, data, sock, host, port); end + + def send(); end +end + +class Resolv::DNS::Requester::UnconnectedUDP::Sender +end + +class Resolv::DNS::Requester::UnconnectedUDP +end + +class Resolv::DNS::Requester +end + +class Resolv::DNS::Resource + def ==(other); end + + def eql?(other); end + ClassHash = ::T.let(nil, ::T.untyped) + ClassInsensitiveTypes = ::T.let(nil, ::T.untyped) + ClassValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::ANY + TypeValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::CNAME + TypeValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::Generic + def self.create(type_value, class_value); end +end + +class Resolv::DNS::Resource::HINFO + TypeValue = ::T.let(nil, ::T.untyped) +end + +module Resolv::DNS::Resource::IN + ClassValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::IN::A + ClassValue = ::T.let(nil, ::T.untyped) + TypeValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::IN::AAAA + ClassValue = ::T.let(nil, ::T.untyped) + TypeValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::IN::ANY + ClassValue = ::T.let(nil, ::T.untyped) + TypeValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::IN::ANY +end + +class Resolv::DNS::Resource::IN::CNAME + ClassValue = ::T.let(nil, ::T.untyped) + TypeValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::IN::CNAME +end + +class Resolv::DNS::Resource::IN::HINFO + ClassValue = ::T.let(nil, ::T.untyped) + TypeValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::IN::HINFO +end + +class Resolv::DNS::Resource::IN::LOC + ClassValue = ::T.let(nil, ::T.untyped) + TypeValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::IN::LOC +end + +class Resolv::DNS::Resource::IN::MINFO + ClassValue = ::T.let(nil, ::T.untyped) + TypeValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::IN::MINFO +end + +class Resolv::DNS::Resource::IN::MX + ClassValue = ::T.let(nil, ::T.untyped) + TypeValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::IN::MX +end + +class Resolv::DNS::Resource::IN::NS + ClassValue = ::T.let(nil, ::T.untyped) + TypeValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::IN::NS +end + +class Resolv::DNS::Resource::IN::PTR + ClassValue = ::T.let(nil, ::T.untyped) + TypeValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::IN::PTR +end + +class Resolv::DNS::Resource::IN::SOA + ClassValue = ::T.let(nil, ::T.untyped) + TypeValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::IN::SOA +end + +class Resolv::DNS::Resource::IN::SRV + ClassValue = ::T.let(nil, ::T.untyped) + TypeValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::IN::TXT + ClassValue = ::T.let(nil, ::T.untyped) + TypeValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::IN::TXT +end + +class Resolv::DNS::Resource::IN::WKS + ClassValue = ::T.let(nil, ::T.untyped) + TypeValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::LOC + TypeValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::MINFO + TypeValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::MX + TypeValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::NS + TypeValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::PTR + TypeValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::SOA + TypeValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource::TXT + TypeValue = ::T.let(nil, ::T.untyped) +end + +class Resolv::DNS::Resource + def self.get_class(type_value, class_value); end +end + +class Resolv::DNS + def self.allocate_request_id(host, port); end + + def self.bind_random_port(udpsock, bind_host=T.unsafe(nil)); end + + def self.free_request_id(host, port, id); end + + def self.random(arg); end +end + +class Resolv::Hosts + def lazy_initialize(); end +end + +class Resolv::IPv4 + def ==(other); end + + def eql?(other); end +end + +class Resolv::IPv6 + def ==(other); end + + def eql?(other); end +end + +class Resolv::LOC::Alt + def ==(other); end + + def eql?(other); end +end + +class Resolv::LOC::Coord + def ==(other); end + + def eql?(other); end +end + +class Resolv::LOC::Size + def ==(other); end + + def eql?(other); end +end + +module RuboCop +end + +module RuboCop::AST +end + +class RuboCop::AST::AliasNode + def new_identifier(); end + + def old_identifier(); end +end + +class RuboCop::AST::AliasNode +end + +class RuboCop::AST::AndNode + include ::RuboCop::AST::BinaryOperatorNode + include ::RuboCop::AST::PredicateOperatorNode + def alternate_operator(); end + + def inverse_operator(); end +end + +class RuboCop::AST::AndNode +end + +class RuboCop::AST::ArgsNode + include ::RuboCop::AST::CollectionNode + def empty_and_without_delimiters?(); end +end + +class RuboCop::AST::ArgsNode +end + +class RuboCop::AST::ArrayNode + def bracketed?(); end + + def percent_literal?(type=T.unsafe(nil)); end + + def square_brackets?(); end + + def values(); end + PERCENT_LITERAL_TYPES = ::T.let(nil, ::T.untyped) +end + +class RuboCop::AST::ArrayNode +end + +module RuboCop::AST::BasicLiteralNode + def value(); end +end + +module RuboCop::AST::BasicLiteralNode +end + +module RuboCop::AST::BinaryOperatorNode + def conditions(); end + + def lhs(); end + + def rhs(); end +end + +module RuboCop::AST::BinaryOperatorNode +end + +class RuboCop::AST::BlockNode + include ::RuboCop::AST::MethodIdentifierPredicates + def arguments(); end + + def arguments?(); end + + def body(); end + + def braces?(); end + + def closing_delimiter(); end + + def delimiters(); end + + def keywords?(); end + + def lambda?(); end + + def method_name(); end + + def opening_delimiter(); end + + def send_node(); end + + def void_context?(); end + VOID_CONTEXT_METHODS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::AST::BlockNode +end + +class RuboCop::AST::BreakNode + include ::RuboCop::AST::MethodDispatchNode + include ::RuboCop::AST::MethodIdentifierPredicates + include ::RuboCop::AST::ParameterizedNode +end + +class RuboCop::AST::BreakNode +end + +class RuboCop::AST::Builder + NODE_MAP = ::T.let(nil, ::T.untyped) +end + +class RuboCop::AST::Builder +end + +class RuboCop::AST::CaseNode + include ::RuboCop::AST::ConditionalNode + def each_when(); end + + def else?(); end + + def else_branch(); end + + def keyword(); end + + def when_branches(); end +end + +class RuboCop::AST::CaseNode +end + +class RuboCop::AST::ClassNode + def body(); end + + def identifier(); end + + def parent_class(); end +end + +class RuboCop::AST::ClassNode +end + +module RuboCop::AST::CollectionNode + def &(*args, &block); end + + def *(*args, &block); end + + def +(*args, &block); end + + def -(*args, &block); end + + def <<(*args, &block); end + + def [](*args, &block); end + + def []=(*args, &block); end + + def all?(*args, &block); end + + def any?(*args, &block); end + + def append(*args, &block); end + + def assoc(*args, &block); end + + def at(*args, &block); end + + def bsearch(*args, &block); end + + def bsearch_index(*args, &block); end + + def chain(*args, &block); end + + def chunk(*args, &block); end + + def chunk_while(*args, &block); end + + def clear(*args, &block); end + + def collect(*args, &block); end + + def collect!(*args, &block); end + + def collect_concat(*args, &block); end + + def combination(*args, &block); end + + def compact(*args, &block); end + + def compact!(*args, &block); end + + def concat(*args, &block); end + + def count(*args, &block); end + + def cycle(*args, &block); end + + def delete(*args, &block); end + + def delete_at(*args, &block); end + + def delete_if(*args, &block); end + + def detect(*args, &block); end + + def difference(*args, &block); end + + def dig(*args, &block); end + + def drop(*args, &block); end + + def drop_while(*args, &block); end + + def each(*args, &block); end + + def each_cons(*args, &block); end + + def each_entry(*args, &block); end + + def each_index(*args, &block); end + + def each_slice(*args, &block); end + + def each_with_index(*args, &block); end + + def each_with_object(*args, &block); end + + def empty?(*args, &block); end + + def entries(*args, &block); end + + def fetch(*args, &block); end + + def fill(*args, &block); end + + def filter(*args, &block); end + + def filter!(*args, &block); end + + def find(*args, &block); end + + def find_all(*args, &block); end + + def find_index(*args, &block); end + + def first(*args, &block); end + + def flat_map(*args, &block); end + + def flatten(*args, &block); end + + def flatten!(*args, &block); end + + def grep(*args, &block); end + + def grep_v(*args, &block); end + + def group_by(*args, &block); end + + def include?(*args, &block); end + + def index(*args, &block); end + + def inject(*args, &block); end + + def insert(*args, &block); end + + def join(*args, &block); end + + def keep_if(*args, &block); end + + def last(*args, &block); end + + def lazy(*args, &block); end + + def length(*args, &block); end + + def map(*args, &block); end + + def map!(*args, &block); end + + def max(*args, &block); end + + def max_by(*args, &block); end + + def member?(*args, &block); end + + def min(*args, &block); end + + def min_by(*args, &block); end + + def minmax(*args, &block); end + + def minmax_by(*args, &block); end + + def none?(*args, &block); end + + def one?(*args, &block); end + + def pack(*args, &block); end + + def partition(*args, &block); end + + def permutation(*args, &block); end + + def pop(*args, &block); end + + def prepend(*args, &block); end + + def product(*args, &block); end + + def push(*args, &block); end + + def rassoc(*args, &block); end + + def reduce(*args, &block); end + + def reject(*args, &block); end + + def reject!(*args, &block); end + + def repeated_combination(*args, &block); end + + def repeated_permutation(*args, &block); end + + def replace(*args, &block); end + + def reverse(*args, &block); end + + def reverse!(*args, &block); end + + def reverse_each(*args, &block); end + + def rindex(*args, &block); end + + def rotate(*args, &block); end + + def rotate!(*args, &block); end + + def sample(*args, &block); end + + def select(*args, &block); end + + def select!(*args, &block); end + + def shelljoin(*args, &block); end + + def shift(*args, &block); end + + def shuffle(*args, &block); end + + def shuffle!(*args, &block); end + + def size(*args, &block); end + + def slice(*args, &block); end + + def slice!(*args, &block); end + + def slice_after(*args, &block); end + + def slice_before(*args, &block); end + + def slice_when(*args, &block); end + + def sort(*args, &block); end + + def sort!(*args, &block); end + + def sort_by(*args, &block); end + + def sort_by!(*args, &block); end + + def sum(*args, &block); end + + def take(*args, &block); end + + def take_while(*args, &block); end + + def to_ary(*args, &block); end + + def to_h(*args, &block); end + + def to_set(*args, &block); end + + def transpose(*args, &block); end + + def union(*args, &block); end + + def uniq(*args, &block); end + + def uniq!(*args, &block); end + + def unshift(*args, &block); end + + def values_at(*args, &block); end + + def zip(*args, &block); end + + def |(*args, &block); end + ARRAY_METHODS = ::T.let(nil, ::T.untyped) +end + +module RuboCop::AST::CollectionNode + extend ::Forwardable +end + +module RuboCop::AST::ConditionalNode + def body(); end + + def condition(); end + + def multiline_condition?(); end + + def single_line_condition?(); end +end + +module RuboCop::AST::ConditionalNode +end + +class RuboCop::AST::DefNode + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::MethodIdentifierPredicates + def argument_forwarding?(); end + + def arguments(); end + + def body(); end + + def method_name(); end + + def receiver(); end + + def void_context?(); end +end + +class RuboCop::AST::DefNode +end + +class RuboCop::AST::DefinedNode + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::MethodDispatchNode + include ::RuboCop::AST::MethodIdentifierPredicates +end + +class RuboCop::AST::DefinedNode +end + +class RuboCop::AST::EnsureNode + def body(); end +end + +class RuboCop::AST::EnsureNode +end + +class RuboCop::AST::FloatNode + include ::RuboCop::AST::NumericNode +end + +class RuboCop::AST::FloatNode +end + +class RuboCop::AST::ForNode + def body(); end + + def collection(); end + + def do?(); end + + def keyword(); end + + def variable(); end + + def void_context?(); end +end + +class RuboCop::AST::ForNode +end + +class RuboCop::AST::ForwardArgsNode + include ::RuboCop::AST::CollectionNode +end + +class RuboCop::AST::ForwardArgsNode +end + +module RuboCop::AST::HashElementNode + def delimiter_delta(other); end + + def key(); end + + def key_delta(other, alignment=T.unsafe(nil)); end + + def same_line?(other); end + + def value(); end + + def value_delta(other); end +end + +module RuboCop::AST::HashElementNode +end + +class RuboCop::AST::HashNode + def braces?(); end + + def each_key(); end + + def each_pair(); end + + def each_value(); end + + def empty?(); end + + def keys(); end + + def mixed_delimiters?(); end + + def pairs(); end + + def pairs_on_same_line?(); end + + def values(); end +end + +class RuboCop::AST::HashNode +end + +class RuboCop::AST::IfNode + include ::RuboCop::AST::ConditionalNode + include ::RuboCop::AST::ModifierNode + def branches(); end + + def each_branch(); end + + def else?(); end + + def else_branch(); end + + def elsif?(); end + + def elsif_conditional?(); end + + def if?(); end + + def if_branch(); end + + def inverse_keyword(); end + + def keyword(); end + + def nested_conditional?(); end + + def ternary?(); end + + def unless?(); end +end + +class RuboCop::AST::IfNode +end + +class RuboCop::AST::IntNode + include ::RuboCop::AST::NumericNode +end + +class RuboCop::AST::IntNode +end + +class RuboCop::AST::KeywordSplatNode + include ::RuboCop::AST::HashElementNode + def colon?(); end + + def hash_rocket?(); end + + def operator(); end + DOUBLE_SPLAT = ::T.let(nil, ::T.untyped) +end + +class RuboCop::AST::KeywordSplatNode +end + +module RuboCop::AST::MethodDispatchNode + include ::RuboCop::AST::MethodIdentifierPredicates + def access_modifier?(); end + + def adjacent_def_modifier?(node=T.unsafe(nil)); end + + def arguments(); end + + def arithmetic_operation?(); end + + def assignment?(); end + + def bare_access_modifier?(); end + + def bare_access_modifier_declaration?(node=T.unsafe(nil)); end + + def binary_operation?(); end + + def block_literal?(); end + + def block_node(); end + + def command?(name); end + + def const_receiver?(); end + + def def_modifier?(); end + + def dot?(); end + + def double_colon?(); end + + def implicit_call?(); end + + def lambda?(); end + + def lambda_literal?(); end + + def macro?(); end + + def macro_scope?(node=T.unsafe(nil)); end + + def method_name(); end + + def non_bare_access_modifier?(); end + + def non_bare_access_modifier_declaration?(node=T.unsafe(nil)); end + + def receiver(); end + + def self_receiver?(); end + + def setter_method?(); end + + def special_modifier?(); end + + def unary_operation?(); end + ARITHMETIC_OPERATORS = ::T.let(nil, ::T.untyped) + SPECIAL_MODIFIERS = ::T.let(nil, ::T.untyped) +end + +module RuboCop::AST::MethodDispatchNode + extend ::RuboCop::NodePattern::Macros +end + +module RuboCop::AST::MethodIdentifierPredicates + def assignment_method?(); end + + def bang_method?(); end + + def camel_case_method?(); end + + def comparison_method?(); end + + def const_receiver?(); end + + def enumerator_method?(); end + + def method?(name); end + + def negation_method?(); end + + def operator_method?(); end + + def predicate_method?(); end + + def prefix_bang?(); end + + def prefix_not?(); end + + def self_receiver?(); end + ENUMERATOR_METHODS = ::T.let(nil, ::T.untyped) + OPERATOR_METHODS = ::T.let(nil, ::T.untyped) +end + +module RuboCop::AST::MethodIdentifierPredicates +end + +module RuboCop::AST::ModifierNode + def modifier_form?(); end +end + +module RuboCop::AST::ModifierNode +end + +class RuboCop::AST::ModuleNode + def body(); end + + def identifier(); end +end + +class RuboCop::AST::ModuleNode +end + +class RuboCop::AST::Node + include ::RuboCop::AST::Sexp + def __ENCODING___type?(); end + + def __FILE___type?(); end + + def __LINE___type?(); end + + def alias_type?(); end + + def ancestors(); end + + def and_asgn_type?(); end + + def and_type?(); end + + def arg_expr_type?(); end + + def arg_type?(); end + + def args_type?(); end + + def argument?(); end + + def array_pattern_type?(); end + + def array_pattern_with_tail_type?(); end + + def array_type?(); end + + def assignment?(); end + + def assignment_or_similar?(node=T.unsafe(nil)); end + + def back_ref_type?(); end + + def basic_conditional?(); end + + def basic_literal?(); end + + def begin_type?(); end + + def block_pass_type?(); end + + def block_type?(); end + + def blockarg_expr_type?(); end + + def blockarg_type?(); end + + def boolean_type?(); end + + def break_type?(); end + + def call_type?(); end + + def case_match_type?(); end + + def case_type?(); end + + def casgn_type?(); end + + def cbase_type?(); end + + def chained?(); end + + def child_nodes(); end + + def class_constructor?(node=T.unsafe(nil)); end + + def class_type?(); end + + def complete!(); end + + def complete?(); end + + def complex_type?(); end + + def conditional?(); end + + def const_name(); end + + def const_pattern_type?(); end + + def const_type?(); end + + def csend_type?(); end + + def cvar_type?(); end + + def cvasgn_type?(); end + + def def_type?(); end + + def defined_module(); end + + def defined_module_name(); end + + def defined_type?(); end + + def defs_type?(); end + + def descendants(); end + + def dstr_type?(); end + + def dsym_type?(); end + + def each_ancestor(*types, &block); end + + def each_child_node(*types); end + + def each_descendant(*types, &block); end + + def each_node(*types, &block); end + + def eflipflop_type?(); end + + def empty_else_type?(); end + + def empty_source?(); end + + def ensure_type?(); end + + def equals_asgn?(); end + + def erange_type?(); end + + def false_type?(); end + + def falsey_literal?(); end + + def first_line(); end + + def float_type?(); end + + def for_type?(); end + + def forward_args_type?(); end + + def forwarded_args_type?(); end + + def guard_clause?(node=T.unsafe(nil)); end + + def gvar_type?(); end + + def gvasgn_type?(); end + + def hash_pattern_type?(); end + + def hash_type?(); end + + def ident_type?(); end + + def if_guard_type?(); end + + def if_type?(); end + + def iflipflop_type?(); end + + def immutable_literal?(); end + + def in_match_type?(); end + + def in_pattern_type?(); end + + def index_type?(); end + + def indexasgn_type?(); end + + def int_type?(); end + + def irange_type?(); end + + def ivar_type?(); end + + def ivasgn_type?(); end + + def keyword?(); end + + def kwarg_type?(); end + + def kwbegin_type?(); end + + def kwnilarg_type?(); end + + def kwoptarg_type?(); end + + def kwrestarg_type?(); end + + def kwsplat_type?(); end + + def lambda?(node=T.unsafe(nil)); end + + def lambda_or_proc?(node=T.unsafe(nil)); end + + def lambda_type?(); end + + def last_line(); end + + def line_count(); end + + def literal?(); end + + def lvar_type?(); end + + def lvasgn_type?(); end + + def masgn_type?(); end + + def match_alt_type?(); end + + def match_as_type?(); end + + def match_current_line_type?(); end + + def match_nil_pattern_type?(); end + + def match_rest_type?(); end + + def match_var_type?(); end + + def match_with_lvasgn_type?(); end + + def match_with_trailing_comma_type?(); end + + def mlhs_type?(); end + + def module_type?(); end + + def multiline?(); end + + def mutable_literal?(); end + + def new_class_or_module_block?(node=T.unsafe(nil)); end + + def next_type?(); end + + def nil_type?(); end + + def node_parts(); end + + def nonempty_line_count(); end + + def not_type?(); end + + def nth_ref_type?(); end + + def numargs_type?(); end + + def numblock_type?(); end + + def numeric_type?(); end + + def objc_kwarg_type?(); end + + def objc_restarg_type?(); end + + def objc_varargs_type?(); end + + def op_asgn_type?(); end + + def operator_keyword?(); end + + def optarg_type?(); end + + def or_asgn_type?(); end + + def or_type?(); end + + def pair_type?(); end + + def parent(); end + + def parent=(node); end + + def parent_module_name(); end + + def parenthesized_call?(); end + + def pin_type?(); end + + def postexe_type?(); end + + def preexe_type?(); end + + def proc?(node=T.unsafe(nil)); end + + def procarg0_type?(); end + + def pure?(); end + + def range_type?(); end + + def rational_type?(); end + + def receiver(node=T.unsafe(nil)); end + + def recursive_basic_literal?(); end + + def recursive_literal?(); end + + def redo_type?(); end + + def reference?(); end + + def regexp_type?(); end + + def regopt_type?(); end + + def resbody_type?(); end + + def rescue_type?(); end + + def restarg_expr_type?(); end + + def restarg_type?(); end + + def retry_type?(); end + + def return_type?(); end + + def root_type?(); end + + def sclass_type?(); end + + def self_type?(); end + + def send_type?(); end + + def shadowarg_type?(); end + + def shorthand_asgn?(); end + + def sibling_index(); end + + def single_line?(); end + + def source(); end + + def source_length(); end + + def source_range(); end + + def special_keyword?(); end + + def splat_type?(); end + + def str_content(node=T.unsafe(nil)); end + + def str_type?(); end + + def super_type?(); end + + def sym_type?(); end + + def true_type?(); end + + def truthy_literal?(); end + + def undef_type?(); end + + def unless_guard_type?(); end + + def until_post_type?(); end + + def until_type?(); end + + def value_used?(); end + + def variable?(); end + + def visit_descendants(types, &block); end + + def when_type?(); end + + def while_post_type?(); end + + def while_type?(); end + + def xstr_type?(); end + + def yield_type?(); end + + def zsuper_type?(); end + ASSIGNMENTS = ::T.let(nil, ::T.untyped) + BASIC_CONDITIONALS = ::T.let(nil, ::T.untyped) + BASIC_LITERALS = ::T.let(nil, ::T.untyped) + COMPARISON_OPERATORS = ::T.let(nil, ::T.untyped) + COMPOSITE_LITERALS = ::T.let(nil, ::T.untyped) + CONDITIONALS = ::T.let(nil, ::T.untyped) + EQUALS_ASSIGNMENTS = ::T.let(nil, ::T.untyped) + FALSEY_LITERALS = ::T.let(nil, ::T.untyped) + IMMUTABLE_LITERALS = ::T.let(nil, ::T.untyped) + KEYWORDS = ::T.let(nil, ::T.untyped) + LITERALS = ::T.let(nil, ::T.untyped) + MUTABLE_LITERALS = ::T.let(nil, ::T.untyped) + OPERATOR_KEYWORDS = ::T.let(nil, ::T.untyped) + REFERENCES = ::T.let(nil, ::T.untyped) + SHORTHAND_ASSIGNMENTS = ::T.let(nil, ::T.untyped) + SPECIAL_KEYWORDS = ::T.let(nil, ::T.untyped) + TRUTHY_LITERALS = ::T.let(nil, ::T.untyped) + VARIABLES = ::T.let(nil, ::T.untyped) +end + +class RuboCop::AST::Node + extend ::RuboCop::NodePattern::Macros +end + +module RuboCop::AST::NumericNode + def sign?(); end + SIGN_REGEX = ::T.let(nil, ::T.untyped) +end + +module RuboCop::AST::NumericNode +end + +class RuboCop::AST::OrNode + include ::RuboCop::AST::BinaryOperatorNode + include ::RuboCop::AST::PredicateOperatorNode + def alternate_operator(); end + + def inverse_operator(); end +end + +class RuboCop::AST::OrNode +end + +class RuboCop::AST::PairNode + include ::RuboCop::AST::HashElementNode + def colon?(); end + + def delimiter(with_spacing=T.unsafe(nil)); end + + def hash_rocket?(); end + + def inverse_delimiter(with_spacing=T.unsafe(nil)); end + + def value_on_new_line?(); end + COLON = ::T.let(nil, ::T.untyped) + HASH_ROCKET = ::T.let(nil, ::T.untyped) + SPACED_COLON = ::T.let(nil, ::T.untyped) + SPACED_HASH_ROCKET = ::T.let(nil, ::T.untyped) +end + +class RuboCop::AST::PairNode +end + +module RuboCop::AST::ParameterizedNode + def arguments?(); end + + def block_argument?(); end + + def first_argument(); end + + def last_argument(); end + + def parenthesized?(); end + + def rest_argument?(); end + + def splat_argument?(); end +end + +module RuboCop::AST::ParameterizedNode +end + +module RuboCop::AST::PredicateOperatorNode + def logical_operator?(); end + + def operator(); end + + def semantic_operator?(); end + LOGICAL_AND = ::T.let(nil, ::T.untyped) + LOGICAL_OR = ::T.let(nil, ::T.untyped) + SEMANTIC_AND = ::T.let(nil, ::T.untyped) + SEMANTIC_OR = ::T.let(nil, ::T.untyped) +end + +module RuboCop::AST::PredicateOperatorNode +end + +class RuboCop::AST::RangeNode + def begin(); end + + def end(); end +end + +class RuboCop::AST::RangeNode +end + +class RuboCop::AST::RegexpNode + def content(); end + + def regopt(); end + + def to_regexp(); end + OPTIONS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::AST::RegexpNode +end + +class RuboCop::AST::ResbodyNode + def body(); end + + def exception_variable(); end +end + +class RuboCop::AST::ResbodyNode +end + +class RuboCop::AST::RetryNode + include ::RuboCop::AST::MethodDispatchNode + include ::RuboCop::AST::MethodIdentifierPredicates + include ::RuboCop::AST::ParameterizedNode +end + +class RuboCop::AST::RetryNode +end + +class RuboCop::AST::ReturnNode + include ::RuboCop::AST::MethodDispatchNode + include ::RuboCop::AST::MethodIdentifierPredicates + include ::RuboCop::AST::ParameterizedNode +end + +class RuboCop::AST::ReturnNode +end + +class RuboCop::AST::SelfClassNode + def body(); end + + def identifier(); end +end + +class RuboCop::AST::SelfClassNode +end + +class RuboCop::AST::SendNode + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::MethodDispatchNode + include ::RuboCop::AST::MethodIdentifierPredicates +end + +class RuboCop::AST::SendNode +end + +module RuboCop::AST::Sexp + def s(type, *children); end +end + +module RuboCop::AST::Sexp +end + +class RuboCop::AST::StrNode + include ::RuboCop::AST::BasicLiteralNode + def heredoc?(); end +end + +class RuboCop::AST::StrNode +end + +class RuboCop::AST::SuperNode + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::MethodDispatchNode + include ::RuboCop::AST::MethodIdentifierPredicates +end + +class RuboCop::AST::SuperNode +end + +class RuboCop::AST::SymbolNode + include ::RuboCop::AST::BasicLiteralNode +end + +class RuboCop::AST::SymbolNode +end + +module RuboCop::AST::Traversal + def on_alias(node); end + + def on_and(node); end + + def on_and_asgn(node); end + + def on_arg(node); end + + def on_arg_expr(node); end + + def on_args(node); end + + def on_array(node); end + + def on_array_pattern(node); end + + def on_array_pattern_with_tail(node); end + + def on_back_ref(node); end + + def on_begin(node); end + + def on_block(node); end + + def on_block_pass(node); end + + def on_blockarg(node); end + + def on_break(node); end + + def on_case(node); end + + def on_case_match(node); end + + def on_casgn(node); end + + def on_cbase(node); end + + def on_class(node); end + + def on_complex(node); end + + def on_const(node); end + + def on_const_pattern(node); end + + def on_csend(node); end + + def on_cvar(node); end + + def on_cvasgn(node); end + + def on_def(node); end + + def on_defined?(node); end + + def on_defs(node); end + + def on_dstr(node); end + + def on_dsym(node); end + + def on_eflipflop(node); end + + def on_ensure(node); end + + def on_erange(node); end + + def on_false(node); end + + def on_float(node); end + + def on_for(node); end + + def on_forward_args(node); end + + def on_forwarded_args(node); end + + def on_gvar(node); end + + def on_gvasgn(node); end + + def on_hash(node); end + + def on_hash_pattern(node); end + + def on_if(node); end + + def on_if_guard(node); end + + def on_iflipflop(node); end + + def on_in_match(node); end + + def on_in_pattern(node); end + + def on_int(node); end + + def on_irange(node); end + + def on_ivar(node); end + + def on_ivasgn(node); end + + def on_kwarg(node); end + + def on_kwbegin(node); end + + def on_kwoptarg(node); end + + def on_kwrestarg(node); end + + def on_kwsplat(node); end + + def on_lambda(node); end + + def on_lvar(node); end + + def on_lvasgn(node); end + + def on_masgn(node); end + + def on_match_alt(node); end + + def on_match_as(node); end + + def on_match_current_line(node); end + + def on_match_nil_pattern(node); end + + def on_match_rest(node); end + + def on_match_var(node); end + + def on_match_with_lvasgn(node); end + + def on_match_with_trailing_comma(node); end + + def on_mlhs(node); end + + def on_module(node); end + + def on_next(node); end + + def on_nil(node); end + + def on_not(node); end + + def on_nth_ref(node); end + + def on_numblock(node); end + + def on_op_asgn(node); end + + def on_optarg(node); end + + def on_or(node); end + + def on_or_asgn(node); end + + def on_pair(node); end + + def on_pin(node); end + + def on_postexe(node); end + + def on_preexe(node); end + + def on_rational(node); end + + def on_redo(node); end + + def on_regexp(node); end + + def on_regopt(node); end + + def on_resbody(node); end + + def on_rescue(node); end + + def on_restarg(node); end + + def on_retry(node); end + + def on_return(node); end + + def on_sclass(node); end + + def on_self(node); end + + def on_send(node); end + + def on_shadowarg(node); end + + def on_splat(node); end + + def on_str(node); end + + def on_super(node); end + + def on_sym(node); end + + def on_true(node); end + + def on_undef(node); end + + def on_unless_guard(node); end + + def on_until(node); end + + def on_until_post(node); end + + def on_when(node); end + + def on_while(node); end + + def on_while_post(node); end + + def on_xstr(node); end + + def on_yield(node); end + + def on_zsuper(node); end + + def walk(node); end + MANY_CHILD_NODES = ::T.let(nil, ::T.untyped) + NO_CHILD_NODES = ::T.let(nil, ::T.untyped) + ONE_CHILD_NODE = ::T.let(nil, ::T.untyped) + SECOND_CHILD_ONLY = ::T.let(nil, ::T.untyped) +end + +module RuboCop::AST::Traversal +end + +class RuboCop::AST::UntilNode + include ::RuboCop::AST::ConditionalNode + include ::RuboCop::AST::ModifierNode + def do?(); end + + def inverse_keyword(); end + + def keyword(); end +end + +class RuboCop::AST::UntilNode +end + +class RuboCop::AST::WhenNode + def body(); end + + def branch_index(); end + + def conditions(); end + + def each_condition(); end + + def then?(); end +end + +class RuboCop::AST::WhenNode +end + +class RuboCop::AST::WhileNode + include ::RuboCop::AST::ConditionalNode + include ::RuboCop::AST::ModifierNode + def do?(); end + + def inverse_keyword(); end + + def keyword(); end +end + +class RuboCop::AST::WhileNode +end + +class RuboCop::AST::YieldNode + include ::RuboCop::AST::ParameterizedNode + include ::RuboCop::AST::MethodDispatchNode + include ::RuboCop::AST::MethodIdentifierPredicates +end + +class RuboCop::AST::YieldNode +end + +module RuboCop::AST +end + +class RuboCop::CLI + def config_store(); end + + def options(); end + + def run(args=T.unsafe(nil)); end + STATUS_ERROR = ::T.let(nil, ::T.untyped) + STATUS_INTERRUPTED = ::T.let(nil, ::T.untyped) + STATUS_OFFENSES = ::T.let(nil, ::T.untyped) + STATUS_SUCCESS = ::T.let(nil, ::T.untyped) +end + +module RuboCop::CLI::Command +end + +class RuboCop::CLI::Command::AutoGenerateConfig + def run(); end + PHASE_1 = ::T.let(nil, ::T.untyped) + PHASE_1_DISABLED = ::T.let(nil, ::T.untyped) + PHASE_1_OVERRIDDEN = ::T.let(nil, ::T.untyped) + PHASE_2 = ::T.let(nil, ::T.untyped) +end + +class RuboCop::CLI::Command::AutoGenerateConfig +end + +class RuboCop::CLI::Command::Base + def env(); end + + def initialize(env); end +end + +class RuboCop::CLI::Command::Base + def self.by_command_name(name); end + + def self.command_name(); end + + def self.command_name=(command_name); end + + def self.inherited(subclass); end +end + +class RuboCop::CLI::Command::ExecuteRunner + include ::RuboCop::Formatter::TextUtil + def run(); end +end + +class RuboCop::CLI::Command::ExecuteRunner +end + +class RuboCop::CLI::Command::InitDotfile + def run(); end + DOTFILE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::CLI::Command::InitDotfile +end + +class RuboCop::CLI::Command::ShowCops + def run(); end +end + +class RuboCop::CLI::Command::ShowCops +end + +class RuboCop::CLI::Command::Version + def run(); end +end + +class RuboCop::CLI::Command::Version +end + +module RuboCop::CLI::Command + def self.run(env, name); end +end + +class RuboCop::CLI::Environment + def config_store(); end + + def initialize(options, config_store, paths); end + + def options(); end + + def paths(); end + + def run(name); end +end + +class RuboCop::CLI::Environment +end + +class RuboCop::CLI::Finished +end + +class RuboCop::CLI::Finished +end + +class RuboCop::CLI +end + +class RuboCop::CachedData + def from_json(text); end + + def initialize(filename); end + + def to_json(offenses); end +end + +class RuboCop::CachedData +end + +class RuboCop::CommentConfig + def cop_disabled_line_ranges(); end + + def cop_enabled_at_line?(cop, line_number); end + + def extra_enabled_comments(); end + + def initialize(processed_source); end + + def processed_source(); end + COMMENT_DIRECTIVE_REGEXP = ::T.let(nil, ::T.untyped) + COPS_PATTERN = ::T.let(nil, ::T.untyped) + COP_NAMES_PATTERN = ::T.let(nil, ::T.untyped) + COP_NAME_PATTERN = ::T.let(nil, ::T.untyped) + REDUNDANT_DISABLE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::CommentConfig::CopAnalysis + def line_ranges(); end + + def line_ranges=(_); end + + def start_line_number(); end + + def start_line_number=(_); end +end + +class RuboCop::CommentConfig::CopAnalysis + def self.[](*_); end + + def self.members(); end +end + +class RuboCop::CommentConfig +end + +class RuboCop::Config + include ::RuboCop::PathUtil + include ::RuboCop::FileFinder + def [](*args, &block); end + + def []=(*args, &block); end + + def add_excludes_from_higher_level(highest_config); end + + def allowed_camel_case_file?(file); end + + def base_dir_for_path_parameters(); end + + def bundler_lock_file_path(); end + + def check(); end + + def delete(*args, &block); end + + def deprecation_check(); end + + def each(*args, &block); end + + def each_key(*args, &block); end + + def file_to_exclude?(file); end + + def file_to_include?(file); end + + def for_all_cops(); end + + def for_cop(cop); end + + def for_department(department_name); end + + def initialize(hash=T.unsafe(nil), loaded_path=T.unsafe(nil)); end + + def internal?(); end + + def key?(*args, &block); end + + def keys(*args, &block); end + + def loaded_path(); end + + def make_excludes_absolute(); end + + def map(*args, &block); end + + def merge(*args, &block); end + + def path_relative_to_config(path); end + + def patterns_to_exclude(); end + + def patterns_to_include(); end + + def possibly_include_hidden?(); end + + def signature(); end + + def smart_loaded_path(); end + + def target_rails_version(); end + + def target_ruby_version(*args, &block); end + + def to_h(*args, &block); end + + def to_hash(*args, &block); end + + def validate(*args, &block); end + DEFAULT_RAILS_VERSION = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Config + extend ::Forwardable + def self.create(hash, path); end +end + +class RuboCop::ConfigLoader + AUTO_GENERATED_FILE = ::T.let(nil, ::T.untyped) + DEFAULT_FILE = ::T.let(nil, ::T.untyped) + DOTFILE = ::T.let(nil, ::T.untyped) + RUBOCOP_HOME = ::T.let(nil, ::T.untyped) + XDG_CONFIG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::ConfigLoader + extend ::RuboCop::FileFinder + def self.add_excludes_from_files(config, config_file); end + + def self.add_inheritance_from_auto_generated_file(); end + + def self.add_missing_namespaces(path, hash); end + + def self.auto_gen_config(); end + + def self.auto_gen_config=(auto_gen_config); end + + def self.auto_gen_config?(); end + + def self.clear_options(); end + + def self.configuration_file_for(target_dir); end + + def self.configuration_from_file(config_file); end + + def self.debug(); end + + def self.debug=(debug); end + + def self.debug?(); end + + def self.default_configuration(); end + + def self.default_configuration=(default_configuration); end + + def self.ignore_parent_exclusion(); end + + def self.ignore_parent_exclusion=(ignore_parent_exclusion); end + + def self.ignore_parent_exclusion?(); end + + def self.load_file(file); end + + def self.merge(base_hash, derived_hash); end + + def self.merge_with_default(config, config_file, unset_nil: T.unsafe(nil)); end + + def self.options_config(); end + + def self.options_config=(options_config); end + + def self.warn_on_pending_cops(config); end +end + +class RuboCop::ConfigLoaderResolver + def merge(base_hash, derived_hash, **opts); end + + def merge_with_default(config, config_file, unset_nil:); end + + def resolve_inheritance(path, hash, file, debug); end + + def resolve_inheritance_from_gems(hash); end + + def resolve_requires(path, hash); end +end + +class RuboCop::ConfigLoaderResolver +end + +class RuboCop::ConfigNotFoundError +end + +class RuboCop::ConfigNotFoundError +end + +class RuboCop::ConfigObsoletion + def initialize(config); end + + def reject_obsolete_cops_and_parameters(); end + MOVED_COPS = ::T.let(nil, ::T.untyped) + OBSOLETE_COPS = ::T.let(nil, ::T.untyped) + OBSOLETE_ENFORCED_STYLES = ::T.let(nil, ::T.untyped) + OBSOLETE_PARAMETERS = ::T.let(nil, ::T.untyped) + REMOVED_COPS = ::T.let(nil, ::T.untyped) + REMOVED_COPS_WITH_REASON = ::T.let(nil, ::T.untyped) + RENAMED_COPS = ::T.let(nil, ::T.untyped) + SPLIT_COPS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::ConfigObsoletion +end + +class RuboCop::ConfigStore + def for(file_or_dir); end + + def force_default_config!(); end + + def options_config=(options_config); end +end + +class RuboCop::ConfigStore +end + +class RuboCop::ConfigValidator + def for_all_cops(*args, &block); end + + def initialize(config); end + + def smart_loaded_path(*args, &block); end + + def target_ruby_version(); end + + def validate(); end + + def validate_section_presence(name); end + COMMON_PARAMS = ::T.let(nil, ::T.untyped) + INTERNAL_PARAMS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::ConfigValidator + extend ::Forwardable +end + +module RuboCop::Cop +end + +module RuboCop::Cop::Alignment + SPACE = ::T.let(nil, ::T.untyped) +end + +module RuboCop::Cop::Alignment +end + +class RuboCop::Cop::AlignmentCorrector +end + +class RuboCop::Cop::AlignmentCorrector + extend ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::Alignment + def self.align_end(processed_source, node, align_to); end + + def self.correct(processed_source, node, column_delta); end + + def self.processed_source(); end +end + +class RuboCop::Cop::AmbiguousCopName + def initialize(name, origin, badges); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::AmbiguousCopName +end + +module RuboCop::Cop::ArrayMinSize +end + +module RuboCop::Cop::ArrayMinSize +end + +module RuboCop::Cop::ArraySyntax +end + +module RuboCop::Cop::ArraySyntax +end + +module RuboCop::Cop::AutocorrectLogic + def autocorrect?(); end + + def autocorrect_enabled?(); end + + def autocorrect_requested?(); end + + def correctable?(); end + + def disable_offense(node); end + + def disable_uncorrectable?(); end + + def safe_autocorrect?(); end + + def support_autocorrect?(); end +end + +module RuboCop::Cop::AutocorrectLogic +end + +class RuboCop::Cop::Badge + def ==(other); end + + def cop_name(); end + + def department(); end + + def eql?(other); end + + def initialize(department, cop_name); end + + def match?(other); end + + def qualified?(); end + + def with_department(department); end +end + +class RuboCop::Cop::Badge::InvalidBadge + def initialize(token); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Badge::InvalidBadge +end + +class RuboCop::Cop::Badge + def self.for(class_name); end + + def self.parse(identifier); end +end + +module RuboCop::Cop::Bundler +end + +class RuboCop::Cop::Bundler::DuplicatedGem + include ::RuboCop::Cop::RangeHelp + def gem_declarations(node0); end + + def investigate(processed_source); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Bundler::DuplicatedGem +end + +class RuboCop::Cop::Bundler::GemComment + include ::RuboCop::Cop::DefNode + def gem_declaration?(node=T.unsafe(nil)); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Bundler::GemComment +end + +class RuboCop::Cop::Bundler::InsecureProtocolSource + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def insecure_protocol_source?(node=T.unsafe(nil)); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Bundler::InsecureProtocolSource +end + +class RuboCop::Cop::Bundler::OrderedGems + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::OrderedGemNode + def autocorrect(node); end + + def gem_declarations(node0); end + + def investigate(processed_source); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Bundler::OrderedGems +end + +module RuboCop::Cop::Bundler +end + +module RuboCop::Cop::CheckAssignment + def on_and_asgn(node); end + + def on_casgn(node); end + + def on_cvasgn(node); end + + def on_gvasgn(node); end + + def on_ivasgn(node); end + + def on_lvasgn(node); end + + def on_masgn(node); end + + def on_op_asgn(node); end + + def on_or_asgn(node); end + + def on_send(node); end +end + +module RuboCop::Cop::CheckAssignment + def self.extract_rhs(node); end +end + +module RuboCop::Cop::CheckLineBreakable + def extract_breakable_node(node, max); end +end + +module RuboCop::Cop::CheckLineBreakable +end + +module RuboCop::Cop::ClassishLength + include ::RuboCop::Cop::CodeLength + include ::RuboCop::Cop::ConfigurableMax +end + +module RuboCop::Cop::ClassishLength +end + +module RuboCop::Cop::CodeLength + include ::RuboCop::Cop::ConfigurableMax +end + +module RuboCop::Cop::CodeLength +end + +class RuboCop::Cop::Commissioner + include ::RuboCop::AST::Traversal + def errors(); end + + def initialize(cops, forces=T.unsafe(nil), options=T.unsafe(nil)); end + + def investigate(processed_source); end +end + +class RuboCop::Cop::Commissioner +end + +class RuboCop::Cop::ConditionCorrector +end + +class RuboCop::Cop::ConditionCorrector + def self.correct_negative_condition(node); end +end + +module RuboCop::Cop::ConfigurableEnforcedStyle + def alternative_style(); end + + def alternative_styles(); end + + def ambiguous_style_detected(*possibilities); end + + def conflicting_styles_detected(); end + + def correct_style_detected(); end + + def detected_style(); end + + def detected_style=(style); end + + def no_acceptable_style!(); end + + def no_acceptable_style?(); end + + def opposite_style_detected(); end + + def style(); end + + def style_configured?(); end + + def style_detected(detected); end + + def style_parameter_name(); end + + def supported_styles(); end + + def unexpected_style_detected(unexpected); end + + def unrecognized_style_detected(); end +end + +module RuboCop::Cop::ConfigurableEnforcedStyle +end + +module RuboCop::Cop::ConfigurableFormatting + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def check_name(node, name, name_range); end + + def class_emitter_method?(node, name); end + + def report_opposing_styles(node, name); end + + def valid_name?(node, name, given_style=T.unsafe(nil)); end +end + +module RuboCop::Cop::ConfigurableFormatting +end + +module RuboCop::Cop::ConfigurableMax +end + +module RuboCop::Cop::ConfigurableMax +end + +module RuboCop::Cop::ConfigurableNaming + include ::RuboCop::Cop::ConfigurableFormatting + include ::RuboCop::Cop::ConfigurableEnforcedStyle + FORMATS = ::T.let(nil, ::T.untyped) +end + +module RuboCop::Cop::ConfigurableNaming +end + +module RuboCop::Cop::ConfigurableNumbering + include ::RuboCop::Cop::ConfigurableFormatting + include ::RuboCop::Cop::ConfigurableEnforcedStyle + FORMATS = ::T.let(nil, ::T.untyped) +end + +module RuboCop::Cop::ConfigurableNumbering +end + +class RuboCop::Cop::Cop + include ::RuboCop::AST::Sexp + include ::RuboCop::Cop::Util + include ::RuboCop::PathUtil + include ::RuboCop::Cop::IgnoredNode + include ::RuboCop::Cop::AutocorrectLogic + def add_offense(node, location: T.unsafe(nil), message: T.unsafe(nil), severity: T.unsafe(nil)); end + + def config(); end + + def config_to_allow_offenses(); end + + def config_to_allow_offenses=(hash); end + + def cop_config(); end + + def cop_name(); end + + def correct(node); end + + def corrections(); end + + def disable_uncorrectable(node); end + + def duplicate_location?(location); end + + def excluded_file?(file); end + + def external_dependency_checksum(); end + + def find_location(node, loc); end + + def initialize(config=T.unsafe(nil), options=T.unsafe(nil)); end + + def join_force?(_force_class); end + + def message(_node=T.unsafe(nil)); end + + def name(); end + + def offenses(); end + + def parse(source, path=T.unsafe(nil)); end + + def processed_source(); end + + def processed_source=(processed_source); end + + def reason_to_not_correct(node); end + + def relevant_file?(file); end + + def target_rails_version(); end + + def target_ruby_version(); end +end + +class RuboCop::Cop::Cop::Correction + def call(corrector); end + + def cop(); end + + def cop=(_); end + + def lambda=(_); end + + def node(); end + + def node=(_); end +end + +class RuboCop::Cop::Cop::Correction + def self.[](*_); end + + def self.members(); end +end + +class RuboCop::Cop::Cop + extend ::RuboCop::AST::Sexp + extend ::RuboCop::NodePattern::Macros + def self.all(); end + + def self.autocorrect_incompatible_with(); end + + def self.badge(); end + + def self.cop_name(); end + + def self.department(); end + + def self.inherited(subclass); end + + def self.lint?(); end + + def self.match?(given_names); end + + def self.qualified_cop_name(name, origin); end + + def self.registry(); end +end + +class RuboCop::Cop::Corrector + def corrections(); end + + def diagnostics(); end + + def initialize(source_buffer, corrections=T.unsafe(nil)); end + + def insert_after(range, content); end + + def insert_before(range, content); end + + def remove(range); end + + def remove_leading(range, size); end + + def remove_preceding(range, size); end + + def remove_trailing(range, size); end + + def replace(range, content); end + + def rewrite(); end +end + +class RuboCop::Cop::Corrector +end + +module RuboCop::Cop::DefNode + def non_public_modifier?(node=T.unsafe(nil)); end + NON_PUBLIC_MODIFIERS = ::T.let(nil, ::T.untyped) +end + +module RuboCop::Cop::DefNode + extend ::RuboCop::NodePattern::Macros +end + +module RuboCop::Cop::DocumentationComment + include ::RuboCop::Cop::Style::AnnotationComment +end + +module RuboCop::Cop::DocumentationComment + extend ::RuboCop::NodePattern::Macros +end + +module RuboCop::Cop::Duplication +end + +module RuboCop::Cop::Duplication +end + +class RuboCop::Cop::EachToForCorrector + def call(corrector); end + + def initialize(block_node); end + CORRECTION_WITHOUT_ARGUMENTS = ::T.let(nil, ::T.untyped) + CORRECTION_WITH_ARGUMENTS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::EachToForCorrector + extend ::RuboCop::NodePattern::Macros +end + +class RuboCop::Cop::EmptyLineCorrector +end + +class RuboCop::Cop::EmptyLineCorrector + def self.correct(node); end + + def self.insert_before(node); end +end + +module RuboCop::Cop::EmptyParameter + def empty_arguments?(node=T.unsafe(nil)); end +end + +module RuboCop::Cop::EmptyParameter + extend ::RuboCop::NodePattern::Macros +end + +module RuboCop::Cop::EndKeywordAlignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + MSG = ::T.let(nil, ::T.untyped) +end + +module RuboCop::Cop::EndKeywordAlignment +end + +module RuboCop::Cop::EnforceSuperclass + def on_class(node); end + + def on_send(node); end +end + +module RuboCop::Cop::EnforceSuperclass + def self.included(base); end +end + +module RuboCop::Cop::FirstElementLineBreak +end + +module RuboCop::Cop::FirstElementLineBreak +end + +class RuboCop::Cop::ForToEachCorrector + def call(corrector); end + + def initialize(for_node); end + CORRECTION = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::ForToEachCorrector + extend ::RuboCop::NodePattern::Macros +end + +class RuboCop::Cop::Force + def cops(); end + + def initialize(cops); end + + def investigate(_processed_source); end + + def name(); end + + def run_hook(method_name, *args); end +end + +class RuboCop::Cop::Force + def self.all(); end + + def self.force_name(); end + + def self.inherited(subclass); end +end + +module RuboCop::Cop::FrozenStringLiteral + FROZEN_STRING_LITERAL = ::T.let(nil, ::T.untyped) + FROZEN_STRING_LITERAL_ENABLED = ::T.let(nil, ::T.untyped) + FROZEN_STRING_LITERAL_TYPES = ::T.let(nil, ::T.untyped) +end + +module RuboCop::Cop::FrozenStringLiteral + def self.frozen_string_literal_comment_exists?(); end +end + +module RuboCop::Cop::Gemspec +end + +class RuboCop::Cop::Gemspec::DuplicatedAssignment + include ::RuboCop::Cop::RangeHelp + def assignment_method_declarations(node0); end + + def gem_specification(node0); end + + def investigate(processed_source); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Gemspec::DuplicatedAssignment +end + +class RuboCop::Cop::Gemspec::OrderedDependencies + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::OrderedGemNode + def autocorrect(node); end + + def dependency_declarations(node0); end + + def investigate(processed_source); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Gemspec::OrderedDependencies +end + +class RuboCop::Cop::Gemspec::RequiredRubyVersion + def investigate(processed_source); end + + def required_ruby_version(node0); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Gemspec::RequiredRubyVersion +end + +class RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage + def gem_specification?(node0); end + + def on_const(node); end + + def ruby_version?(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Gemspec::RubyVersionGlobalsUsage +end + +module RuboCop::Cop::Gemspec +end + +class RuboCop::Cop::Generator + def initialize(name, github_user, output: T.unsafe(nil)); end + + def inject_config(config_file_path: T.unsafe(nil)); end + + def inject_require(root_file_path: T.unsafe(nil)); end + + def todo(); end + + def write_source(); end + + def write_spec(); end + CONFIGURATION_ADDED_MESSAGE = ::T.let(nil, ::T.untyped) + SOURCE_TEMPLATE = ::T.let(nil, ::T.untyped) + SPEC_TEMPLATE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Generator::ConfigurationInjector + def initialize(configuration_file_path:, badge:, version_added:); end + + def inject(); end + TEMPLATE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Generator::ConfigurationInjector +end + +class RuboCop::Cop::Generator::RequireFileInjector + def initialize(source_path:, root_file_path:, output: T.unsafe(nil)); end + + def inject(); end + REQUIRE_PATH = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Generator::RequireFileInjector +end + +class RuboCop::Cop::Generator +end + +module RuboCop::Cop::HashAlignmentStyles +end + +class RuboCop::Cop::HashAlignmentStyles::KeyAlignment + def checkable_layout?(_node); end + + def deltas(first_pair, current_pair); end + + def deltas_for_first_pair(first_pair, _node); end +end + +class RuboCop::Cop::HashAlignmentStyles::KeyAlignment +end + +class RuboCop::Cop::HashAlignmentStyles::SeparatorAlignment + include ::RuboCop::Cop::HashAlignmentStyles::ValueAlignment + def deltas_for_first_pair(*_nodes); end +end + +class RuboCop::Cop::HashAlignmentStyles::SeparatorAlignment +end + +class RuboCop::Cop::HashAlignmentStyles::TableAlignment + include ::RuboCop::Cop::HashAlignmentStyles::ValueAlignment + def deltas_for_first_pair(first_pair, node); end +end + +class RuboCop::Cop::HashAlignmentStyles::TableAlignment +end + +module RuboCop::Cop::HashAlignmentStyles::ValueAlignment + def checkable_layout?(node); end + + def deltas(first_pair, current_pair); end +end + +module RuboCop::Cop::HashAlignmentStyles::ValueAlignment +end + +module RuboCop::Cop::HashAlignmentStyles +end + +module RuboCop::Cop::HashTransformMethod + def autocorrect(node); end + + def on_block(node); end + + def on_csend(node); end + + def on_send(node); end +end + +class RuboCop::Cop::HashTransformMethod::Autocorrection + def block_node(); end + + def block_node=(_); end + + def leading(); end + + def leading=(_); end + + def match(); end + + def match=(_); end + + def set_new_arg_name(transformed_argname, corrector); end + + def set_new_body_expression(transforming_body_expr, corrector); end + + def set_new_method_name(new_method_name, corrector); end + + def strip_prefix_and_suffix(node, corrector); end + + def trailing(); end + + def trailing=(_); end +end + +class RuboCop::Cop::HashTransformMethod::Autocorrection + def self.[](*_); end + + def self.from_each_with_object(node, match); end + + def self.from_hash_brackets_map(node, match); end + + def self.from_map_to_h(node, match); end + + def self.members(); end +end + +class RuboCop::Cop::HashTransformMethod::Captures + def noop_transformation?(); end + + def transformation_uses_both_args?(); end + + def transformed_argname(); end + + def transformed_argname=(_); end + + def transforming_body_expr(); end + + def transforming_body_expr=(_); end + + def unchanged_body_expr(); end + + def unchanged_body_expr=(_); end +end + +class RuboCop::Cop::HashTransformMethod::Captures + def self.[](*_); end + + def self.members(); end +end + +module RuboCop::Cop::HashTransformMethod +end + +module RuboCop::Cop::Heredoc + def on_dstr(node); end + + def on_heredoc(_node); end + + def on_str(node); end + + def on_xstr(node); end + OPENING_DELIMITER = ::T.let(nil, ::T.untyped) +end + +module RuboCop::Cop::Heredoc +end + +module RuboCop::Cop::IgnoredMethods +end + +module RuboCop::Cop::IgnoredMethods +end + +module RuboCop::Cop::IgnoredNode + def ignore_node(node); end + + def ignored_node?(node); end + + def part_of_ignored_node?(node); end +end + +module RuboCop::Cop::IgnoredNode +end + +module RuboCop::Cop::IgnoredPattern +end + +module RuboCop::Cop::IgnoredPattern +end + +module RuboCop::Cop::IntegerNode +end + +module RuboCop::Cop::IntegerNode +end + +module RuboCop::Cop::Interpolation + def on_dstr(node); end + + def on_dsym(node); end + + def on_node_with_interpolations(node); end + + def on_regexp(node); end + + def on_xstr(node); end +end + +module RuboCop::Cop::Interpolation +end + +class RuboCop::Cop::LambdaLiteralToMethodCorrector + def call(corrector); end + + def initialize(block_node); end +end + +class RuboCop::Cop::LambdaLiteralToMethodCorrector +end + +module RuboCop::Cop::Layout +end + +class RuboCop::Cop::Layout::AccessModifierIndentation + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_block(node); end + + def on_class(node); end + + def on_module(node); end + + def on_sclass(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::AccessModifierIndentation +end + +class RuboCop::Cop::Layout::ArgumentAlignment + include ::RuboCop::Cop::Alignment + def autocorrect(node); end + + def on_csend(node); end + + def on_send(node); end + ALIGN_PARAMS_MSG = ::T.let(nil, ::T.untyped) + FIXED_INDENT_MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::ArgumentAlignment +end + +class RuboCop::Cop::Layout::ArrayAlignment + include ::RuboCop::Cop::Alignment + def autocorrect(node); end + + def on_array(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::ArrayAlignment +end + +class RuboCop::Cop::Layout::AssignmentIndentation + include ::RuboCop::Cop::CheckAssignment + include ::RuboCop::Cop::Alignment + def autocorrect(node); end + + def check_assignment(node, rhs); end + + def leftmost_multiple_assignment(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::AssignmentIndentation +end + +class RuboCop::Cop::Layout::BlockAlignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def block_end_align_target?(node=T.unsafe(nil), param1); end + + def on_block(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::BlockAlignment +end + +class RuboCop::Cop::Layout::BlockEndNewline + include ::RuboCop::Cop::Alignment + def autocorrect(node); end + + def on_block(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::BlockEndNewline +end + +class RuboCop::Cop::Layout::CaseIndentation + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_case(case_node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::CaseIndentation +end + +class RuboCop::Cop::Layout::ClassStructure + def autocorrect(node); end + + def on_class(class_node); end + + def visibility_block?(node=T.unsafe(nil)); end + HUMANIZED_NODE_TYPE = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) + VISIBILITY_SCOPES = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::ClassStructure +end + +class RuboCop::Cop::Layout::ClosingHeredocIndentation + include ::RuboCop::Cop::Heredoc + def autocorrect(node); end + + def on_heredoc(node); end + MSG = ::T.let(nil, ::T.untyped) + MSG_ARG = ::T.let(nil, ::T.untyped) + SIMPLE_HEREDOC = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::ClosingHeredocIndentation +end + +class RuboCop::Cop::Layout::ClosingParenthesisIndentation + include ::RuboCop::Cop::Alignment + def autocorrect(node); end + + def on_begin(node); end + + def on_csend(node); end + + def on_def(node); end + + def on_defs(node); end + + def on_send(node); end + MSG_ALIGN = ::T.let(nil, ::T.untyped) + MSG_INDENT = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::ClosingParenthesisIndentation +end + +class RuboCop::Cop::Layout::CommentIndentation + include ::RuboCop::Cop::Alignment + def autocorrect(comment); end + + def investigate(processed_source); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::CommentIndentation +end + +class RuboCop::Cop::Layout::ConditionPosition + def on_if(node); end + + def on_until(node); end + + def on_while(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::ConditionPosition +end + +class RuboCop::Cop::Layout::DefEndAlignment + include ::RuboCop::Cop::EndKeywordAlignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_def(node); end + + def on_defs(node); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::DefEndAlignment +end + +class RuboCop::Cop::Layout::DotPosition + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def on_csend(node); end + + def on_send(node); end +end + +class RuboCop::Cop::Layout::DotPosition +end + +class RuboCop::Cop::Layout::ElseAlignment + include ::RuboCop::Cop::EndKeywordAlignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::CheckAssignment + def autocorrect(node); end + + def on_case(node); end + + def on_if(node, base=T.unsafe(nil)); end + + def on_rescue(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::ElseAlignment +end + +class RuboCop::Cop::Layout::EmptyComment + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def investigate(processed_source); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::EmptyComment +end + +class RuboCop::Cop::Layout::EmptyLineAfterGuardClause + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_if(node); end + END_OF_HEREDOC_LINE = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::EmptyLineAfterGuardClause +end + +class RuboCop::Cop::Layout::EmptyLineAfterMagicComment + include ::RuboCop::Cop::RangeHelp + def autocorrect(token); end + + def investigate(source); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::EmptyLineAfterMagicComment +end + +class RuboCop::Cop::Layout::EmptyLineBetweenDefs + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def check_defs(nodes); end + + def on_begin(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::EmptyLineBetweenDefs +end + +class RuboCop::Cop::Layout::EmptyLines + include ::RuboCop::Cop::RangeHelp + def autocorrect(range); end + + def investigate(processed_source); end + LINE_OFFSET = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::EmptyLines +end + +class RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_block(node); end + + def on_class(node); end + + def on_module(node); end + + def on_sclass(node); end + + def on_send(node); end + MSG_AFTER = ::T.let(nil, ::T.untyped) + MSG_AFTER_FOR_ONLY_BEFORE = ::T.let(nil, ::T.untyped) + MSG_BEFORE_AND_AFTER = ::T.let(nil, ::T.untyped) + MSG_BEFORE_FOR_ONLY_BEFORE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::EmptyLinesAroundAccessModifier +end + +class RuboCop::Cop::Layout::EmptyLinesAroundArguments + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_csend(node); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::EmptyLinesAroundArguments +end + +class RuboCop::Cop::Layout::EmptyLinesAroundBeginBody + include ::RuboCop::Cop::Layout::EmptyLinesAroundBody + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_kwbegin(node); end + KIND = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::EmptyLinesAroundBeginBody +end + +class RuboCop::Cop::Layout::EmptyLinesAroundBlockBody + include ::RuboCop::Cop::Layout::EmptyLinesAroundBody + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_block(node); end + KIND = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::EmptyLinesAroundBlockBody +end + +module RuboCop::Cop::Layout::EmptyLinesAroundBody + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def constant_definition?(node=T.unsafe(nil)); end + + def empty_line_required?(node=T.unsafe(nil)); end + MSG_DEFERRED = ::T.let(nil, ::T.untyped) + MSG_EXTRA = ::T.let(nil, ::T.untyped) + MSG_MISSING = ::T.let(nil, ::T.untyped) +end + +module RuboCop::Cop::Layout::EmptyLinesAroundBody + extend ::RuboCop::NodePattern::Macros +end + +class RuboCop::Cop::Layout::EmptyLinesAroundClassBody + include ::RuboCop::Cop::Layout::EmptyLinesAroundBody + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_class(node); end + + def on_sclass(node); end + KIND = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::EmptyLinesAroundClassBody +end + +class RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords + include ::RuboCop::Cop::Layout::EmptyLinesAroundBody + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_def(node); end + + def on_defs(node); end + + def on_kwbegin(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::EmptyLinesAroundExceptionHandlingKeywords +end + +class RuboCop::Cop::Layout::EmptyLinesAroundMethodBody + include ::RuboCop::Cop::Layout::EmptyLinesAroundBody + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_def(node); end + + def on_defs(node); end + KIND = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::EmptyLinesAroundMethodBody +end + +class RuboCop::Cop::Layout::EmptyLinesAroundModuleBody + include ::RuboCop::Cop::Layout::EmptyLinesAroundBody + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_module(node); end + KIND = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::EmptyLinesAroundModuleBody +end + +class RuboCop::Cop::Layout::EndAlignment + include ::RuboCop::Cop::CheckAssignment + include ::RuboCop::Cop::EndKeywordAlignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_case(node); end + + def on_class(node); end + + def on_if(node); end + + def on_module(node); end + + def on_until(node); end + + def on_while(node); end +end + +class RuboCop::Cop::Layout::EndAlignment +end + +class RuboCop::Cop::Layout::EndOfLine + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def investigate(processed_source); end + + def offense_message(line); end + + def unimportant_missing_cr?(index, last_line, line); end + MSG_DETECTED = ::T.let(nil, ::T.untyped) + MSG_MISSING = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::EndOfLine +end + +class RuboCop::Cop::Layout::ExtraSpacing + include ::RuboCop::Cop::PrecedingFollowingAlignment + include ::RuboCop::Cop::RangeHelp + def autocorrect(range); end + + def investigate(processed_source); end + MSG_UNALIGNED_ASGN = ::T.let(nil, ::T.untyped) + MSG_UNNECESSARY = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::ExtraSpacing +end + +class RuboCop::Cop::Layout::FirstArgumentIndentation + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def eligible_method_call?(node=T.unsafe(nil)); end + + def on_csend(node); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::FirstArgumentIndentation +end + +class RuboCop::Cop::Layout::FirstArrayElementIndentation + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::MultilineElementIndentation + def autocorrect(node); end + + def on_array(node); end + + def on_csend(node); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::FirstArrayElementIndentation +end + +class RuboCop::Cop::Layout::FirstArrayElementLineBreak + include ::RuboCop::Cop::FirstElementLineBreak + def autocorrect(node); end + + def on_array(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::FirstArrayElementLineBreak +end + +class RuboCop::Cop::Layout::FirstHashElementIndentation + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::MultilineElementIndentation + def autocorrect(node); end + + def on_csend(node); end + + def on_hash(node); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::FirstHashElementIndentation +end + +class RuboCop::Cop::Layout::FirstHashElementLineBreak + include ::RuboCop::Cop::FirstElementLineBreak + def autocorrect(node); end + + def on_hash(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::FirstHashElementLineBreak +end + +class RuboCop::Cop::Layout::FirstMethodArgumentLineBreak + include ::RuboCop::Cop::FirstElementLineBreak + def autocorrect(node); end + + def on_csend(node); end + + def on_send(node); end + + def on_super(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::FirstMethodArgumentLineBreak +end + +class RuboCop::Cop::Layout::FirstMethodParameterLineBreak + include ::RuboCop::Cop::FirstElementLineBreak + def autocorrect(node); end + + def on_def(node); end + + def on_defs(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::FirstMethodParameterLineBreak +end + +class RuboCop::Cop::Layout::FirstParameterIndentation + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::MultilineElementIndentation + def autocorrect(node); end + + def on_def(node); end + + def on_defs(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::FirstParameterIndentation +end + +class RuboCop::Cop::Layout::HashAlignment + include ::RuboCop::Cop::HashAlignmentStyles + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def column_deltas(); end + + def column_deltas=(column_deltas); end + + def offences_by(); end + + def offences_by=(offences_by); end + + def on_hash(node); end + + def on_send(node); end + + def on_super(node); end + + def on_yield(node); end + MESSAGES = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::HashAlignment +end + +class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis +end + +class RuboCop::Cop::Layout::HeredocIndentation + include ::RuboCop::Cop::Heredoc + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def on_heredoc(node); end + LIBRARY_MSG = ::T.let(nil, ::T.untyped) + RUBY23_TYPE_MSG = ::T.let(nil, ::T.untyped) + RUBY23_WIDTH_MSG = ::T.let(nil, ::T.untyped) + STRIP_METHODS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::HeredocIndentation +end + +class RuboCop::Cop::Layout::IndentationConsistency + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def on_begin(node); end + + def on_kwbegin(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::IndentationConsistency +end + +class RuboCop::Cop::Layout::IndentationWidth + include ::RuboCop::Cop::EndKeywordAlignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::CheckAssignment + include ::RuboCop::Cop::IgnoredPattern + def access_modifier?(node=T.unsafe(nil)); end + + def autocorrect(node); end + + def on_block(node); end + + def on_case(case_node); end + + def on_class(node); end + + def on_csend(node); end + + def on_def(node); end + + def on_defs(node); end + + def on_ensure(node); end + + def on_for(node); end + + def on_if(node, base=T.unsafe(nil)); end + + def on_kwbegin(node); end + + def on_module(node); end + + def on_resbody(node); end + + def on_rescue(node); end + + def on_sclass(node); end + + def on_until(node, base=T.unsafe(nil)); end + + def on_while(node, base=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::IndentationWidth +end + +class RuboCop::Cop::Layout::InitialIndentation + include ::RuboCop::Cop::RangeHelp + def autocorrect(range); end + + def investigate(_processed_source); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::InitialIndentation +end + +class RuboCop::Cop::Layout::LeadingCommentSpace + include ::RuboCop::Cop::RangeHelp + def autocorrect(comment); end + + def investigate(processed_source); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::LeadingCommentSpace +end + +class RuboCop::Cop::Layout::LeadingEmptyLines + def autocorrect(node); end + + def investigate(processed_source); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::LeadingEmptyLines +end + +class RuboCop::Cop::Layout::LineLength + include ::RuboCop::Cop::CheckLineBreakable + include ::RuboCop::Cop::ConfigurableMax + include ::RuboCop::Cop::IgnoredPattern + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::LineLengthHelp + def autocorrect(range); end + + def investigate(processed_source); end + + def investigate_post_walk(processed_source); end + + def on_array(node); end + + def on_block(node); end + + def on_hash(node); end + + def on_potential_breakable_node(node); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::LineLength +end + +class RuboCop::Cop::Layout::MultilineArrayBraceLayout + include ::RuboCop::Cop::MultilineLiteralBraceLayout + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def on_array(node); end + ALWAYS_NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) + ALWAYS_SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) + NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) + SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::MultilineArrayBraceLayout +end + +class RuboCop::Cop::Layout::MultilineArrayLineBreaks + include ::RuboCop::Cop::MultilineElementLineBreaks + def autocorrect(node); end + + def on_array(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::MultilineArrayLineBreaks +end + +class RuboCop::Cop::Layout::MultilineAssignmentLayout + include ::RuboCop::Cop::CheckAssignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def check_assignment(node, rhs); end + + def check_by_enforced_style(node, rhs); end + + def check_new_line_offense(node, rhs); end + + def check_same_line_offense(node, rhs); end + NEW_LINE_OFFENSE = ::T.let(nil, ::T.untyped) + SAME_LINE_OFFENSE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::MultilineAssignmentLayout +end + +class RuboCop::Cop::Layout::MultilineBlockLayout + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_block(node); end + ARG_MSG = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) + PIPE_SIZE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::MultilineBlockLayout +end + +class RuboCop::Cop::Layout::MultilineHashBraceLayout + include ::RuboCop::Cop::MultilineLiteralBraceLayout + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def on_hash(node); end + ALWAYS_NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) + ALWAYS_SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) + NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) + SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::MultilineHashBraceLayout +end + +class RuboCop::Cop::Layout::MultilineHashKeyLineBreaks + include ::RuboCop::Cop::MultilineElementLineBreaks + def autocorrect(node); end + + def on_hash(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::MultilineHashKeyLineBreaks +end + +class RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks + include ::RuboCop::Cop::MultilineElementLineBreaks + def autocorrect(node); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::MultilineMethodArgumentLineBreaks +end + +class RuboCop::Cop::Layout::MultilineMethodCallBraceLayout + include ::RuboCop::Cop::MultilineLiteralBraceLayout + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def on_send(node); end + ALWAYS_NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) + ALWAYS_SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) + NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) + SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::MultilineMethodCallBraceLayout +end + +class RuboCop::Cop::Layout::MultilineMethodCallIndentation + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::MultilineExpressionIndentation + def autocorrect(node); end + + def validate_config(); end +end + +class RuboCop::Cop::Layout::MultilineMethodCallIndentation +end + +class RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout + include ::RuboCop::Cop::MultilineLiteralBraceLayout + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def on_def(node); end + + def on_defs(node); end + ALWAYS_NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) + ALWAYS_SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) + NEW_LINE_MESSAGE = ::T.let(nil, ::T.untyped) + SAME_LINE_MESSAGE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::MultilineMethodDefinitionBraceLayout +end + +class RuboCop::Cop::Layout::MultilineOperationIndentation + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::MultilineExpressionIndentation + def autocorrect(node); end + + def on_and(node); end + + def on_or(node); end + + def validate_config(); end +end + +class RuboCop::Cop::Layout::MultilineOperationIndentation +end + +class RuboCop::Cop::Layout::ParameterAlignment + include ::RuboCop::Cop::Alignment + def autocorrect(node); end + + def on_def(node); end + + def on_defs(node); end + ALIGN_PARAMS_MSG = ::T.let(nil, ::T.untyped) + FIXED_INDENT_MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::ParameterAlignment +end + +class RuboCop::Cop::Layout::RescueEnsureAlignment + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def investigate(processed_source); end + + def on_ensure(node); end + + def on_resbody(node); end + ALTERNATIVE_ACCESS_MODIFIERS = ::T.let(nil, ::T.untyped) + ANCESTOR_TYPES = ::T.let(nil, ::T.untyped) + ANCESTOR_TYPES_WITH_ACCESS_MODIFIERS = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) + RUBY_2_5_ANCESTOR_TYPES = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::RescueEnsureAlignment +end + +class RuboCop::Cop::Layout::SpaceAfterColon + def autocorrect(range); end + + def on_kwoptarg(node); end + + def on_pair(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::SpaceAfterColon +end + +class RuboCop::Cop::Layout::SpaceAfterComma + include ::RuboCop::Cop::SpaceAfterPunctuation + def autocorrect(comma); end + + def kind(token); end + + def space_style_before_rcurly(); end +end + +class RuboCop::Cop::Layout::SpaceAfterComma +end + +class RuboCop::Cop::Layout::SpaceAfterMethodName + include ::RuboCop::Cop::RangeHelp + def autocorrect(pos_before_left_paren); end + + def on_def(node); end + + def on_defs(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::SpaceAfterMethodName +end + +class RuboCop::Cop::Layout::SpaceAfterNot + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_send(node); end + + def whitespace_after_operator?(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::SpaceAfterNot +end + +class RuboCop::Cop::Layout::SpaceAfterSemicolon + include ::RuboCop::Cop::SpaceAfterPunctuation + def autocorrect(semicolon); end + + def kind(token); end + + def space_style_before_rcurly(); end +end + +class RuboCop::Cop::Layout::SpaceAfterSemicolon +end + +class RuboCop::Cop::Layout::SpaceAroundBlockParameters + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(target); end + + def on_block(node); end +end + +class RuboCop::Cop::Layout::SpaceAroundBlockParameters +end + +class RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault + include ::RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(range); end + + def on_optarg(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::SpaceAroundEqualsInParameterDefault +end + +class RuboCop::Cop::Layout::SpaceAroundKeyword + def autocorrect(range); end + + def on_and(node); end + + def on_block(node); end + + def on_break(node); end + + def on_case(node); end + + def on_defined?(node); end + + def on_ensure(node); end + + def on_for(node); end + + def on_if(node); end + + def on_kwbegin(node); end + + def on_next(node); end + + def on_or(node); end + + def on_postexe(node); end + + def on_preexe(node); end + + def on_resbody(node); end + + def on_rescue(node); end + + def on_return(node); end + + def on_send(node); end + + def on_super(node); end + + def on_until(node); end + + def on_when(node); end + + def on_while(node); end + + def on_yield(node); end + + def on_zsuper(node); end + ACCEPT_LEFT_PAREN = ::T.let(nil, ::T.untyped) + ACCEPT_LEFT_SQUARE_BRACKET = ::T.let(nil, ::T.untyped) + ACCEPT_NAMESPACE_OPERATOR = ::T.let(nil, ::T.untyped) + DO = ::T.let(nil, ::T.untyped) + MSG_AFTER = ::T.let(nil, ::T.untyped) + MSG_BEFORE = ::T.let(nil, ::T.untyped) + NAMESPACE_OPERATOR = ::T.let(nil, ::T.untyped) + SAFE_NAVIGATION = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::SpaceAroundKeyword +end + +class RuboCop::Cop::Layout::SpaceAroundOperators + include ::RuboCop::Cop::PrecedingFollowingAlignment + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::RationalLiteral + def autocorrect(range); end + + def on_and(node); end + + def on_and_asgn(node); end + + def on_assignment(node); end + + def on_binary(node); end + + def on_casgn(node); end + + def on_class(node); end + + def on_cvasgn(node); end + + def on_gvasgn(node); end + + def on_if(node); end + + def on_ivasgn(node); end + + def on_lvasgn(node); end + + def on_masgn(node); end + + def on_op_asgn(node); end + + def on_or(node); end + + def on_or_asgn(node); end + + def on_pair(node); end + + def on_resbody(node); end + + def on_send(node); end + + def on_special_asgn(node); end + EXCESSIVE_SPACE = ::T.let(nil, ::T.untyped) + IRREGULAR_METHODS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::SpaceAroundOperators +end + +class RuboCop::Cop::Layout::SpaceBeforeBlockBraces + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(range); end + + def on_block(node); end + DETECTED_MSG = ::T.let(nil, ::T.untyped) + MISSING_MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::SpaceBeforeBlockBraces +end + +class RuboCop::Cop::Layout::SpaceBeforeComma + include ::RuboCop::Cop::SpaceBeforePunctuation + include ::RuboCop::Cop::RangeHelp + def autocorrect(space); end + + def kind(token); end +end + +class RuboCop::Cop::Layout::SpaceBeforeComma +end + +class RuboCop::Cop::Layout::SpaceBeforeComment + def autocorrect(range); end + + def investigate(processed_source); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::SpaceBeforeComment +end + +class RuboCop::Cop::Layout::SpaceBeforeFirstArg + include ::RuboCop::Cop::PrecedingFollowingAlignment + include ::RuboCop::Cop::RangeHelp + def autocorrect(range); end + + def on_csend(node); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::SpaceBeforeFirstArg +end + +class RuboCop::Cop::Layout::SpaceBeforeSemicolon + include ::RuboCop::Cop::SpaceBeforePunctuation + include ::RuboCop::Cop::RangeHelp + def autocorrect(space); end + + def kind(token); end +end + +class RuboCop::Cop::Layout::SpaceBeforeSemicolon +end + +class RuboCop::Cop::Layout::SpaceInLambdaLiteral + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(lambda_node); end + + def on_send(node); end + MSG_REQUIRE_NO_SPACE = ::T.let(nil, ::T.untyped) + MSG_REQUIRE_SPACE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::SpaceInLambdaLiteral +end + +class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets + include ::RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def on_array(node); end + EMPTY_MSG = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets +end + +class RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral + include ::RuboCop::Cop::MatchRange + include ::RuboCop::Cop::PercentLiteral + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_array(node); end + + def on_percent_literal(node); end + MSG = ::T.let(nil, ::T.untyped) + MULTIPLE_SPACES_BETWEEN_ITEMS_REGEX = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::SpaceInsideArrayPercentLiteral +end + +class RuboCop::Cop::Layout::SpaceInsideBlockBraces + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::RangeHelp + def autocorrect(range); end + + def on_block(node); end +end + +class RuboCop::Cop::Layout::SpaceInsideBlockBraces +end + +class RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces + include ::RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(range); end + + def on_hash(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::SpaceInsideHashLiteralBraces +end + +class RuboCop::Cop::Layout::SpaceInsideParens + include ::RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(range); end + + def investigate(processed_source); end + MSG = ::T.let(nil, ::T.untyped) + MSG_SPACE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::SpaceInsideParens +end + +class RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters + include ::RuboCop::Cop::MatchRange + include ::RuboCop::Cop::PercentLiteral + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_array(node); end + + def on_percent_literal(node); end + + def on_xstr(node); end + BEGIN_REGEX = ::T.let(nil, ::T.untyped) + END_REGEX = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::SpaceInsidePercentLiteralDelimiters +end + +class RuboCop::Cop::Layout::SpaceInsideRangeLiteral + def autocorrect(node); end + + def on_erange(node); end + + def on_irange(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::SpaceInsideRangeLiteral +end + +class RuboCop::Cop::Layout::SpaceInsideReferenceBrackets + include ::RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def on_send(node); end + BRACKET_METHODS = ::T.let(nil, ::T.untyped) + EMPTY_MSG = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::SpaceInsideReferenceBrackets +end + +class RuboCop::Cop::Layout::SpaceInsideStringInterpolation + include ::RuboCop::Cop::Interpolation + include ::RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(begin_node); end + + def on_interpolation(begin_node); end + NO_SPACE_MSG = ::T.let(nil, ::T.untyped) + SPACE_MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::SpaceInsideStringInterpolation +end + +class RuboCop::Cop::Layout::Tab + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::RangeHelp + def autocorrect(range); end + + def investigate(processed_source); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::Tab +end + +class RuboCop::Cop::Layout::TrailingEmptyLines + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(range); end + + def investigate(processed_source); end +end + +class RuboCop::Cop::Layout::TrailingEmptyLines +end + +class RuboCop::Cop::Layout::TrailingWhitespace + include ::RuboCop::Cop::RangeHelp + def autocorrect(range); end + + def investigate(processed_source); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Layout::TrailingWhitespace +end + +module RuboCop::Cop::Layout +end + +class RuboCop::Cop::LineBreakCorrector +end + +class RuboCop::Cop::LineBreakCorrector + extend ::RuboCop::Cop::Alignment + extend ::RuboCop::Cop::TrailingBody + extend ::RuboCop::Cop::Util + extend ::RuboCop::PathUtil + def self.break_line_before(range:, node:, corrector:, configured_width:, indent_steps: T.unsafe(nil)); end + + def self.correct_trailing_body(configured_width:, corrector:, node:, processed_source:); end + + def self.move_comment(eol_comment:, node:, corrector:); end + + def self.processed_source(); end +end + +module RuboCop::Cop::LineLengthHelp +end + +module RuboCop::Cop::LineLengthHelp +end + +module RuboCop::Cop::Lint +end + +class RuboCop::Cop::Lint::AmbiguousBlockAssociation + def on_csend(node); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::AmbiguousBlockAssociation +end + +class RuboCop::Cop::Lint::AmbiguousOperator + include ::RuboCop::Cop::ParserDiagnostic + AMBIGUITIES = ::T.let(nil, ::T.untyped) + MSG_FORMAT = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::AmbiguousOperator +end + +class RuboCop::Cop::Lint::AmbiguousRegexpLiteral + include ::RuboCop::Cop::ParserDiagnostic + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::AmbiguousRegexpLiteral +end + +class RuboCop::Cop::Lint::AssignmentInCondition + include ::RuboCop::Cop::SafeAssignment + def on_if(node); end + + def on_until(node); end + + def on_while(node); end + ASGN_TYPES = ::T.let(nil, ::T.untyped) + MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED = ::T.let(nil, ::T.untyped) + MSG_WITH_SAFE_ASSIGNMENT_ALLOWED = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::AssignmentInCondition +end + +class RuboCop::Cop::Lint::BigDecimalNew + def autocorrect(node); end + + def big_decimal_new(node=T.unsafe(nil)); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::BigDecimalNew +end + +class RuboCop::Cop::Lint::BooleanSymbol + def boolean_symbol?(node=T.unsafe(nil)); end + + def on_sym(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::BooleanSymbol +end + +class RuboCop::Cop::Lint::CircularArgumentReference + def on_kwoptarg(node); end + + def on_optarg(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::CircularArgumentReference +end + +class RuboCop::Cop::Lint::Debugger + def binding_irb_call?(node=T.unsafe(nil)); end + + def debugger_call?(node=T.unsafe(nil)); end + + def kernel?(node=T.unsafe(nil)); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::Debugger +end + +class RuboCop::Cop::Lint::DeprecatedClassMethods + def autocorrect(node); end + + def on_send(node); end + DEPRECATED_METHODS_OBJECT = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::DeprecatedClassMethods::DeprecatedClassMethod + include ::RuboCop::AST::Sexp + def class_constant(); end + + def class_nodes(); end + + def deprecated_method(); end + + def initialize(deprecated:, replacement:, class_constant: T.unsafe(nil)); end + + def replacement_method(); end +end + +class RuboCop::Cop::Lint::DeprecatedClassMethods::DeprecatedClassMethod +end + +class RuboCop::Cop::Lint::DeprecatedClassMethods +end + +class RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor + def on_def(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::DisjunctiveAssignmentInConstructor +end + +class RuboCop::Cop::Lint::DuplicateCaseCondition + def on_case(case_node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::DuplicateCaseCondition +end + +class RuboCop::Cop::Lint::DuplicateHashKey + include ::RuboCop::Cop::Duplication + def on_hash(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::DuplicateHashKey +end + +class RuboCop::Cop::Lint::DuplicateMethods + def alias_method?(node=T.unsafe(nil)); end + + def attr?(node=T.unsafe(nil)); end + + def method_alias?(node=T.unsafe(nil)); end + + def on_alias(node); end + + def on_def(node); end + + def on_defs(node); end + + def on_send(node); end + + def sym_name(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::DuplicateMethods +end + +class RuboCop::Cop::Lint::EachWithObjectArgument + def each_with_object?(node=T.unsafe(nil)); end + + def on_csend(node); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::EachWithObjectArgument +end + +class RuboCop::Cop::Lint::ElseLayout + def on_if(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::ElseLayout +end + +class RuboCop::Cop::Lint::EmptyEnsure + def autocorrect(node); end + + def on_ensure(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::EmptyEnsure +end + +class RuboCop::Cop::Lint::EmptyExpression + def on_begin(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::EmptyExpression +end + +class RuboCop::Cop::Lint::EmptyInterpolation + include ::RuboCop::Cop::Interpolation + def autocorrect(node); end + + def on_interpolation(begin_node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::EmptyInterpolation +end + +class RuboCop::Cop::Lint::EmptyWhen + def on_case(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::EmptyWhen +end + +class RuboCop::Cop::Lint::EndInMethod + def on_postexe(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::EndInMethod +end + +class RuboCop::Cop::Lint::EnsureReturn + def on_ensure(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::EnsureReturn +end + +class RuboCop::Cop::Lint::ErbNewArguments + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def erb_new_with_non_keyword_arguments(node=T.unsafe(nil)); end + + def on_send(node); end + MESSAGES = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::ErbNewArguments + extend ::RuboCop::Cop::TargetRubyVersion +end + +class RuboCop::Cop::Lint::FlipFlop + def on_eflipflop(node); end + + def on_iflipflop(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::FlipFlop +end + +class RuboCop::Cop::Lint::FloatOutOfRange + def on_float(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::FloatOutOfRange +end + +class RuboCop::Cop::Lint::FormatParameterMismatch + def called_on_string?(node=T.unsafe(nil)); end + + def on_send(node); end + KERNEL = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) + SHOVEL = ::T.let(nil, ::T.untyped) + STRING_TYPES = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::FormatParameterMismatch +end + +class RuboCop::Cop::Lint::HeredocMethodCallPosition + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_csend(node); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::HeredocMethodCallPosition +end + +class RuboCop::Cop::Lint::ImplicitStringConcatenation + def on_dstr(node); end + FOR_ARRAY = ::T.let(nil, ::T.untyped) + FOR_METHOD = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::ImplicitStringConcatenation +end + +class RuboCop::Cop::Lint::IneffectiveAccessModifier + def on_class(node); end + + def on_module(node); end + + def private_class_methods(node0); end + ALTERNATIVE_PRIVATE = ::T.let(nil, ::T.untyped) + ALTERNATIVE_PROTECTED = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::IneffectiveAccessModifier +end + +class RuboCop::Cop::Lint::InheritException + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def class_new_call?(node=T.unsafe(nil)); end + + def on_class(node); end + + def on_send(node); end + ILLEGAL_CLASSES = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) + PREFERRED_BASE_CLASS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::InheritException +end + +class RuboCop::Cop::Lint::InterpolationCheck + def heredoc?(node); end + + def on_str(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::InterpolationCheck +end + +class RuboCop::Cop::Lint::LiteralAsCondition + def message(node); end + + def on_case(case_node); end + + def on_if(node); end + + def on_send(node); end + + def on_until(node); end + + def on_until_post(node); end + + def on_while(node); end + + def on_while_post(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::LiteralAsCondition +end + +class RuboCop::Cop::Lint::LiteralInInterpolation + include ::RuboCop::Cop::Interpolation + include ::RuboCop::Cop::PercentLiteral + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_interpolation(begin_node); end + COMPOSITE = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::LiteralInInterpolation +end + +class RuboCop::Cop::Lint::Loop + def on_until_post(node); end + + def on_while_post(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::Loop +end + +class RuboCop::Cop::Lint::MissingCopEnableDirective + include ::RuboCop::Cop::RangeHelp + def investigate(processed_source); end + MSG = ::T.let(nil, ::T.untyped) + MSG_BOUND = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::MissingCopEnableDirective +end + +class RuboCop::Cop::Lint::MultipleComparison + def autocorrect(node); end + + def multiple_compare?(node=T.unsafe(nil)); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::MultipleComparison +end + +class RuboCop::Cop::Lint::NestedMethodDefinition + def class_or_module_or_struct_new_call?(node=T.unsafe(nil)); end + + def eval_call?(node=T.unsafe(nil)); end + + def exec_call?(node=T.unsafe(nil)); end + + def on_def(node); end + + def on_defs(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::NestedMethodDefinition +end + +class RuboCop::Cop::Lint::NestedPercentLiteral + include ::RuboCop::Cop::PercentLiteral + include ::RuboCop::Cop::RangeHelp + def on_array(node); end + + def on_percent_literal(node); end + MSG = ::T.let(nil, ::T.untyped) + PERCENT_LITERAL_TYPES = ::T.let(nil, ::T.untyped) + REGEXES = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::NestedPercentLiteral +end + +class RuboCop::Cop::Lint::NextWithoutAccumulator + def on_block(node); end + + def on_body_of_reduce(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::NextWithoutAccumulator +end + +class RuboCop::Cop::Lint::NonDeterministicRequireOrder + def autocorrect(node); end + + def loop_variable(node=T.unsafe(nil)); end + + def on_block(node); end + + def unsorted_dir_block?(node=T.unsafe(nil)); end + + def unsorted_dir_each?(node=T.unsafe(nil)); end + + def var_is_required?(node0, param1); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::NonDeterministicRequireOrder +end + +class RuboCop::Cop::Lint::NonLocalExitFromIterator + def chained_send?(node=T.unsafe(nil)); end + + def define_method?(node=T.unsafe(nil)); end + + def on_return(return_node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::NonLocalExitFromIterator +end + +class RuboCop::Cop::Lint::NumberConversion + def autocorrect(node); end + + def datetime?(node=T.unsafe(nil)); end + + def on_send(node); end + + def to_method(node=T.unsafe(nil)); end + CONVERSION_METHOD_CLASS_MAPPING = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::NumberConversion +end + +class RuboCop::Cop::Lint::OrderedMagicComments + include ::RuboCop::Cop::FrozenStringLiteral + def autocorrect(_node); end + + def investigate(processed_source); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::OrderedMagicComments +end + +class RuboCop::Cop::Lint::ParenthesesAsGroupedExpression + include ::RuboCop::Cop::RangeHelp + def on_csend(node); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::ParenthesesAsGroupedExpression +end + +class RuboCop::Cop::Lint::PercentStringArray + include ::RuboCop::Cop::PercentLiteral + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_array(node); end + + def on_percent_literal(node); end + LEADING_QUOTE = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) + QUOTES_AND_COMMAS = ::T.let(nil, ::T.untyped) + TRAILING_QUOTE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::PercentStringArray +end + +class RuboCop::Cop::Lint::PercentSymbolArray + include ::RuboCop::Cop::PercentLiteral + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_array(node); end + + def on_percent_literal(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::PercentSymbolArray +end + +class RuboCop::Cop::Lint::RandOne + def on_send(node); end + + def rand_one?(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::RandOne +end + +class RuboCop::Cop::Lint::RedundantCopDisableDirective + include ::RuboCop::NameSimilarity + include ::RuboCop::Cop::RangeHelp + def autocorrect(args); end + + def check(offenses, cop_disabled_line_ranges, comments); end + COP_NAME = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::RedundantCopDisableDirective +end + +class RuboCop::Cop::Lint::RedundantCopEnableDirective + include ::RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::RangeHelp + def autocorrect(comment_and_name); end + + def investigate(processed_source); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::RedundantCopEnableDirective +end + +class RuboCop::Cop::Lint::RedundantRequireStatement + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_send(node); end + + def unnecessary_require_statement?(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::RedundantRequireStatement +end + +class RuboCop::Cop::Lint::RedundantSplatExpansion + def array_new?(node=T.unsafe(nil)); end + + def autocorrect(node); end + + def literal_expansion(node=T.unsafe(nil)); end + + def on_splat(node); end + ARRAY_PARAM_MSG = ::T.let(nil, ::T.untyped) + ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) + PERCENT_CAPITAL_I = ::T.let(nil, ::T.untyped) + PERCENT_CAPITAL_W = ::T.let(nil, ::T.untyped) + PERCENT_I = ::T.let(nil, ::T.untyped) + PERCENT_W = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::RedundantSplatExpansion +end + +class RuboCop::Cop::Lint::RedundantStringCoercion + include ::RuboCop::Cop::Interpolation + def autocorrect(node); end + + def on_interpolation(begin_node); end + + def to_s_without_args?(node=T.unsafe(nil)); end + MSG_DEFAULT = ::T.let(nil, ::T.untyped) + MSG_SELF = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::RedundantStringCoercion +end + +class RuboCop::Cop::Lint::RedundantWithIndex + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_block(node); end + + def redundant_with_index?(node=T.unsafe(nil)); end + MSG_EACH_WITH_INDEX = ::T.let(nil, ::T.untyped) + MSG_WITH_INDEX = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::RedundantWithIndex +end + +class RuboCop::Cop::Lint::RedundantWithObject + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_block(node); end + + def redundant_with_object?(node=T.unsafe(nil)); end + MSG_EACH_WITH_OBJECT = ::T.let(nil, ::T.untyped) + MSG_WITH_OBJECT = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::RedundantWithObject +end + +class RuboCop::Cop::Lint::RegexpAsCondition + def on_match_current_line(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::RegexpAsCondition +end + +class RuboCop::Cop::Lint::RequireParentheses + include ::RuboCop::Cop::RangeHelp + def on_csend(node); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::RequireParentheses +end + +class RuboCop::Cop::Lint::RescueException + def on_resbody(node); end + + def targets_exception?(rescue_arg_node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::RescueException +end + +class RuboCop::Cop::Lint::RescueType + include ::RuboCop::Cop::RescueNode + def autocorrect(node); end + + def on_resbody(node); end + INVALID_TYPES = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::RescueType +end + +class RuboCop::Cop::Lint::ReturnInVoidContext + def on_return(return_node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::ReturnInVoidContext +end + +class RuboCop::Cop::Lint::SafeNavigationChain + include ::RuboCop::Cop::NilMethods + def bad_method?(node=T.unsafe(nil)); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::SafeNavigationChain +end + +class RuboCop::Cop::Lint::SafeNavigationConsistency + include ::RuboCop::Cop::NilMethods + def autocorrect(node); end + + def check(node); end + + def on_csend(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::SafeNavigationConsistency +end + +class RuboCop::Cop::Lint::SafeNavigationWithEmpty + def on_if(node); end + + def safe_navigation_empty_in_conditional?(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::SafeNavigationWithEmpty +end + +class RuboCop::Cop::Lint::ScriptPermission + def autocorrect(node); end + + def investigate(processed_source); end + MSG = ::T.let(nil, ::T.untyped) + SHEBANG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::ScriptPermission +end + +class RuboCop::Cop::Lint::SendWithMixinArgument + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_send(node); end + + def send_with_mixin_argument?(node=T.unsafe(nil)); end + MIXIN_METHODS = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::SendWithMixinArgument +end + +class RuboCop::Cop::Lint::ShadowedArgument + def after_leaving_scope(scope, _variable_table); end + + def join_force?(force_class); end + + def uses_var?(node0, param1); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::ShadowedArgument +end + +class RuboCop::Cop::Lint::ShadowedException + include ::RuboCop::Cop::RescueNode + include ::RuboCop::Cop::RangeHelp + def on_rescue(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::ShadowedException +end + +class RuboCop::Cop::Lint::ShadowingOuterLocalVariable + def before_declaring_variable(variable, variable_table); end + + def join_force?(force_class); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::ShadowingOuterLocalVariable +end + +class RuboCop::Cop::Lint::SuppressedException + def on_resbody(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::SuppressedException +end + +class RuboCop::Cop::Lint::Syntax + def add_offense_from_diagnostic(diagnostic, ruby_version); end + + def add_offense_from_error(error); end + ERROR_SOURCE_RANGE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::Syntax::PseudoSourceRange + def begin_pos(); end + + def begin_pos=(_); end + + def column(); end + + def column=(_); end + + def end_pos(); end + + def end_pos=(_); end + + def line(); end + + def line=(_); end + + def source_line(); end + + def source_line=(_); end +end + +class RuboCop::Cop::Lint::Syntax::PseudoSourceRange + def self.[](*_); end + + def self.members(); end +end + +class RuboCop::Cop::Lint::Syntax + def self.offenses_from_processed_source(processed_source, config, options); end +end + +class RuboCop::Cop::Lint::ToJSON + def autocorrect(node); end + + def on_def(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::ToJSON +end + +class RuboCop::Cop::Lint::UnderscorePrefixedVariableName + def after_leaving_scope(scope, _variable_table); end + + def check_variable(variable); end + + def join_force?(force_class); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::UnderscorePrefixedVariableName +end + +class RuboCop::Cop::Lint::UnifiedInteger + def autocorrect(node); end + + def fixnum_or_bignum_const(node=T.unsafe(nil)); end + + def on_const(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::UnifiedInteger +end + +class RuboCop::Cop::Lint::UnreachableCode + def flow_command?(node=T.unsafe(nil)); end + + def on_begin(node); end + + def on_kwbegin(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::UnreachableCode +end + +module RuboCop::Cop::Lint::UnusedArgument + def after_leaving_scope(scope, _variable_table); end + + def join_force?(force_class); end +end + +module RuboCop::Cop::Lint::UnusedArgument + extend ::RuboCop::NodePattern::Macros +end + +class RuboCop::Cop::Lint::UnusedBlockArgument + include ::RuboCop::Cop::Lint::UnusedArgument + def autocorrect(node); end +end + +class RuboCop::Cop::Lint::UnusedBlockArgument +end + +class RuboCop::Cop::Lint::UnusedMethodArgument + include ::RuboCop::Cop::Lint::UnusedArgument + def autocorrect(node); end +end + +class RuboCop::Cop::Lint::UnusedMethodArgument +end + +class RuboCop::Cop::Lint::UriEscapeUnescape + def on_send(node); end + + def uri_escape_unescape?(node=T.unsafe(nil)); end + ALTERNATE_METHODS_OF_URI_ESCAPE = ::T.let(nil, ::T.untyped) + ALTERNATE_METHODS_OF_URI_UNESCAPE = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::UriEscapeUnescape +end + +class RuboCop::Cop::Lint::UriRegexp + def autocorrect(node); end + + def on_send(node); end + + def uri_regexp_with_argument?(node=T.unsafe(nil)); end + + def uri_regexp_without_argument?(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::UriRegexp +end + +class RuboCop::Cop::Lint::UselessAccessModifier + def class_or_instance_eval?(node=T.unsafe(nil)); end + + def class_or_module_or_struct_new_call?(node=T.unsafe(nil)); end + + def dynamic_method_definition?(node=T.unsafe(nil)); end + + def on_block(node); end + + def on_class(node); end + + def on_module(node); end + + def on_sclass(node); end + + def static_method_definition?(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::UselessAccessModifier +end + +class RuboCop::Cop::Lint::UselessAssignment + include ::RuboCop::NameSimilarity + def after_leaving_scope(scope, _variable_table); end + + def check_for_unused_assignments(variable); end + + def collect_variable_like_names(scope); end + + def join_force?(force_class); end + + def message_for_useless_assignment(assignment); end + + def message_specification(assignment, variable); end + + def multiple_assignment_message(variable_name); end + + def operator_assignment_message(scope, assignment); end + + def return_value_node_of_scope(scope); end + + def similar_name_message(variable); end + + def variable_like_method_invocation?(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::UselessAssignment +end + +class RuboCop::Cop::Lint::UselessComparison + def on_send(node); end + + def useless_comparison?(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) + OPS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::UselessComparison +end + +class RuboCop::Cop::Lint::UselessElseWithoutRescue + include ::RuboCop::Cop::ParserDiagnostic + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::UselessElseWithoutRescue +end + +class RuboCop::Cop::Lint::UselessSetterCall + def on_def(node); end + + def on_defs(node); end + + def setter_call_to_local_variable?(node=T.unsafe(nil)); end + ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::UselessSetterCall::MethodVariableTracker + def constructor?(node); end + + def contain_local_object?(variable_name); end + + def initialize(body_node); end + + def process_assignment(asgn_node, rhs_node); end + + def process_assignment_node(node); end + + def process_binary_operator_assignment(op_asgn_node); end + + def process_logical_operator_assignment(asgn_node); end + + def process_multiple_assignment(masgn_node); end + + def scan(node, &block); end +end + +class RuboCop::Cop::Lint::UselessSetterCall::MethodVariableTracker +end + +class RuboCop::Cop::Lint::UselessSetterCall +end + +class RuboCop::Cop::Lint::Void + def on_begin(node); end + + def on_block(node); end + + def on_kwbegin(node); end + BINARY_OPERATORS = ::T.let(nil, ::T.untyped) + DEFINED_MSG = ::T.let(nil, ::T.untyped) + LIT_MSG = ::T.let(nil, ::T.untyped) + NONMUTATING_METHODS = ::T.let(nil, ::T.untyped) + NONMUTATING_MSG = ::T.let(nil, ::T.untyped) + OPERATORS = ::T.let(nil, ::T.untyped) + OP_MSG = ::T.let(nil, ::T.untyped) + SELF_MSG = ::T.let(nil, ::T.untyped) + UNARY_OPERATORS = ::T.let(nil, ::T.untyped) + VAR_MSG = ::T.let(nil, ::T.untyped) + VOID_CONTEXT_TYPES = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Lint::Void +end + +module RuboCop::Cop::Lint +end + +module RuboCop::Cop::MatchRange + include ::RuboCop::Cop::RangeHelp +end + +module RuboCop::Cop::MatchRange +end + +class RuboCop::Cop::MessageAnnotator + def annotate(message); end + + def config(); end + + def cop_config(); end + + def cop_name(); end + + def initialize(config, cop_name, cop_config, options); end + + def options(); end + + def urls(); end +end + +class RuboCop::Cop::MessageAnnotator + def self.style_guide_urls(); end +end + +module RuboCop::Cop::MethodComplexity + include ::RuboCop::Cop::ConfigurableMax + def define_method?(node=T.unsafe(nil)); end + + def on_block(node); end + + def on_def(node); end + + def on_defs(node); end +end + +module RuboCop::Cop::MethodComplexity + extend ::RuboCop::NodePattern::Macros +end + +module RuboCop::Cop::MethodPreference +end + +module RuboCop::Cop::MethodPreference +end + +module RuboCop::Cop::Metrics +end + +class RuboCop::Cop::Metrics::AbcSize + include ::RuboCop::Cop::MethodComplexity + include ::RuboCop::Cop::ConfigurableMax + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Metrics::AbcSize +end + +class RuboCop::Cop::Metrics::BlockLength + include ::RuboCop::Cop::TooManyLines + include ::RuboCop::Cop::CodeLength + include ::RuboCop::Cop::ConfigurableMax + def on_block(node); end + LABEL = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Metrics::BlockLength +end + +class RuboCop::Cop::Metrics::BlockNesting + include ::RuboCop::Cop::ConfigurableMax + def investigate(processed_source); end + NESTING_BLOCKS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Metrics::BlockNesting +end + +class RuboCop::Cop::Metrics::ClassLength + include ::RuboCop::Cop::ClassishLength + include ::RuboCop::Cop::CodeLength + include ::RuboCop::Cop::ConfigurableMax + def class_definition?(node=T.unsafe(nil)); end + + def on_casgn(node); end + + def on_class(node); end +end + +class RuboCop::Cop::Metrics::ClassLength +end + +class RuboCop::Cop::Metrics::CyclomaticComplexity + include ::RuboCop::Cop::MethodComplexity + include ::RuboCop::Cop::ConfigurableMax + COUNTED_NODES = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Metrics::CyclomaticComplexity +end + +class RuboCop::Cop::Metrics::MethodLength + include ::RuboCop::Cop::TooManyLines + include ::RuboCop::Cop::CodeLength + include ::RuboCop::Cop::ConfigurableMax + def on_block(node); end + + def on_def(node); end + + def on_defs(node); end + LABEL = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Metrics::MethodLength +end + +class RuboCop::Cop::Metrics::ModuleLength + include ::RuboCop::Cop::ClassishLength + include ::RuboCop::Cop::CodeLength + include ::RuboCop::Cop::ConfigurableMax + def module_definition?(node=T.unsafe(nil)); end + + def on_casgn(node); end + + def on_module(node); end +end + +class RuboCop::Cop::Metrics::ModuleLength +end + +class RuboCop::Cop::Metrics::ParameterLists + include ::RuboCop::Cop::ConfigurableMax + def argument_to_lambda_or_proc?(node=T.unsafe(nil)); end + + def on_args(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Metrics::ParameterLists +end + +class RuboCop::Cop::Metrics::PerceivedComplexity + include ::RuboCop::Cop::MethodComplexity + include ::RuboCop::Cop::ConfigurableMax + COUNTED_NODES = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Metrics::PerceivedComplexity +end + +module RuboCop::Cop::Metrics::Utils +end + +class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator + def calculate(); end + + def else_branch?(node); end + + def evaluate_branch_nodes(node); end + + def evaluate_condition_node(node); end + + def initialize(node); end + BRANCH_NODES = ::T.let(nil, ::T.untyped) + CONDITION_NODES = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator + def self.calculate(node); end +end + +module RuboCop::Cop::Metrics::Utils +end + +module RuboCop::Cop::Metrics +end + +module RuboCop::Cop::Migration +end + +class RuboCop::Cop::Migration::DepartmentName + include ::RuboCop::Cop::RangeHelp + def autocorrect(range); end + + def investigate(processed_source); end + DISABLE_COMMENT_FORMAT = ::T.let(nil, ::T.untyped) + DISABLING_COPS_CONTENT_TOKEN = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Migration::DepartmentName +end + +module RuboCop::Cop::Migration +end + +module RuboCop::Cop::MinBodyLength +end + +module RuboCop::Cop::MinBodyLength +end + +module RuboCop::Cop::MultilineElementIndentation +end + +module RuboCop::Cop::MultilineElementIndentation +end + +module RuboCop::Cop::MultilineElementLineBreaks +end + +module RuboCop::Cop::MultilineElementLineBreaks +end + +module RuboCop::Cop::MultilineExpressionIndentation + def on_send(node); end + ASSIGNMENT_MESSAGE_TAIL = ::T.let(nil, ::T.untyped) + DEFAULT_MESSAGE_TAIL = ::T.let(nil, ::T.untyped) + KEYWORD_ANCESTOR_TYPES = ::T.let(nil, ::T.untyped) + KEYWORD_MESSAGE_TAIL = ::T.let(nil, ::T.untyped) + UNALIGNED_RHS_TYPES = ::T.let(nil, ::T.untyped) +end + +module RuboCop::Cop::MultilineExpressionIndentation +end + +class RuboCop::Cop::MultilineLiteralBraceCorrector + include ::RuboCop::Cop::MultilineLiteralBraceLayout + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def call(corrector); end + + def initialize(node, processed_source); end +end + +class RuboCop::Cop::MultilineLiteralBraceCorrector +end + +module RuboCop::Cop::MultilineLiteralBraceLayout + include ::RuboCop::Cop::ConfigurableEnforcedStyle +end + +module RuboCop::Cop::MultilineLiteralBraceLayout +end + +module RuboCop::Cop::Naming +end + +class RuboCop::Cop::Naming::AccessorMethodName + def on_def(node); end + + def on_defs(node); end + MSG_READER = ::T.let(nil, ::T.untyped) + MSG_WRITER = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Naming::AccessorMethodName +end + +class RuboCop::Cop::Naming::AsciiIdentifiers + include ::RuboCop::Cop::RangeHelp + def investigate(processed_source); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Naming::AsciiIdentifiers +end + +class RuboCop::Cop::Naming::BinaryOperatorParameterName + def on_def(node); end + + def op_method_candidate?(node=T.unsafe(nil)); end + BLACKLISTED = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) + OP_LIKE_METHODS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Naming::BinaryOperatorParameterName +end + +class RuboCop::Cop::Naming::BlockParameterName + include ::RuboCop::Cop::UncommunicativeName + def on_block(node); end +end + +class RuboCop::Cop::Naming::BlockParameterName +end + +class RuboCop::Cop::Naming::ClassAndModuleCamelCase + def on_class(node); end + + def on_module(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Naming::ClassAndModuleCamelCase +end + +class RuboCop::Cop::Naming::ConstantName + def class_or_struct_return_method?(node=T.unsafe(nil)); end + + def literal_receiver?(node=T.unsafe(nil)); end + + def on_casgn(node); end + MSG = ::T.let(nil, ::T.untyped) + SNAKE_CASE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Naming::ConstantName +end + +class RuboCop::Cop::Naming::FileName + include ::RuboCop::Cop::RangeHelp + def investigate(processed_source); end + MSG_NO_DEFINITION = ::T.let(nil, ::T.untyped) + MSG_REGEX = ::T.let(nil, ::T.untyped) + MSG_SNAKE_CASE = ::T.let(nil, ::T.untyped) + SNAKE_CASE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Naming::FileName +end + +class RuboCop::Cop::Naming::HeredocDelimiterCase + include ::RuboCop::Cop::Heredoc + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def on_heredoc(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Naming::HeredocDelimiterCase +end + +class RuboCop::Cop::Naming::HeredocDelimiterNaming + include ::RuboCop::Cop::Heredoc + def on_heredoc(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Naming::HeredocDelimiterNaming +end + +class RuboCop::Cop::Naming::MemoizedInstanceVariableName + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def memoized?(node=T.unsafe(nil)); end + + def on_def(node); end + + def on_defs(node); end + MSG = ::T.let(nil, ::T.untyped) + UNDERSCORE_REQUIRED = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Naming::MemoizedInstanceVariableName +end + +class RuboCop::Cop::Naming::MethodName + include ::RuboCop::Cop::ConfigurableNaming + include ::RuboCop::Cop::ConfigurableFormatting + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::IgnoredPattern + def on_def(node); end + + def on_defs(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Naming::MethodName +end + +class RuboCop::Cop::Naming::MethodParameterName + include ::RuboCop::Cop::UncommunicativeName + def on_def(node); end + + def on_defs(node); end +end + +class RuboCop::Cop::Naming::MethodParameterName +end + +class RuboCop::Cop::Naming::PredicateName + def dynamic_method_define(node=T.unsafe(nil)); end + + def on_def(node); end + + def on_defs(node); end + + def on_send(node); end +end + +class RuboCop::Cop::Naming::PredicateName +end + +class RuboCop::Cop::Naming::RescuedExceptionsVariableName + def autocorrect(node); end + + def on_resbody(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Naming::RescuedExceptionsVariableName +end + +class RuboCop::Cop::Naming::VariableName + include ::RuboCop::Cop::ConfigurableNaming + include ::RuboCop::Cop::ConfigurableFormatting + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def on_arg(node); end + + def on_blockarg(node); end + + def on_cvasgn(node); end + + def on_ivasgn(node); end + + def on_kwarg(node); end + + def on_kwoptarg(node); end + + def on_kwrestarg(node); end + + def on_lvar(node); end + + def on_lvasgn(node); end + + def on_optarg(node); end + + def on_restarg(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Naming::VariableName +end + +class RuboCop::Cop::Naming::VariableNumber + include ::RuboCop::Cop::ConfigurableNumbering + include ::RuboCop::Cop::ConfigurableFormatting + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def on_arg(node); end + + def on_cvasgn(node); end + + def on_ivasgn(node); end + + def on_lvasgn(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Naming::VariableNumber +end + +module RuboCop::Cop::Naming +end + +module RuboCop::Cop::NegativeConditional + def empty_condition?(node=T.unsafe(nil)); end + + def single_negative?(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +module RuboCop::Cop::NegativeConditional + extend ::RuboCop::NodePattern::Macros +end + +module RuboCop::Cop::NilMethods +end + +module RuboCop::Cop::NilMethods +end + +class RuboCop::Cop::Offense + include ::Comparable + def ==(other); end + + def column(); end + + def column_length(); end + + def column_range(); end + + def cop_name(); end + + def correctable?(); end + + def corrected?(); end + + def corrected_with_todo?(); end + + def disabled?(); end + + def eql?(other); end + + def first_line(); end + + def highlighted_area(); end + + def initialize(severity, location, message, cop_name, status=T.unsafe(nil)); end + + def last_column(); end + + def last_line(); end + + def line(); end + + def location(); end + + def message(); end + + def real_column(); end + + def severity(); end + + def source_line(); end + + def status(); end + COMPARISON_ATTRIBUTES = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Offense +end + +module RuboCop::Cop::OnNormalIfUnless + def on_if(node); end +end + +module RuboCop::Cop::OnNormalIfUnless +end + +class RuboCop::Cop::OrderedGemCorrector +end + +class RuboCop::Cop::OrderedGemCorrector + extend ::RuboCop::Cop::OrderedGemNode + def self.comments_as_separators(); end + + def self.correct(processed_source, node, previous_declaration, comments_as_separators); end + + def self.processed_source(); end +end + +module RuboCop::Cop::OrderedGemNode +end + +module RuboCop::Cop::OrderedGemNode +end + +module RuboCop::Cop::Parentheses +end + +module RuboCop::Cop::Parentheses +end + +class RuboCop::Cop::ParenthesesCorrector +end + +class RuboCop::Cop::ParenthesesCorrector + def self.correct(node); end +end + +module RuboCop::Cop::ParserDiagnostic + def investigate(processed_source); end +end + +module RuboCop::Cop::ParserDiagnostic +end + +module RuboCop::Cop::PercentArray +end + +module RuboCop::Cop::PercentArray +end + +module RuboCop::Cop::PercentLiteral + include ::RuboCop::Cop::RangeHelp +end + +module RuboCop::Cop::PercentLiteral +end + +class RuboCop::Cop::PercentLiteralCorrector + include ::RuboCop::Cop::Util + include ::RuboCop::PathUtil + def config(); end + + def correct(node, char); end + + def initialize(config, preferred_delimiters); end + + def preferred_delimiters(); end +end + +class RuboCop::Cop::PercentLiteralCorrector +end + +module RuboCop::Cop::PrecedingFollowingAlignment +end + +module RuboCop::Cop::PrecedingFollowingAlignment +end + +class RuboCop::Cop::PreferredDelimiters + def config(); end + + def delimiters(); end + + def initialize(type, config, preferred_delimiters); end + + def type(); end + PERCENT_LITERAL_TYPES = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::PreferredDelimiters +end + +class RuboCop::Cop::PunctuationCorrector +end + +class RuboCop::Cop::PunctuationCorrector + def self.add_space(token); end + + def self.remove_space(space_before); end + + def self.swap_comma(range); end +end + +module RuboCop::Cop::RangeHelp + BYTE_ORDER_MARK = ::T.let(nil, ::T.untyped) +end + +module RuboCop::Cop::RangeHelp +end + +module RuboCop::Cop::RationalLiteral + def rational_literal?(node=T.unsafe(nil)); end +end + +module RuboCop::Cop::RationalLiteral + extend ::RuboCop::NodePattern::Macros +end + +class RuboCop::Cop::Registry + def ==(other); end + + def contains_cop_matching?(names); end + + def cops(); end + + def department_missing?(badge, name); end + + def departments(); end + + def each(&block); end + + def enabled(config, only, only_safe=T.unsafe(nil)); end + + def enabled?(cop, config, only_safe); end + + def enlist(cop); end + + def find_by_cop_name(cop_name); end + + def initialize(cops=T.unsafe(nil)); end + + def length(); end + + def names(); end + + def print_warning(name, path); end + + def qualified_cop_name(name, path, shall_warn=T.unsafe(nil)); end + + def select(&block); end + + def sort!(); end + + def to_h(); end + + def unqualified_cop_names(); end + + def with_department(department); end + + def without_department(department); end +end + +class RuboCop::Cop::Registry +end + +module RuboCop::Cop::RescueNode + def investigate(processed_source); end +end + +module RuboCop::Cop::RescueNode +end + +module RuboCop::Cop::SafeAssignment + def empty_condition?(node=T.unsafe(nil)); end + + def safe_assignment?(node=T.unsafe(nil)); end + + def setter_method?(node=T.unsafe(nil)); end +end + +module RuboCop::Cop::SafeAssignment + extend ::RuboCop::NodePattern::Macros +end + +module RuboCop::Cop::Security +end + +class RuboCop::Cop::Security::Eval + def eval?(node=T.unsafe(nil)); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Security::Eval +end + +class RuboCop::Cop::Security::JSONLoad + def autocorrect(node); end + + def json_load(node=T.unsafe(nil)); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Security::JSONLoad +end + +class RuboCop::Cop::Security::MarshalLoad + def marshal_load(node=T.unsafe(nil)); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Security::MarshalLoad +end + +class RuboCop::Cop::Security::Open + def on_send(node); end + + def open?(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Security::Open +end + +class RuboCop::Cop::Security::YAMLLoad + def autocorrect(node); end + + def on_send(node); end + + def yaml_load(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Security::YAMLLoad +end + +module RuboCop::Cop::Security +end + +class RuboCop::Cop::Severity + include ::Comparable + def ==(other); end + + def code(); end + + def initialize(name_or_code); end + + def level(); end + + def name(); end + CODE_TABLE = ::T.let(nil, ::T.untyped) + NAMES = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Severity + def self.name_from_code(code); end +end + +module RuboCop::Cop::SpaceAfterPunctuation + def investigate(processed_source); end + MSG = ::T.let(nil, ::T.untyped) +end + +module RuboCop::Cop::SpaceAfterPunctuation +end + +module RuboCop::Cop::SpaceBeforePunctuation + include ::RuboCop::Cop::RangeHelp + def investigate(processed_source); end + MSG = ::T.let(nil, ::T.untyped) +end + +module RuboCop::Cop::SpaceBeforePunctuation +end + +class RuboCop::Cop::SpaceCorrector +end + +class RuboCop::Cop::SpaceCorrector + extend ::RuboCop::Cop::SurroundingSpace + extend ::RuboCop::Cop::RangeHelp + def self.add_space(processed_source, corrector, left_token, right_token); end + + def self.empty_corrections(processed_source, corrector, empty_config, left_token, right_token); end + + def self.processed_source(); end + + def self.remove_space(processed_source, corrector, left_token, right_token); end +end + +module RuboCop::Cop::StatementModifier +end + +module RuboCop::Cop::StatementModifier +end + +module RuboCop::Cop::StringHelp + def on_regexp(node); end + + def on_str(node); end +end + +module RuboCop::Cop::StringHelp +end + +class RuboCop::Cop::StringLiteralCorrector +end + +class RuboCop::Cop::StringLiteralCorrector + extend ::RuboCop::Cop::Util + extend ::RuboCop::PathUtil + def self.correct(node, style); end +end + +module RuboCop::Cop::StringLiteralsHelp + include ::RuboCop::Cop::StringHelp +end + +module RuboCop::Cop::StringLiteralsHelp +end + +module RuboCop::Cop::Style +end + +class RuboCop::Cop::Style::AccessModifierDeclarations + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def on_send(node); end + GROUP_STYLE_MESSAGE = ::T.let(nil, ::T.untyped) + INLINE_STYLE_MESSAGE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::AccessModifierDeclarations +end + +class RuboCop::Cop::Style::Alias + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def identifier(node=T.unsafe(nil)); end + + def on_alias(node); end + + def on_send(node); end + MSG_ALIAS = ::T.let(nil, ::T.untyped) + MSG_ALIAS_METHOD = ::T.let(nil, ::T.untyped) + MSG_SYMBOL_ARGS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::Alias +end + +class RuboCop::Cop::Style::AndOr + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_and(node); end + + def on_if(node); end + + def on_or(node); end + + def on_until(node); end + + def on_until_post(node); end + + def on_while(node); end + + def on_while_post(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::AndOr +end + +module RuboCop::Cop::Style::AnnotationComment +end + +module RuboCop::Cop::Style::AnnotationComment +end + +class RuboCop::Cop::Style::ArrayJoin + def autocorrect(node); end + + def join_candidate?(node=T.unsafe(nil)); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::ArrayJoin +end + +class RuboCop::Cop::Style::AsciiComments + include ::RuboCop::Cop::RangeHelp + def investigate(processed_source); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::AsciiComments +end + +class RuboCop::Cop::Style::Attr + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def class_eval?(node=T.unsafe(nil)); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::Attr +end + +class RuboCop::Cop::Style::AutoResourceCleanup + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) + TARGET_METHODS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::AutoResourceCleanup +end + +class RuboCop::Cop::Style::BarePercentLiterals + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def on_dstr(node); end + + def on_str(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::BarePercentLiterals +end + +class RuboCop::Cop::Style::BeginBlock + def on_preexe(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::BeginBlock +end + +class RuboCop::Cop::Style::BlockComments + include ::RuboCop::Cop::RangeHelp + def autocorrect(comment); end + + def investigate(processed_source); end + BEGIN_LENGTH = ::T.let(nil, ::T.untyped) + END_LENGTH = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::BlockComments +end + +class RuboCop::Cop::Style::BlockDelimiters + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::IgnoredMethods + def autocorrect(node); end + + def on_block(node); end + + def on_send(node); end + ALWAYS_BRACES_MESSAGE = ::T.let(nil, ::T.untyped) + BRACES_REQUIRED_MESSAGE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::BlockDelimiters +end + +class RuboCop::Cop::Style::CaseCorrector +end + +class RuboCop::Cop::Style::CaseCorrector + extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper + extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper + def self.correct(cop, node); end + + def self.move_assignment_inside_condition(node); end +end + +class RuboCop::Cop::Style::CaseEquality + def case_equality?(node=T.unsafe(nil)); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::CaseEquality +end + +class RuboCop::Cop::Style::CharacterLiteral + include ::RuboCop::Cop::StringHelp + def autocorrect(node); end + + def correct_style_detected(); end + + def offense?(node); end + + def opposite_style_detected(); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::CharacterLiteral +end + +class RuboCop::Cop::Style::ClassAndModuleChildren + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_class(node); end + + def on_module(node); end + COMPACT_MSG = ::T.let(nil, ::T.untyped) + NESTED_MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::ClassAndModuleChildren +end + +class RuboCop::Cop::Style::ClassCheck + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def class_check?(node=T.unsafe(nil)); end + + def message(node); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::ClassCheck +end + +class RuboCop::Cop::Style::ClassMethods + def autocorrect(node); end + + def on_class(node); end + + def on_module(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::ClassMethods +end + +class RuboCop::Cop::Style::ClassVars + def message(node); end + + def on_cvasgn(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::ClassVars +end + +class RuboCop::Cop::Style::CollectionMethods + include ::RuboCop::Cop::MethodPreference + def autocorrect(node); end + + def on_block(node); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::CollectionMethods +end + +class RuboCop::Cop::Style::ColonMethodCall + def autocorrect(node); end + + def java_type_node?(node=T.unsafe(nil)); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::ColonMethodCall +end + +class RuboCop::Cop::Style::ColonMethodDefinition + def autocorrect(node); end + + def on_defs(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::ColonMethodDefinition +end + +class RuboCop::Cop::Style::CommandLiteral + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def on_xstr(node); end + MSG_USE_BACKTICKS = ::T.let(nil, ::T.untyped) + MSG_USE_PERCENT_X = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::CommandLiteral +end + +class RuboCop::Cop::Style::CommentAnnotation + include ::RuboCop::Cop::Style::AnnotationComment + include ::RuboCop::Cop::RangeHelp + def autocorrect(comment); end + + def investigate(processed_source); end + MISSING_NOTE = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::CommentAnnotation +end + +class RuboCop::Cop::Style::CommentedKeyword + def investigate(processed_source); end + ALLOWED_COMMENTS = ::T.let(nil, ::T.untyped) + KEYWORDS = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::CommentedKeyword +end + +class RuboCop::Cop::Style::ConditionalAssignment + include ::RuboCop::Cop::Style::ConditionalAssignmentHelper + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def assignment_type?(node=T.unsafe(nil)); end + + def autocorrect(node); end + + def candidate_condition?(node=T.unsafe(nil)); end + + def on_and_asgn(node); end + + def on_case(node); end + + def on_casgn(node); end + + def on_cvasgn(node); end + + def on_gvasgn(node); end + + def on_if(node); end + + def on_ivasgn(node); end + + def on_lvasgn(node); end + + def on_masgn(node); end + + def on_op_asgn(node); end + + def on_or_asgn(node); end + + def on_send(node); end + ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) + ASSIGN_TO_CONDITION_MSG = ::T.let(nil, ::T.untyped) + ENABLED = ::T.let(nil, ::T.untyped) + INDENTATION_WIDTH = ::T.let(nil, ::T.untyped) + LINE_LENGTH = ::T.let(nil, ::T.untyped) + MAX = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) + SINGLE_LINE_CONDITIONS_ONLY = ::T.let(nil, ::T.untyped) + VARIABLE_ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) + WIDTH = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::ConditionalAssignment +end + +module RuboCop::Cop::Style::ConditionalAssignmentHelper + def end_with_eq?(sym); end + + def expand_elses(branch); end + + def expand_when_branches(when_branches); end + + def indent(cop, source); end + + def lhs(node); end + + def tail(branch); end + ALIGN_WITH = ::T.let(nil, ::T.untyped) + END_ALIGNMENT = ::T.let(nil, ::T.untyped) + EQUAL = ::T.let(nil, ::T.untyped) + KEYWORD = ::T.let(nil, ::T.untyped) +end + +module RuboCop::Cop::Style::ConditionalAssignmentHelper + extend ::RuboCop::NodePattern::Macros +end + +module RuboCop::Cop::Style::ConditionalCorrectorHelper + def assignment(node); end + + def correct_branches(corrector, branches); end + + def correct_if_branches(corrector, cop, node); end + + def remove_whitespace_in_branches(corrector, branch, condition, column); end + + def replace_branch_assignment(corrector, branch); end + + def white_space_range(node, column); end +end + +module RuboCop::Cop::Style::ConditionalCorrectorHelper +end + +class RuboCop::Cop::Style::ConstantVisibility + def on_casgn(node); end + + def visibility_declaration_for?(node=T.unsafe(nil), param1); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::ConstantVisibility +end + +class RuboCop::Cop::Style::Copyright + include ::RuboCop::Cop::RangeHelp + def autocorrect(token); end + + def investigate(processed_source); end + AUTOCORRECT_EMPTY_WARNING = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::Copyright +end + +class RuboCop::Cop::Style::DateTime + def date_time?(node=T.unsafe(nil)); end + + def historic_date?(node=T.unsafe(nil)); end + + def on_send(node); end + + def to_datetime?(node=T.unsafe(nil)); end + CLASS_MSG = ::T.let(nil, ::T.untyped) + COERCION_MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::DateTime +end + +class RuboCop::Cop::Style::DefWithParentheses + def autocorrect(node); end + + def on_def(node); end + + def on_defs(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::DefWithParentheses +end + +class RuboCop::Cop::Style::Dir + def autocorrect(node); end + + def dir_replacement?(node=T.unsafe(nil)); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::Dir +end + +class RuboCop::Cop::Style::Documentation + include ::RuboCop::Cop::DocumentationComment + include ::RuboCop::Cop::Style::AnnotationComment + def constant_definition?(node=T.unsafe(nil)); end + + def on_class(node); end + + def on_module(node); end + + def outer_module(node0); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::Documentation +end + +class RuboCop::Cop::Style::DocumentationMethod + include ::RuboCop::Cop::DocumentationComment + include ::RuboCop::Cop::Style::AnnotationComment + include ::RuboCop::Cop::DefNode + def module_function_node?(node=T.unsafe(nil)); end + + def on_def(node); end + + def on_defs(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::DocumentationMethod +end + +class RuboCop::Cop::Style::DoubleCopDisableDirective + def autocorrect(comment); end + + def investigate(processed_source); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::DoubleCopDisableDirective +end + +class RuboCop::Cop::Style::DoubleNegation + def double_negative?(node=T.unsafe(nil)); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::DoubleNegation +end + +class RuboCop::Cop::Style::EachForSimpleLoop + def autocorrect(node); end + + def offending_each_range(node=T.unsafe(nil)); end + + def on_block(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::EachForSimpleLoop +end + +class RuboCop::Cop::Style::EachWithObject + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def each_with_object_candidate?(node=T.unsafe(nil)); end + + def on_block(node); end + METHODS = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::EachWithObject +end + +class RuboCop::Cop::Style::EmptyBlockParameter + include ::RuboCop::Cop::EmptyParameter + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_block(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::EmptyBlockParameter +end + +class RuboCop::Cop::Style::EmptyCaseCondition + include ::RuboCop::Cop::RangeHelp + def autocorrect(case_node); end + + def on_case(case_node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::EmptyCaseCondition +end + +class RuboCop::Cop::Style::EmptyElse + include ::RuboCop::Cop::OnNormalIfUnless + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_case(node); end + + def on_normal_if_unless(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::EmptyElse +end + +class RuboCop::Cop::Style::EmptyLambdaParameter + include ::RuboCop::Cop::EmptyParameter + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_block(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::EmptyLambdaParameter +end + +class RuboCop::Cop::Style::EmptyLiteral + include ::RuboCop::Cop::FrozenStringLiteral + include ::RuboCop::Cop::RangeHelp + def array_node(node=T.unsafe(nil)); end + + def array_with_block(node=T.unsafe(nil)); end + + def autocorrect(node); end + + def hash_node(node=T.unsafe(nil)); end + + def hash_with_block(node=T.unsafe(nil)); end + + def on_send(node); end + + def str_node(node=T.unsafe(nil)); end + ARR_MSG = ::T.let(nil, ::T.untyped) + HASH_MSG = ::T.let(nil, ::T.untyped) + STR_MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::EmptyLiteral +end + +class RuboCop::Cop::Style::EmptyMethod + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def on_def(node); end + + def on_defs(node); end + MSG_COMPACT = ::T.let(nil, ::T.untyped) + MSG_EXPANDED = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::EmptyMethod +end + +class RuboCop::Cop::Style::Encoding + include ::RuboCop::Cop::RangeHelp + def autocorrect(range); end + + def investigate(processed_source); end + ENCODING_PATTERN = ::T.let(nil, ::T.untyped) + MSG_UNNECESSARY = ::T.let(nil, ::T.untyped) + SHEBANG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::Encoding +end + +class RuboCop::Cop::Style::EndBlock + def on_postexe(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::EndBlock +end + +class RuboCop::Cop::Style::EvalWithLocation + def eval_without_location?(node=T.unsafe(nil)); end + + def line_with_offset?(node=T.unsafe(nil), param1, param2); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) + MSG_INCORRECT_LINE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::EvalWithLocation +end + +class RuboCop::Cop::Style::EvenOdd + def autocorrect(node); end + + def even_odd_candidate?(node=T.unsafe(nil)); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::EvenOdd +end + +class RuboCop::Cop::Style::ExpandPathArguments + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def file_expand_path(node=T.unsafe(nil)); end + + def on_send(node); end + + def pathname_new_parent_expand_path(node=T.unsafe(nil)); end + + def pathname_parent_expand_path(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) + PATHNAME_MSG = ::T.let(nil, ::T.untyped) + PATHNAME_NEW_MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::ExpandPathArguments +end + +class RuboCop::Cop::Style::FloatDivision + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def any_coerce?(node=T.unsafe(nil)); end + + def both_coerce?(node=T.unsafe(nil)); end + + def left_coerce?(node=T.unsafe(nil)); end + + def on_send(node); end + + def right_coerce?(node=T.unsafe(nil)); end +end + +class RuboCop::Cop::Style::FloatDivision +end + +class RuboCop::Cop::Style::For + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_block(node); end + + def on_for(node); end + EACH_LENGTH = ::T.let(nil, ::T.untyped) + PREFER_EACH = ::T.let(nil, ::T.untyped) + PREFER_FOR = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::For +end + +class RuboCop::Cop::Style::FormatString + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def formatter(node=T.unsafe(nil)); end + + def message(detected_style); end + + def method_name(style_name); end + + def on_send(node); end + + def variable_argument?(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::FormatString +end + +class RuboCop::Cop::Style::FormatStringToken + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def format_string_in_typical_context?(node=T.unsafe(nil)); end + + def on_str(node); end +end + +class RuboCop::Cop::Style::FormatStringToken +end + +class RuboCop::Cop::Style::FrozenStringLiteralComment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::FrozenStringLiteral + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def investigate(processed_source); end + MSG_DISABLED = ::T.let(nil, ::T.untyped) + MSG_MISSING = ::T.let(nil, ::T.untyped) + MSG_MISSING_TRUE = ::T.let(nil, ::T.untyped) + MSG_UNNECESSARY = ::T.let(nil, ::T.untyped) + SHEBANG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::FrozenStringLiteralComment +end + +class RuboCop::Cop::Style::GlobalVars + def allowed_var?(global_var); end + + def check(node); end + + def on_gvar(node); end + + def on_gvasgn(node); end + + def user_vars(); end + BUILT_IN_VARS = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::GlobalVars +end + +class RuboCop::Cop::Style::GuardClause + include ::RuboCop::Cop::MinBodyLength + include ::RuboCop::Cop::StatementModifier + def on_def(node); end + + def on_defs(node); end + + def on_if(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::GuardClause +end + +class RuboCop::Cop::Style::HashEachMethods + include ::RuboCop::Cop::Lint::UnusedArgument + def autocorrect(node); end + + def kv_each(node=T.unsafe(nil)); end + + def on_block(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::HashEachMethods +end + +class RuboCop::Cop::Style::HashSyntax + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def hash_rockets_check(pairs); end + + def no_mixed_keys_check(pairs); end + + def on_hash(node); end + + def ruby19_check(pairs); end + + def ruby19_no_mixed_keys_check(pairs); end + MSG_19 = ::T.let(nil, ::T.untyped) + MSG_HASH_ROCKETS = ::T.let(nil, ::T.untyped) + MSG_NO_MIXED_KEYS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::HashSyntax +end + +class RuboCop::Cop::Style::HashTransformKeys + include ::RuboCop::Cop::HashTransformMethod + def on_bad_each_with_object(node=T.unsafe(nil)); end + + def on_bad_hash_brackets_map(node=T.unsafe(nil)); end + + def on_bad_map_to_h(node=T.unsafe(nil)); end +end + +class RuboCop::Cop::Style::HashTransformKeys + extend ::RuboCop::Cop::TargetRubyVersion +end + +class RuboCop::Cop::Style::HashTransformValues + include ::RuboCop::Cop::HashTransformMethod + def on_bad_each_with_object(node=T.unsafe(nil)); end + + def on_bad_hash_brackets_map(node=T.unsafe(nil)); end + + def on_bad_map_to_h(node=T.unsafe(nil)); end +end + +class RuboCop::Cop::Style::HashTransformValues + extend ::RuboCop::Cop::TargetRubyVersion +end + +class RuboCop::Cop::Style::IdenticalConditionalBranches + def on_case(node); end + + def on_if(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::IdenticalConditionalBranches +end + +class RuboCop::Cop::Style::IfCorrector +end + +class RuboCop::Cop::Style::IfCorrector + extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper + extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper + def self.correct(cop, node); end + + def self.move_assignment_inside_condition(node); end +end + +class RuboCop::Cop::Style::IfInsideElse + def on_if(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::IfInsideElse +end + +class RuboCop::Cop::Style::IfUnlessModifier + include ::RuboCop::Cop::StatementModifier + include ::RuboCop::Cop::LineLengthHelp + include ::RuboCop::Cop::IgnoredPattern + def autocorrect(node); end + + def on_if(node); end + ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) + MSG_USE_MODIFIER = ::T.let(nil, ::T.untyped) + MSG_USE_NORMAL = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::IfUnlessModifier +end + +class RuboCop::Cop::Style::IfUnlessModifierOfIfUnless + include ::RuboCop::Cop::StatementModifier + def on_if(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::IfUnlessModifierOfIfUnless +end + +class RuboCop::Cop::Style::IfWithSemicolon + include ::RuboCop::Cop::OnNormalIfUnless + def on_normal_if_unless(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::IfWithSemicolon +end + +class RuboCop::Cop::Style::ImplicitRuntimeError + def implicit_runtime_error_raise_or_fail(node=T.unsafe(nil)); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::ImplicitRuntimeError +end + +class RuboCop::Cop::Style::InfiniteLoop + def after_leaving_scope(scope, _variable_table); end + + def autocorrect(node); end + + def join_force?(force_class); end + + def on_until(node); end + + def on_until_post(node); end + + def on_while(node); end + + def on_while_post(node); end + LEADING_SPACE = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::InfiniteLoop +end + +class RuboCop::Cop::Style::InlineComment + def investigate(processed_source); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::InlineComment +end + +class RuboCop::Cop::Style::InverseMethods + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def correct_inverse_block(node); end + + def correct_inverse_method(node); end + + def correct_inverse_selector(block, corrector); end + + def inverse_block?(node=T.unsafe(nil)); end + + def inverse_candidate?(node=T.unsafe(nil)); end + + def on_block(node); end + + def on_send(node); end + CAMEL_CASE = ::T.let(nil, ::T.untyped) + CLASS_COMPARISON_METHODS = ::T.let(nil, ::T.untyped) + EQUALITY_METHODS = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) + NEGATED_EQUALITY_METHODS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::InverseMethods +end + +class RuboCop::Cop::Style::IpAddresses + include ::RuboCop::Cop::StringHelp + def correct_style_detected(); end + + def offense?(node); end + + def opposite_style_detected(); end + IPV6_MAX_SIZE = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::IpAddresses +end + +class RuboCop::Cop::Style::Lambda + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def on_block(node); end + LITERAL_MESSAGE = ::T.let(nil, ::T.untyped) + METHOD_MESSAGE = ::T.let(nil, ::T.untyped) + OFFENDING_SELECTORS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::Lambda +end + +class RuboCop::Cop::Style::LambdaCall + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def on_send(node); end +end + +class RuboCop::Cop::Style::LambdaCall +end + +class RuboCop::Cop::Style::LineEndConcatenation + include ::RuboCop::Cop::RangeHelp + def autocorrect(operator_range); end + + def investigate(processed_source); end + COMPLEX_STRING_BEGIN_TOKEN = ::T.let(nil, ::T.untyped) + COMPLEX_STRING_END_TOKEN = ::T.let(nil, ::T.untyped) + CONCAT_TOKEN_TYPES = ::T.let(nil, ::T.untyped) + HIGH_PRECEDENCE_OP_TOKEN_TYPES = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) + QUOTE_DELIMITERS = ::T.let(nil, ::T.untyped) + SIMPLE_STRING_TOKEN_TYPE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::LineEndConcatenation +end + +class RuboCop::Cop::Style::MethodCallWithArgsParentheses + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::IgnoredMethods + include ::RuboCop::Cop::IgnoredPattern + def autocorrect(_node); end + + def initialize(*_); end +end + +module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses + def autocorrect(node); end + + def message(_node=T.unsafe(nil)); end + + def on_csend(node); end + + def on_send(node); end + + def on_super(node); end + + def on_yield(node); end + TRAILING_WHITESPACE_REGEX = ::T.let(nil, ::T.untyped) +end + +module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses +end + +module RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses + def autocorrect(node); end + + def message(_node=T.unsafe(nil)); end + + def on_csend(node); end + + def on_send(node); end + + def on_super(node); end + + def on_yield(node); end +end + +module RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses +end + +class RuboCop::Cop::Style::MethodCallWithArgsParentheses +end + +class RuboCop::Cop::Style::MethodCallWithoutArgsParentheses + include ::RuboCop::Cop::IgnoredMethods + def autocorrect(node); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::MethodCallWithoutArgsParentheses +end + +class RuboCop::Cop::Style::MethodCalledOnDoEndBlock + include ::RuboCop::Cop::RangeHelp + def on_block(node); end + + def on_csend(node); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::MethodCalledOnDoEndBlock +end + +class RuboCop::Cop::Style::MethodDefParentheses + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_def(node); end + + def on_defs(node); end + MSG_MISSING = ::T.let(nil, ::T.untyped) + MSG_PRESENT = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::MethodDefParentheses +end + +class RuboCop::Cop::Style::MethodMissingSuper + def on_def(node); end + + def on_defs(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::MethodMissingSuper +end + +class RuboCop::Cop::Style::MinMax + def autocorrect(node); end + + def min_max_candidate(node=T.unsafe(nil)); end + + def on_array(node); end + + def on_return(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::MinMax +end + +class RuboCop::Cop::Style::MissingElse + include ::RuboCop::Cop::OnNormalIfUnless + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def on_case(node); end + + def on_normal_if_unless(node); end + MSG = ::T.let(nil, ::T.untyped) + MSG_EMPTY = ::T.let(nil, ::T.untyped) + MSG_NIL = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::MissingElse +end + +class RuboCop::Cop::Style::MissingRespondToMissing + def on_def(node); end + + def on_defs(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::MissingRespondToMissing +end + +class RuboCop::Cop::Style::MixinGrouping + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def on_class(node); end + + def on_module(node); end + MIXIN_METHODS = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::MixinGrouping +end + +class RuboCop::Cop::Style::MixinUsage + def include_statement(node=T.unsafe(nil)); end + + def on_send(node); end + + def wrapped_macro_scope?(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::MixinUsage +end + +class RuboCop::Cop::Style::ModuleFunction + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def extend_self_node?(node=T.unsafe(nil)); end + + def module_function_node?(node=T.unsafe(nil)); end + + def on_module(node); end + + def private_directive?(node=T.unsafe(nil)); end + EXTEND_SELF_MSG = ::T.let(nil, ::T.untyped) + MODULE_FUNCTION_MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::ModuleFunction +end + +class RuboCop::Cop::Style::MultilineBlockChain + include ::RuboCop::Cop::RangeHelp + def on_block(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::MultilineBlockChain +end + +class RuboCop::Cop::Style::MultilineIfModifier + include ::RuboCop::Cop::StatementModifier + include ::RuboCop::Cop::Alignment + def autocorrect(node); end + + def on_if(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::MultilineIfModifier +end + +class RuboCop::Cop::Style::MultilineIfThen + include ::RuboCop::Cop::OnNormalIfUnless + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_normal_if_unless(node); end + MSG = ::T.let(nil, ::T.untyped) + NON_MODIFIER_THEN = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::MultilineIfThen +end + +class RuboCop::Cop::Style::MultilineMemoization + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def on_or_asgn(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::MultilineMemoization +end + +class RuboCop::Cop::Style::MultilineMethodSignature + def on_def(node); end + + def on_defs(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::MultilineMethodSignature +end + +class RuboCop::Cop::Style::MultilineTernaryOperator + def on_if(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::MultilineTernaryOperator +end + +class RuboCop::Cop::Style::MultilineWhenThen + include ::RuboCop::Cop::RangeHelp + def accept_node_type?(node); end + + def autocorrect(node); end + + def on_when(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::MultilineWhenThen +end + +class RuboCop::Cop::Style::MultipleComparison + def on_or(node); end + + def simple_comparison?(node=T.unsafe(nil)); end + + def simple_double_comparison?(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::MultipleComparison +end + +class RuboCop::Cop::Style::MutableConstant + include ::RuboCop::Cop::FrozenStringLiteral + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def on_casgn(node); end + + def on_or_asgn(node); end + + def operation_produces_immutable_object?(node=T.unsafe(nil)); end + + def range_enclosed_in_parentheses?(node=T.unsafe(nil)); end + + def splat_value(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::MutableConstant +end + +class RuboCop::Cop::Style::NegatedIf + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::NegativeConditional + def autocorrect(node); end + + def on_if(node); end +end + +class RuboCop::Cop::Style::NegatedIf +end + +class RuboCop::Cop::Style::NegatedUnless + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::NegativeConditional + def autocorrect(node); end + + def on_if(node); end +end + +class RuboCop::Cop::Style::NegatedUnless +end + +class RuboCop::Cop::Style::NegatedWhile + include ::RuboCop::Cop::NegativeConditional + def autocorrect(node); end + + def on_until(node); end + + def on_while(node); end +end + +class RuboCop::Cop::Style::NegatedWhile +end + +class RuboCop::Cop::Style::NestedModifier + include ::RuboCop::Cop::RangeHelp + def add_parentheses_to_method_arguments(send_node); end + + def autocorrect(node); end + + def check(node); end + + def left_hand_operand(node, operator); end + + def modifier?(node); end + + def new_expression(inner_node); end + + def on_if(node); end + + def on_until(node); end + + def on_while(node); end + + def replacement_operator(keyword); end + + def requires_parens?(node); end + + def right_hand_operand(node, left_hand_keyword); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::NestedModifier +end + +class RuboCop::Cop::Style::NestedParenthesizedCalls + include ::RuboCop::Cop::RangeHelp + def autocorrect(nested); end + + def on_csend(node); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::NestedParenthesizedCalls +end + +class RuboCop::Cop::Style::NestedTernaryOperator + def on_if(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::NestedTernaryOperator +end + +class RuboCop::Cop::Style::Next + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::MinBodyLength + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def investigate(_processed_source); end + + def on_block(node); end + + def on_for(node); end + + def on_until(node); end + + def on_while(node); end + EXIT_TYPES = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::Next +end + +class RuboCop::Cop::Style::NilComparison + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def nil_check?(node=T.unsafe(nil)); end + + def nil_comparison?(node=T.unsafe(nil)); end + + def on_send(node); end + EXPLICIT_MSG = ::T.let(nil, ::T.untyped) + PREDICATE_MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::NilComparison +end + +class RuboCop::Cop::Style::NonNilCheck + def autocorrect(node); end + + def nil_check?(node=T.unsafe(nil)); end + + def not_and_nil_check?(node=T.unsafe(nil)); end + + def not_equal_to_nil?(node=T.unsafe(nil)); end + + def on_def(node); end + + def on_defs(node); end + + def on_send(node); end + + def unless_check?(node=T.unsafe(nil)); end +end + +class RuboCop::Cop::Style::NonNilCheck +end + +class RuboCop::Cop::Style::Not + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) + OPPOSITE_METHODS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::Not +end + +class RuboCop::Cop::Style::NumericLiteralPrefix + include ::RuboCop::Cop::IntegerNode + def autocorrect(node); end + + def on_int(node); end + BINARY_MSG = ::T.let(nil, ::T.untyped) + BINARY_REGEX = ::T.let(nil, ::T.untyped) + DECIMAL_MSG = ::T.let(nil, ::T.untyped) + DECIMAL_REGEX = ::T.let(nil, ::T.untyped) + HEX_MSG = ::T.let(nil, ::T.untyped) + HEX_REGEX = ::T.let(nil, ::T.untyped) + OCTAL_MSG = ::T.let(nil, ::T.untyped) + OCTAL_REGEX = ::T.let(nil, ::T.untyped) + OCTAL_ZERO_ONLY_MSG = ::T.let(nil, ::T.untyped) + OCTAL_ZERO_ONLY_REGEX = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::NumericLiteralPrefix +end + +class RuboCop::Cop::Style::NumericLiterals + include ::RuboCop::Cop::ConfigurableMax + include ::RuboCop::Cop::IntegerNode + def autocorrect(node); end + + def on_float(node); end + + def on_int(node); end + DELIMITER_REGEXP = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::NumericLiterals +end + +class RuboCop::Cop::Style::NumericPredicate + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::IgnoredMethods + def autocorrect(node); end + + def comparison(node=T.unsafe(nil)); end + + def inverted_comparison(node=T.unsafe(nil)); end + + def on_send(node); end + + def predicate(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) + REPLACEMENTS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::NumericPredicate +end + +class RuboCop::Cop::Style::OneLineConditional + include ::RuboCop::Cop::OnNormalIfUnless + def autocorrect(node); end + + def on_normal_if_unless(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::OneLineConditional +end + +class RuboCop::Cop::Style::OptionHash + def on_args(node); end + + def option_hash(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::OptionHash +end + +class RuboCop::Cop::Style::OptionalArguments + def on_def(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::OptionalArguments +end + +class RuboCop::Cop::Style::OrAssignment + def autocorrect(node); end + + def on_cvasgn(node); end + + def on_gvasgn(node); end + + def on_if(node); end + + def on_ivasgn(node); end + + def on_lvasgn(node); end + + def ternary_assignment?(node=T.unsafe(nil)); end + + def unless_assignment?(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::OrAssignment +end + +class RuboCop::Cop::Style::ParallelAssignment + include ::RuboCop::Cop::RescueNode + def autocorrect(node); end + + def implicit_self_getter?(node=T.unsafe(nil)); end + + def on_masgn(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::ParallelAssignment::AssignmentSorter + include ::TSort + def accesses?(rhs, lhs); end + + def dependency?(lhs, rhs); end + + def initialize(assignments); end + + def matching_calls(node0, param1, param2); end + + def tsort_each_child(assignment); end + + def uses_var?(node0, param1); end + + def var_name(node=T.unsafe(nil)); end +end + +class RuboCop::Cop::Style::ParallelAssignment::AssignmentSorter + extend ::RuboCop::NodePattern::Macros +end + +class RuboCop::Cop::Style::ParallelAssignment::GenericCorrector + include ::RuboCop::Cop::Alignment + def assignment(); end + + def config(); end + + def correction(); end + + def correction_range(); end + + def initialize(node, config, new_elements); end + + def node(); end +end + +class RuboCop::Cop::Style::ParallelAssignment::GenericCorrector +end + +class RuboCop::Cop::Style::ParallelAssignment::ModifierCorrector +end + +class RuboCop::Cop::Style::ParallelAssignment::ModifierCorrector +end + +class RuboCop::Cop::Style::ParallelAssignment::RescueCorrector +end + +class RuboCop::Cop::Style::ParallelAssignment::RescueCorrector +end + +class RuboCop::Cop::Style::ParallelAssignment +end + +class RuboCop::Cop::Style::ParenthesesAroundCondition + include ::RuboCop::Cop::SafeAssignment + include ::RuboCop::Cop::Parentheses + def autocorrect(node); end + + def control_op_condition(node=T.unsafe(nil)); end + + def on_if(node); end + + def on_until(node); end + + def on_while(node); end +end + +class RuboCop::Cop::Style::ParenthesesAroundCondition +end + +class RuboCop::Cop::Style::PercentLiteralDelimiters + include ::RuboCop::Cop::PercentLiteral + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def message(node); end + + def on_array(node); end + + def on_dstr(node); end + + def on_regexp(node); end + + def on_str(node); end + + def on_sym(node); end + + def on_xstr(node); end +end + +class RuboCop::Cop::Style::PercentLiteralDelimiters +end + +class RuboCop::Cop::Style::PercentQLiterals + include ::RuboCop::Cop::PercentLiteral + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def on_str(node); end + LOWER_CASE_Q_MSG = ::T.let(nil, ::T.untyped) + UPPER_CASE_Q_MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::PercentQLiterals +end + +class RuboCop::Cop::Style::PerlBackrefs + def autocorrect(node); end + + def on_nth_ref(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::PerlBackrefs +end + +class RuboCop::Cop::Style::PreferredHashMethods + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def on_csend(node); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) + OFFENDING_SELECTORS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::PreferredHashMethods +end + +class RuboCop::Cop::Style::Proc + def autocorrect(node); end + + def on_block(node); end + + def proc_new?(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::Proc +end + +class RuboCop::Cop::Style::RaiseArgs + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def on_send(node); end + COMPACT_MSG = ::T.let(nil, ::T.untyped) + EXPLODED_MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::RaiseArgs +end + +class RuboCop::Cop::Style::RandomWithOffset + def autocorrect(node); end + + def integer_op_rand?(node=T.unsafe(nil)); end + + def namespace(node=T.unsafe(nil)); end + + def on_send(node); end + + def rand_modified?(node=T.unsafe(nil)); end + + def rand_op_integer?(node=T.unsafe(nil)); end + + def random_call(node=T.unsafe(nil)); end + + def to_int(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::RandomWithOffset +end + +class RuboCop::Cop::Style::RedundantBegin + def autocorrect(node); end + + def on_block(node); end + + def on_def(node); end + + def on_defs(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::RedundantBegin +end + +class RuboCop::Cop::Style::RedundantCapitalW + include ::RuboCop::Cop::PercentLiteral + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_array(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::RedundantCapitalW +end + +class RuboCop::Cop::Style::RedundantCondition + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_if(node); end + MSG = ::T.let(nil, ::T.untyped) + REDUNDANT_CONDITION = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::RedundantCondition +end + +class RuboCop::Cop::Style::RedundantConditional + include ::RuboCop::Cop::Alignment + def autocorrect(node); end + + def on_if(node); end + + def redundant_condition?(node=T.unsafe(nil)); end + + def redundant_condition_inverted?(node=T.unsafe(nil)); end + COMPARISON_OPERATORS = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::RedundantConditional +end + +class RuboCop::Cop::Style::RedundantException + def autocorrect(node); end + + def compact?(node=T.unsafe(nil)); end + + def exploded?(node=T.unsafe(nil)); end + + def on_send(node); end + MSG_1 = ::T.let(nil, ::T.untyped) + MSG_2 = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::RedundantException +end + +class RuboCop::Cop::Style::RedundantFreeze + include ::RuboCop::Cop::FrozenStringLiteral + def autocorrect(node); end + + def on_send(node); end + + def operation_produces_immutable_object?(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::RedundantFreeze +end + +class RuboCop::Cop::Style::RedundantInterpolation + include ::RuboCop::Cop::PercentLiteral + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_dstr(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::RedundantInterpolation +end + +class RuboCop::Cop::Style::RedundantParentheses + include ::RuboCop::Cop::Parentheses + def arg_in_call_with_block?(node=T.unsafe(nil)); end + + def autocorrect(node); end + + def first_send_argument?(node=T.unsafe(nil)); end + + def first_super_argument?(node=T.unsafe(nil)); end + + def method_node_and_args(node=T.unsafe(nil)); end + + def on_begin(node); end + + def range_end?(node=T.unsafe(nil)); end + + def rescue?(node=T.unsafe(nil)); end + + def square_brackets?(node=T.unsafe(nil)); end +end + +class RuboCop::Cop::Style::RedundantParentheses +end + +class RuboCop::Cop::Style::RedundantPercentQ + def autocorrect(node); end + + def on_dstr(node); end + + def on_str(node); end + DYNAMIC_MSG = ::T.let(nil, ::T.untyped) + EMPTY = ::T.let(nil, ::T.untyped) + ESCAPED_NON_BACKSLASH = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) + PERCENT_CAPITAL_Q = ::T.let(nil, ::T.untyped) + PERCENT_Q = ::T.let(nil, ::T.untyped) + QUOTE = ::T.let(nil, ::T.untyped) + SINGLE_QUOTE = ::T.let(nil, ::T.untyped) + STRING_INTERPOLATION_REGEXP = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::RedundantPercentQ +end + +class RuboCop::Cop::Style::RedundantReturn + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_def(node); end + + def on_defs(node); end + MSG = ::T.let(nil, ::T.untyped) + MULTI_RETURN_MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::RedundantReturn +end + +class RuboCop::Cop::Style::RedundantSelf + def autocorrect(node); end + + def on_and_asgn(node); end + + def on_args(node); end + + def on_block(node); end + + def on_blockarg(node); end + + def on_def(node); end + + def on_defs(node); end + + def on_lvasgn(node); end + + def on_masgn(node); end + + def on_op_asgn(node); end + + def on_or_asgn(node); end + + def on_send(node); end + KERNEL_METHODS = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::RedundantSelf +end + +class RuboCop::Cop::Style::RedundantSort + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_send(node); end + + def redundant_sort?(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::RedundantSort +end + +class RuboCop::Cop::Style::RedundantSortBy + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_block(node); end + + def redundant_sort_by(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::RedundantSortBy +end + +class RuboCop::Cop::Style::RegexpLiteral + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_regexp(node); end + MSG_USE_PERCENT_R = ::T.let(nil, ::T.untyped) + MSG_USE_SLASHES = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::RegexpLiteral +end + +class RuboCop::Cop::Style::RescueModifier + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::RescueNode + def autocorrect(node); end + + def on_resbody(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::RescueModifier +end + +class RuboCop::Cop::Style::RescueStandardError + include ::RuboCop::Cop::RescueNode + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_resbody(node); end + + def rescue_standard_error?(node=T.unsafe(nil)); end + + def rescue_without_error_class?(node=T.unsafe(nil)); end + MSG_EXPLICIT = ::T.let(nil, ::T.untyped) + MSG_IMPLICIT = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::RescueStandardError +end + +class RuboCop::Cop::Style::ReturnNil + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def chained_send?(node=T.unsafe(nil)); end + + def define_method?(node=T.unsafe(nil)); end + + def on_return(node); end + + def return_nil_node?(node=T.unsafe(nil)); end + + def return_node?(node=T.unsafe(nil)); end + RETURN_MSG = ::T.let(nil, ::T.untyped) + RETURN_NIL_MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::ReturnNil +end + +class RuboCop::Cop::Style::SafeNavigation + include ::RuboCop::Cop::NilMethods + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def check_node(node); end + + def modifier_if_safe_navigation_candidate(node=T.unsafe(nil)); end + + def not_nil_check?(node=T.unsafe(nil)); end + + def on_and(node); end + + def on_if(node); end + + def use_var_only_in_unless_modifier?(node, variable); end + LOGIC_JUMP_KEYWORDS = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::SafeNavigation +end + +class RuboCop::Cop::Style::Sample + def autocorrect(node); end + + def on_send(node); end + + def sample_candidate?(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::Sample +end + +class RuboCop::Cop::Style::SelfAssignment + def autocorrect(node); end + + def on_cvasgn(node); end + + def on_ivasgn(node); end + + def on_lvasgn(node); end + MSG = ::T.let(nil, ::T.untyped) + OPS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::SelfAssignment +end + +class RuboCop::Cop::Style::Semicolon + include ::RuboCop::Cop::RangeHelp + def autocorrect(range); end + + def investigate(processed_source); end + + def on_begin(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::Semicolon +end + +class RuboCop::Cop::Style::Send + def on_csend(node); end + + def on_send(node); end + + def sending?(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::Send +end + +class RuboCop::Cop::Style::SignalException + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def custom_fail_methods(node0); end + + def investigate(processed_source); end + + def kernel_call?(node=T.unsafe(nil), param1); end + + def on_rescue(node); end + + def on_send(node); end + FAIL_MSG = ::T.let(nil, ::T.untyped) + RAISE_MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::SignalException +end + +class RuboCop::Cop::Style::SingleLineBlockParams + def on_block(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::SingleLineBlockParams +end + +class RuboCop::Cop::Style::SingleLineMethods + include ::RuboCop::Cop::Alignment + def autocorrect(node); end + + def on_def(node); end + + def on_defs(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::SingleLineMethods +end + +class RuboCop::Cop::Style::SpecialGlobalVars + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def message(node); end + + def on_gvar(node); end + ENGLISH_VARS = ::T.let(nil, ::T.untyped) + MSG_BOTH = ::T.let(nil, ::T.untyped) + MSG_ENGLISH = ::T.let(nil, ::T.untyped) + MSG_REGULAR = ::T.let(nil, ::T.untyped) + NON_ENGLISH_VARS = ::T.let(nil, ::T.untyped) + PERL_VARS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::SpecialGlobalVars +end + +class RuboCop::Cop::Style::StabbyLambdaParentheses + include ::RuboCop::Cop::ConfigurableEnforcedStyle + def autocorrect(node); end + + def on_send(node); end + MSG_NO_REQUIRE = ::T.let(nil, ::T.untyped) + MSG_REQUIRE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::StabbyLambdaParentheses +end + +class RuboCop::Cop::Style::StderrPuts + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_send(node); end + + def stderr_puts?(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::StderrPuts +end + +class RuboCop::Cop::Style::StringHashKeys + def autocorrect(node); end + + def on_pair(node); end + + def receive_environments_method?(node=T.unsafe(nil)); end + + def string_hash_key?(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::StringHashKeys +end + +class RuboCop::Cop::Style::StringLiterals + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::StringLiteralsHelp + include ::RuboCop::Cop::StringHelp + def autocorrect(node); end + + def on_dstr(node); end + MSG_INCONSISTENT = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::StringLiterals +end + +class RuboCop::Cop::Style::StringLiteralsInInterpolation + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::StringLiteralsHelp + include ::RuboCop::Cop::StringHelp + def autocorrect(node); end +end + +class RuboCop::Cop::Style::StringLiteralsInInterpolation +end + +class RuboCop::Cop::Style::StringMethods + include ::RuboCop::Cop::MethodPreference + def autocorrect(node); end + + def on_csend(node); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::StringMethods +end + +class RuboCop::Cop::Style::Strip + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def lstrip_rstrip(node=T.unsafe(nil)); end + + def on_send(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::Strip +end + +class RuboCop::Cop::Style::StructInheritance + def on_class(node); end + + def struct_constructor?(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::StructInheritance +end + +class RuboCop::Cop::Style::SymbolArray + include ::RuboCop::Cop::ArrayMinSize + include ::RuboCop::Cop::ArraySyntax + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::PercentArray + def autocorrect(node); end + + def on_array(node); end + ARRAY_MSG = ::T.let(nil, ::T.untyped) + PERCENT_MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::SymbolArray + def self.largest_brackets(); end + + def self.largest_brackets=(largest_brackets); end +end + +class RuboCop::Cop::Style::SymbolLiteral + def autocorrect(node); end + + def on_sym(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::SymbolLiteral +end + +class RuboCop::Cop::Style::SymbolProc + include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::IgnoredMethods + def autocorrect(node); end + + def destructuring_block_argument?(argument_node); end + + def on_block(node); end + + def proc_node?(node=T.unsafe(nil)); end + + def symbol_proc?(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) + SUPER_TYPES = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::SymbolProc +end + +class RuboCop::Cop::Style::TernaryCorrector +end + +class RuboCop::Cop::Style::TernaryCorrector + extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper + extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper + def self.correct(node); end + + def self.move_assignment_inside_condition(node); end +end + +class RuboCop::Cop::Style::TernaryParentheses + include ::RuboCop::Cop::SafeAssignment + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def method_name(node=T.unsafe(nil)); end + + def on_if(node); end + + def only_closing_parenthesis_is_last_line?(condition); end + MSG = ::T.let(nil, ::T.untyped) + MSG_COMPLEX = ::T.let(nil, ::T.untyped) + NON_COMPLEX_TYPES = ::T.let(nil, ::T.untyped) + VARIABLE_TYPES = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::TernaryParentheses +end + +class RuboCop::Cop::Style::TrailingBodyOnClass + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::TrailingBody + def autocorrect(node); end + + def on_class(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::TrailingBodyOnClass +end + +class RuboCop::Cop::Style::TrailingBodyOnMethodDefinition + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::TrailingBody + def autocorrect(node); end + + def on_def(node); end + + def on_defs(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::TrailingBodyOnMethodDefinition +end + +class RuboCop::Cop::Style::TrailingBodyOnModule + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::TrailingBody + def autocorrect(node); end + + def on_module(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::TrailingBodyOnModule +end + +class RuboCop::Cop::Style::TrailingCommaInArguments + include ::RuboCop::Cop::TrailingComma + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(range); end + + def on_csend(node); end + + def on_send(node); end +end + +class RuboCop::Cop::Style::TrailingCommaInArguments +end + +class RuboCop::Cop::Style::TrailingCommaInArrayLiteral + include ::RuboCop::Cop::TrailingComma + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(range); end + + def on_array(node); end +end + +class RuboCop::Cop::Style::TrailingCommaInArrayLiteral +end + +class RuboCop::Cop::Style::TrailingCommaInHashLiteral + include ::RuboCop::Cop::TrailingComma + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(range); end + + def on_hash(node); end +end + +class RuboCop::Cop::Style::TrailingCommaInHashLiteral +end + +class RuboCop::Cop::Style::TrailingMethodEndStatement + include ::RuboCop::Cop::Alignment + def autocorrect(node); end + + def on_def(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::TrailingMethodEndStatement +end + +class RuboCop::Cop::Style::TrailingUnderscoreVariable + include ::RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_masgn(node); end + MSG = ::T.let(nil, ::T.untyped) + UNDERSCORE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::TrailingUnderscoreVariable +end + +class RuboCop::Cop::Style::TrivialAccessors + def autocorrect(node); end + + def looks_like_trivial_writer?(node=T.unsafe(nil)); end + + def on_def(node); end + + def on_defs(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::TrivialAccessors +end + +class RuboCop::Cop::Style::UnlessElse + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def on_if(node); end + + def range_between_condition_and_else(node, condition); end + + def range_between_else_and_end(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::UnlessElse +end + +class RuboCop::Cop::Style::UnpackFirst + def autocorrect(node); end + + def on_send(node); end + + def unpack_and_first_element?(node=T.unsafe(nil)); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::UnpackFirst + extend ::RuboCop::Cop::TargetRubyVersion +end + +class RuboCop::Cop::Style::VariableInterpolation + include ::RuboCop::Cop::Interpolation + def autocorrect(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::VariableInterpolation +end + +class RuboCop::Cop::Style::WhenThen + def autocorrect(node); end + + def on_when(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::WhenThen +end + +class RuboCop::Cop::Style::WhileUntilDo + def autocorrect(node); end + + def handle(node); end + + def on_until(node); end + + def on_while(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::WhileUntilDo +end + +class RuboCop::Cop::Style::WhileUntilModifier + include ::RuboCop::Cop::StatementModifier + def autocorrect(node); end + + def on_until(node); end + + def on_while(node); end + MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::WhileUntilModifier +end + +class RuboCop::Cop::Style::WordArray + include ::RuboCop::Cop::ArrayMinSize + include ::RuboCop::Cop::ArraySyntax + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::PercentArray + def autocorrect(node); end + + def on_array(node); end + ARRAY_MSG = ::T.let(nil, ::T.untyped) + PERCENT_MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::WordArray + def self.largest_brackets(); end + + def self.largest_brackets=(largest_brackets); end +end + +class RuboCop::Cop::Style::YodaCondition + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + def autocorrect(node); end + + def file_constant_equal_program_name?(node=T.unsafe(nil)); end + + def on_send(node); end + EQUALITY_OPERATORS = ::T.let(nil, ::T.untyped) + MSG = ::T.let(nil, ::T.untyped) + NONCOMMUTATIVE_OPERATORS = ::T.let(nil, ::T.untyped) + PROGRAM_NAMES = ::T.let(nil, ::T.untyped) + REVERSE_COMPARISON = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::YodaCondition +end + +class RuboCop::Cop::Style::ZeroLengthPredicate + def autocorrect(node); end + + def non_polymorphic_collection?(node=T.unsafe(nil)); end + + def nonzero_length_predicate(node=T.unsafe(nil)); end + + def on_send(node); end + + def other_receiver(node=T.unsafe(nil)); end + + def zero_length_predicate(node=T.unsafe(nil)); end + + def zero_length_receiver(node=T.unsafe(nil)); end + NONZERO_MSG = ::T.let(nil, ::T.untyped) + ZERO_MSG = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Style::ZeroLengthPredicate +end + +module RuboCop::Cop::Style +end + +module RuboCop::Cop::SurroundingSpace + include ::RuboCop::Cop::RangeHelp + NO_SPACE_COMMAND = ::T.let(nil, ::T.untyped) + SINGLE_SPACE_REGEXP = ::T.let(nil, ::T.untyped) + SPACE_COMMAND = ::T.let(nil, ::T.untyped) +end + +module RuboCop::Cop::SurroundingSpace +end + +module RuboCop::Cop::TargetRubyVersion + def minimum_target_ruby_version(version); end + + def support_target_ruby_version?(version); end +end + +module RuboCop::Cop::TargetRubyVersion +end + +class RuboCop::Cop::Team + def autocorrect(buffer, cops); end + + def autocorrect?(); end + + def cops(); end + + def debug?(); end + + def errors(); end + + def external_dependency_checksum(); end + + def forces(); end + + def forces_for(cops); end + + def initialize(cop_classes, config, options=T.unsafe(nil)); end + + def inspect_file(processed_source); end + + def updated_source_file(); end + + def updated_source_file?(); end + + def warnings(); end + DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Team::Investigation + def errors(); end + + def errors=(_); end + + def offenses(); end + + def offenses=(_); end +end + +class RuboCop::Cop::Team::Investigation + def self.[](*_); end + + def self.members(); end +end + +class RuboCop::Cop::Team +end + +module RuboCop::Cop::TooManyLines + include ::RuboCop::Cop::CodeLength + include ::RuboCop::Cop::ConfigurableMax + MSG = ::T.let(nil, ::T.untyped) +end + +module RuboCop::Cop::TooManyLines +end + +module RuboCop::Cop::TrailingBody + def body_on_first_line?(node, body); end + + def first_part_of(body); end + + def trailing_body?(node); end +end + +module RuboCop::Cop::TrailingBody +end + +module RuboCop::Cop::TrailingComma + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::RangeHelp + MSG = ::T.let(nil, ::T.untyped) +end + +module RuboCop::Cop::TrailingComma +end + +module RuboCop::Cop::UncommunicativeName + def check(node, args); end + CASE_MSG = ::T.let(nil, ::T.untyped) + FORBIDDEN_MSG = ::T.let(nil, ::T.untyped) + LENGTH_MSG = ::T.let(nil, ::T.untyped) + NUM_MSG = ::T.let(nil, ::T.untyped) +end + +module RuboCop::Cop::UncommunicativeName +end + +class RuboCop::Cop::UnusedArgCorrector +end + +class RuboCop::Cop::UnusedArgCorrector + extend ::RuboCop::Cop::RangeHelp + def self.correct(processed_source, node); end + + def self.correct_for_blockarg_type(node); end + + def self.processed_source(); end +end + +module RuboCop::Cop::Util + include ::RuboCop::PathUtil + LITERAL_REGEX = ::T.let(nil, ::T.untyped) +end + +module RuboCop::Cop::Util + def self.begins_its_line?(range); end + + def self.comment_line?(line_source); end + + def self.double_quotes_required?(string); end + + def self.escape_string(string); end + + def self.first_part_of_call_chain(node); end + + def self.interpret_string_escapes(string); end + + def self.line_range(node); end + + def self.needs_escaping?(string); end + + def self.on_node(syms, sexp, excludes=T.unsafe(nil), &block); end + + def self.parentheses?(node); end + + def self.same_line?(node1, node2); end + + def self.to_string_literal(string); end + + def self.to_supported_styles(enforced_style); end + + def self.tokens(node); end + + def self.trim_string_interporation_escape_character(str); end +end + +module RuboCop::Cop::Utils +end + +class RuboCop::Cop::Utils::FormatString + def format_sequences(); end + + def initialize(string); end + + def max_digit_dollar_num(); end + + def named_interpolation?(); end + DIGIT_DOLLAR = ::T.let(nil, ::T.untyped) + FLAG = ::T.let(nil, ::T.untyped) + NAME = ::T.let(nil, ::T.untyped) + NUMBER = ::T.let(nil, ::T.untyped) + NUMBER_ARG = ::T.let(nil, ::T.untyped) + PRECISION = ::T.let(nil, ::T.untyped) + SEQUENCE = ::T.let(nil, ::T.untyped) + TEMPLATE_NAME = ::T.let(nil, ::T.untyped) + TYPE = ::T.let(nil, ::T.untyped) + WIDTH = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::Utils::FormatString::FormatSequence + def annotated?(); end + + def arity(); end + + def begin_pos(); end + + def end_pos(); end + + def flags(); end + + def initialize(match); end + + def max_digit_dollar_num(); end + + def name(); end + + def percent?(); end + + def precision(); end + + def style(); end + + def template?(); end + + def type(); end + + def width(); end +end + +class RuboCop::Cop::Utils::FormatString::FormatSequence +end + +class RuboCop::Cop::Utils::FormatString +end + +module RuboCop::Cop::Utils +end + +class RuboCop::Cop::VariableForce + def investigate(processed_source); end + + def process_node(node); end + + def variable_table(); end + ARGUMENT_DECLARATION_TYPES = ::T.let(nil, ::T.untyped) + LOGICAL_OPERATOR_ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) + LOOP_TYPES = ::T.let(nil, ::T.untyped) + MULTIPLE_ASSIGNMENT_TYPE = ::T.let(nil, ::T.untyped) + OPERATOR_ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) + POST_CONDITION_LOOP_TYPES = ::T.let(nil, ::T.untyped) + REGEXP_NAMED_CAPTURE_TYPE = ::T.let(nil, ::T.untyped) + RESCUE_TYPE = ::T.let(nil, ::T.untyped) + SCOPE_TYPES = ::T.let(nil, ::T.untyped) + SEND_TYPE = ::T.let(nil, ::T.untyped) + TWISTED_SCOPE_TYPES = ::T.let(nil, ::T.untyped) + VARIABLE_ASSIGNMENT_TYPE = ::T.let(nil, ::T.untyped) + VARIABLE_ASSIGNMENT_TYPES = ::T.let(nil, ::T.untyped) + VARIABLE_REFERENCE_TYPE = ::T.let(nil, ::T.untyped) + ZERO_ARITY_SUPER_TYPE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::VariableForce::Assignment + include ::RuboCop::Cop::VariableForce::Branchable + def initialize(node, variable); end + + def meta_assignment_node(); end + + def multiple_assignment?(); end + + def name(); end + + def node(); end + + def operator(); end + + def operator_assignment?(); end + + def reference!(node); end + + def referenced(); end + + def referenced?(); end + + def references(); end + + def regexp_named_capture?(); end + + def scope(); end + + def used?(); end + + def variable(); end + MULTIPLE_LEFT_HAND_SIDE_TYPE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::VariableForce::Assignment +end + +class RuboCop::Cop::VariableForce::AssignmentReference + def assignment?(); end + + def node(); end + + def node=(_); end +end + +class RuboCop::Cop::VariableForce::AssignmentReference + def self.[](*_); end + + def self.members(); end +end + +module RuboCop::Cop::VariableForce::Branch + CLASSES_BY_TYPE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::VariableForce::Branch::And + include ::RuboCop::Cop::VariableForce::Branch::LogicalOperator + def left_body?(); end + + def right_body?(); end +end + +class RuboCop::Cop::VariableForce::Branch::And +end + +class RuboCop::Cop::VariableForce::Branch::Base + def ==(other); end + + def always_run?(); end + + def branched?(); end + + def child_node(); end + + def child_node=(_); end + + def control_node(); end + + def each_ancestor(include_self: T.unsafe(nil), &block); end + + def eql?(other); end + + def exclusive_with?(other); end + + def may_jump_to_other_branch?(); end + + def may_run_incompletely?(); end + + def parent(); end + + def scope(); end + + def scope=(_); end +end + +class RuboCop::Cop::VariableForce::Branch::Base + def self.[](*_); end + + def self.classes(); end + + def self.define_predicate(name, child_index: T.unsafe(nil)); end + + def self.inherited(subclass); end + + def self.members(); end + + def self.type(); end +end + +class RuboCop::Cop::VariableForce::Branch::Case + def else_body?(); end + + def target?(); end + + def when_clause?(); end +end + +class RuboCop::Cop::VariableForce::Branch::Case +end + +class RuboCop::Cop::VariableForce::Branch::Ensure + include ::RuboCop::Cop::VariableForce::Branch::ExceptionHandler + def ensure_body?(); end + + def main_body?(); end +end + +class RuboCop::Cop::VariableForce::Branch::Ensure +end + +module RuboCop::Cop::VariableForce::Branch::ExceptionHandler + def may_jump_to_other_branch?(); end + + def may_run_incompletely?(); end +end + +module RuboCop::Cop::VariableForce::Branch::ExceptionHandler +end + +class RuboCop::Cop::VariableForce::Branch::For + def collection?(); end + + def element?(); end + + def loop_body?(); end +end + +class RuboCop::Cop::VariableForce::Branch::For +end + +class RuboCop::Cop::VariableForce::Branch::If + include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional + def falsey_body?(); end + + def truthy_body?(); end +end + +class RuboCop::Cop::VariableForce::Branch::If +end + +module RuboCop::Cop::VariableForce::Branch::LogicalOperator + def always_run?(); end +end + +module RuboCop::Cop::VariableForce::Branch::LogicalOperator +end + +class RuboCop::Cop::VariableForce::Branch::Or + include ::RuboCop::Cop::VariableForce::Branch::LogicalOperator + def left_body?(); end + + def right_body?(); end +end + +class RuboCop::Cop::VariableForce::Branch::Or +end + +class RuboCop::Cop::VariableForce::Branch::Rescue + include ::RuboCop::Cop::VariableForce::Branch::ExceptionHandler + def else_body?(); end + + def main_body?(); end + + def rescue_clause?(); end +end + +class RuboCop::Cop::VariableForce::Branch::Rescue +end + +module RuboCop::Cop::VariableForce::Branch::SimpleConditional + def always_run?(); end + + def conditional_clause?(); end +end + +module RuboCop::Cop::VariableForce::Branch::SimpleConditional +end + +class RuboCop::Cop::VariableForce::Branch::Until + include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional + def loop_body?(); end +end + +class RuboCop::Cop::VariableForce::Branch::Until +end + +class RuboCop::Cop::VariableForce::Branch::UntilPost + include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional + def loop_body?(); end +end + +class RuboCop::Cop::VariableForce::Branch::UntilPost +end + +class RuboCop::Cop::VariableForce::Branch::While + include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional + def loop_body?(); end +end + +class RuboCop::Cop::VariableForce::Branch::While +end + +class RuboCop::Cop::VariableForce::Branch::WhilePost + include ::RuboCop::Cop::VariableForce::Branch::SimpleConditional + def loop_body?(); end +end + +class RuboCop::Cop::VariableForce::Branch::WhilePost +end + +module RuboCop::Cop::VariableForce::Branch + def self.of(target_node, scope: T.unsafe(nil)); end +end + +module RuboCop::Cop::VariableForce::Branchable + def branch(); end + + def run_exclusively_with?(other); end +end + +module RuboCop::Cop::VariableForce::Branchable +end + +class RuboCop::Cop::VariableForce::Reference + include ::RuboCop::Cop::VariableForce::Branchable + def explicit?(); end + + def initialize(node, scope); end + + def node(); end + + def scope(); end + VARIABLE_REFERENCE_TYPES = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::VariableForce::Reference +end + +class RuboCop::Cop::VariableForce::Scope + def ==(other); end + + def body_node(); end + + def each_node(&block); end + + def include?(target_node); end + + def initialize(node); end + + def naked_top_level(); end + + def naked_top_level?(); end + + def name(); end + + def node(); end + + def variables(); end + OUTER_SCOPE_CHILD_INDICES = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::VariableForce::Scope +end + +class RuboCop::Cop::VariableForce::Variable + def argument?(); end + + def assign(node); end + + def assignments(); end + + def block_argument?(); end + + def capture_with_block!(); end + + def captured_by_block(); end + + def captured_by_block?(); end + + def declaration_node(); end + + def explicit_block_local_variable?(); end + + def in_modifier_if?(assignment); end + + def initialize(name, declaration_node, scope); end + + def keyword_argument?(); end + + def method_argument?(); end + + def name(); end + + def reference!(node); end + + def referenced?(); end + + def references(); end + + def scope(); end + + def should_be_unused?(); end + + def used?(); end + VARIABLE_DECLARATION_TYPES = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Cop::VariableForce::Variable +end + +class RuboCop::Cop::VariableForce::VariableReference + def assignment?(); end + + def name(); end + + def name=(_); end +end + +class RuboCop::Cop::VariableForce::VariableReference + def self.[](*_); end + + def self.members(); end +end + +class RuboCop::Cop::VariableForce::VariableTable + def accessible_variables(); end + + def assign_to_variable(name, node); end + + def current_scope(); end + + def current_scope_level(); end + + def declare_variable(name, node); end + + def find_variable(name); end + + def initialize(hook_receiver=T.unsafe(nil)); end + + def invoke_hook(hook_name, *args); end + + def pop_scope(); end + + def push_scope(scope_node); end + + def reference_variable(name, node); end + + def scope_stack(); end + + def variable_exist?(name); end +end + +class RuboCop::Cop::VariableForce::VariableTable +end + +class RuboCop::Cop::VariableForce +end + +module RuboCop::Cop +end + +class RuboCop::Error +end + +class RuboCop::Error +end + +class RuboCop::ErrorWithAnalyzedFileLocation + def column(); end + + def cop(); end + + def initialize(cause:, node:, cop:); end + + def line(); end +end + +class RuboCop::ErrorWithAnalyzedFileLocation +end + +module RuboCop::FileFinder + def find_file_upwards(filename, start_dir); end + + def find_files_upwards(filename, start_dir); end +end + +module RuboCop::FileFinder + def self.root_level=(level); end + + def self.root_level?(path); end +end + +module RuboCop::Formatter +end + +class RuboCop::Formatter::AutoGenConfigFormatter +end + +class RuboCop::Formatter::AutoGenConfigFormatter +end + +class RuboCop::Formatter::BaseFormatter + def file_finished(file, offenses); end + + def file_started(file, options); end + + def finished(inspected_files); end + + def initialize(output, options=T.unsafe(nil)); end + + def options(); end + + def output(); end + + def started(target_files); end +end + +class RuboCop::Formatter::BaseFormatter +end + +class RuboCop::Formatter::ClangStyleFormatter + ELLIPSES = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Formatter::ClangStyleFormatter +end + +module RuboCop::Formatter::Colorizable + def black(string); end + + def blue(string); end + + def colorize(string, *args); end + + def cyan(string); end + + def green(string); end + + def magenta(string); end + + def rainbow(); end + + def red(string); end + + def white(string); end + + def yellow(string); end +end + +module RuboCop::Formatter::Colorizable +end + +class RuboCop::Formatter::DisabledConfigFormatter + def file_started(_file, _file_info); end + + def finished(_inspected_files); end + HEADING = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Formatter::DisabledConfigFormatter + def self.config_to_allow_offenses(); end + + def self.config_to_allow_offenses=(config_to_allow_offenses); end + + def self.detected_styles(); end + + def self.detected_styles=(detected_styles); end +end + +class RuboCop::Formatter::DisabledLinesFormatter + include ::RuboCop::PathUtil + include ::RuboCop::Formatter::Colorizable + def cop_disabled_line_ranges(); end + + def finished(_inspected_files); end + + def started(_target_files); end +end + +class RuboCop::Formatter::DisabledLinesFormatter +end + +class RuboCop::Formatter::EmacsStyleFormatter +end + +class RuboCop::Formatter::EmacsStyleFormatter +end + +class RuboCop::Formatter::FileListFormatter +end + +class RuboCop::Formatter::FileListFormatter +end + +class RuboCop::Formatter::FormatterSet + def add_formatter(formatter_type, output_path=T.unsafe(nil)); end + + def close_output_files(); end + + def file_finished(file, offenses); end + + def file_started(file, options); end + + def finished(*args); end + + def initialize(options=T.unsafe(nil)); end + + def started(*args); end + BUILTIN_FORMATTERS_FOR_KEYS = ::T.let(nil, ::T.untyped) + FORMATTER_APIS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Formatter::FormatterSet +end + +class RuboCop::Formatter::FuubarStyleFormatter + def initialize(*output); end + + def progressbar_color(); end + + def started(target_files); end + + def with_color(); end + RESET_SEQUENCE = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Formatter::FuubarStyleFormatter +end + +class RuboCop::Formatter::HTMLFormatter + def files(); end + + def render_html(); end + + def summary(); end + ELLIPSES = ::T.let(nil, ::T.untyped) + TEMPLATE_PATH = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Formatter::HTMLFormatter::Color + def alpha(); end + + def alpha=(_); end + + def blue(); end + + def blue=(_); end + + def fade_out(amount); end + + def green(); end + + def green=(_); end + + def red(); end + + def red=(_); end +end + +class RuboCop::Formatter::HTMLFormatter::Color + def self.[](*_); end + + def self.members(); end +end + +class RuboCop::Formatter::HTMLFormatter::ERBContext + include ::RuboCop::PathUtil + include ::RuboCop::Formatter::TextUtil + def base64_encoded_logo_image(); end + + def decorated_message(offense); end + + def escape(string); end + + def files(); end + + def highlighted_source_line(offense); end + + def hightlight_source_tag(offense); end + + def initialize(files, summary); end + + def possible_ellipses(location); end + + def source_after_highlight(offense); end + + def source_before_highlight(offense); end + + def summary(); end + LOGO_IMAGE_PATH = ::T.let(nil, ::T.untyped) + SEVERITY_COLORS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Formatter::HTMLFormatter::ERBContext +end + +class RuboCop::Formatter::HTMLFormatter +end + +class RuboCop::Formatter::JSONFormatter + include ::RuboCop::PathUtil + def hash_for_file(file, offenses); end + + def hash_for_location(offense); end + + def hash_for_offense(offense); end + + def metadata_hash(); end + + def output_hash(); end +end + +class RuboCop::Formatter::JSONFormatter +end + +class RuboCop::Formatter::JUnitFormatter + def finished(_inspected_files); end +end + +class RuboCop::Formatter::JUnitFormatter +end + +class RuboCop::Formatter::OffenseCountFormatter + def file_finished(_file, offenses); end + + def finished(_inspected_files); end + + def offense_counts(); end + + def ordered_offense_counts(offense_counts); end + + def report_summary(offense_counts); end + + def total_offense_count(offense_counts); end +end + +class RuboCop::Formatter::OffenseCountFormatter +end + +class RuboCop::Formatter::PacmanFormatter + include ::RuboCop::Formatter::TextUtil + def cols(); end + + def file_started(_file, _options); end + + def next_step(offenses); end + + def pacdots(number); end + + def progress_line(); end + + def progress_line=(progress_line); end + + def started(target_files); end + + def step(character); end + + def update_progress_line(); end + FALLBACK_TERMINAL_WIDTH = ::T.let(nil, ::T.untyped) + GHOST = ::T.let(nil, ::T.untyped) + PACDOT = ::T.let(nil, ::T.untyped) + PACMAN = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Formatter::PacmanFormatter +end + +class RuboCop::Formatter::ProgressFormatter + include ::RuboCop::Formatter::TextUtil + def report_file_as_mark(offenses); end + + def started(target_files); end + DOT = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Formatter::ProgressFormatter +end + +class RuboCop::Formatter::QuietFormatter +end + +class RuboCop::Formatter::QuietFormatter +end + +class RuboCop::Formatter::SimpleTextFormatter + include ::RuboCop::Formatter::Colorizable + include ::RuboCop::PathUtil + def report_file(file, offenses); end + + def report_summary(file_count, offense_count, correction_count); end + + def started(_target_files); end + COLOR_FOR_SEVERITY = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Formatter::SimpleTextFormatter::Report + include ::RuboCop::Formatter::Colorizable + include ::RuboCop::Formatter::TextUtil + def initialize(file_count, offense_count, correction_count, rainbow); end + + def summary(); end +end + +class RuboCop::Formatter::SimpleTextFormatter::Report +end + +class RuboCop::Formatter::SimpleTextFormatter +end + +class RuboCop::Formatter::TapFormatter + def started(target_files); end +end + +class RuboCop::Formatter::TapFormatter +end + +module RuboCop::Formatter::TextUtil +end + +module RuboCop::Formatter::TextUtil + def self.pluralize(number, thing, options=T.unsafe(nil)); end +end + +class RuboCop::Formatter::WorstOffendersFormatter + def finished(_inspected_files); end + + def offense_counts(); end + + def ordered_offense_counts(offense_counts); end + + def report_summary(offense_counts); end + + def total_offense_count(offense_counts); end +end + +class RuboCop::Formatter::WorstOffendersFormatter +end + +module RuboCop::Formatter +end + +class RuboCop::IncorrectCopNameError +end + +class RuboCop::IncorrectCopNameError +end + +class RuboCop::MagicComment + def any?(); end + + def encoding_specified?(); end + + def frozen_string_literal(); end + + def frozen_string_literal?(); end + + def frozen_string_literal_specified?(); end + + def initialize(comment); end + + def valid_literal_value?(); end + TOKEN = ::T.let(nil, ::T.untyped) +end + +class RuboCop::MagicComment::EditorComment +end + +class RuboCop::MagicComment::EditorComment +end + +class RuboCop::MagicComment::EmacsComment + def encoding(); end + FORMAT = ::T.let(nil, ::T.untyped) + OPERATOR = ::T.let(nil, ::T.untyped) + SEPARATOR = ::T.let(nil, ::T.untyped) +end + +class RuboCop::MagicComment::EmacsComment +end + +class RuboCop::MagicComment::SimpleComment + def encoding(); end +end + +class RuboCop::MagicComment::SimpleComment +end + +class RuboCop::MagicComment::VimComment + def encoding(); end + FORMAT = ::T.let(nil, ::T.untyped) + OPERATOR = ::T.let(nil, ::T.untyped) + SEPARATOR = ::T.let(nil, ::T.untyped) +end + +class RuboCop::MagicComment::VimComment +end + +class RuboCop::MagicComment + def self.parse(comment); end +end + +module RuboCop::NameSimilarity + def find_similar_name(target_name, scope); end + MINIMUM_SIMILARITY_TO_SUGGEST = ::T.let(nil, ::T.untyped) +end + +module RuboCop::NameSimilarity +end + +class RuboCop::NodePattern + def ==(other); end + + def eql?(other); end + + def initialize(str); end + + def marshal_dump(); end + + def marshal_load(pattern); end + + def match(*args); end + + def pattern(); end +end + +class RuboCop::NodePattern::Invalid +end + +class RuboCop::NodePattern::Invalid +end + +module RuboCop::NodePattern::Macros + def def_node_matcher(method_name, pattern_str); end + + def def_node_search(method_name, pattern_str); end + + def node_search(method_name, compiler, on_match, prelude, called_from); end + + def node_search_all(method_name, compiler, called_from); end + + def node_search_body(method_name, trailing_params, prelude, match_code, on_match); end + + def node_search_first(method_name, compiler, called_from); end +end + +module RuboCop::NodePattern::Macros +end + +class RuboCop::NodePattern + def self.descend(element, &block); end +end + +class RuboCop::OptionArgumentError +end + +class RuboCop::OptionArgumentError +end + +class RuboCop::Options + def parse(command_line_args); end + DEFAULT_MAXIMUM_EXCLUSION_ITEMS = ::T.let(nil, ::T.untyped) + EXITING_OPTIONS = ::T.let(nil, ::T.untyped) + E_STDIN_NO_PATH = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Options +end + +module RuboCop::OptionsHelp + FORMATTER_OPTION_LIST = ::T.let(nil, ::T.untyped) + MAX_EXCL = ::T.let(nil, ::T.untyped) + TEXT = ::T.let(nil, ::T.untyped) +end + +module RuboCop::OptionsHelp +end + +class RuboCop::OptionsValidator + def boolean_or_empty_cache?(); end + + def display_only_fail_level_offenses_with_autocorrect?(); end + + def except_syntax?(); end + + def incompatible_options(); end + + def initialize(options); end + + def only_includes_redundant_disable?(); end + + def validate_auto_correct(); end + + def validate_auto_gen_config(); end + + def validate_compatibility(); end + + def validate_cop_options(); end + + def validate_exclude_limit_option(); end + + def validate_parallel(); end + + def validate_parallel_with_combo_option(); end +end + +class RuboCop::OptionsValidator + def self.validate_cop_list(names); end +end + +module RuboCop::PathUtil +end + +module RuboCop::PathUtil + def self.absolute?(path); end + + def self.chdir(dir, &block); end + + def self.hidden_dir?(path); end + + def self.hidden_file_in_not_hidden_dir?(pattern, path); end + + def self.match_path?(pattern, path); end + + def self.pwd(); end + + def self.relative_path(path, base_dir=T.unsafe(nil)); end + + def self.reset_pwd(); end + + def self.smart_path(path); end +end + +module RuboCop::Platform +end + +module RuboCop::Platform + def self.windows?(); end +end + +class RuboCop::ProcessedSource + def [](*args); end + + def ast(); end + + def ast_with_comments(); end + + def blank?(); end + + def buffer(); end + + def checksum(); end + + def comment_config(); end + + def commented?(source_range); end + + def comments(); end + + def comments_before_line(line); end + + def current_line(token); end + + def diagnostics(); end + + def disabled_line_ranges(); end + + def each_comment(); end + + def each_token(); end + + def file_path(); end + + def find_comment(); end + + def find_token(); end + + def following_line(token); end + + def initialize(source, ruby_version, path=T.unsafe(nil)); end + + def line_indentation(line_number); end + + def lines(); end + + def parser_error(); end + + def path(); end + + def preceding_line(token); end + + def raw_source(); end + + def ruby_version(); end + + def start_with?(string); end + + def tokens(); end + + def valid_syntax?(); end + STRING_SOURCE_NAME = ::T.let(nil, ::T.untyped) +end + +class RuboCop::ProcessedSource + def self.from_file(path, ruby_version); end +end + +class RuboCop::RemoteConfig + def file(); end + + def inherit_from_remote(file, path); end + + def initialize(url, base_dir); end + + def uri(); end + CACHE_LIFETIME = ::T.let(nil, ::T.untyped) +end + +class RuboCop::RemoteConfig +end + +class RuboCop::ResultCache + def initialize(file, team, options, config_store, cache_root=T.unsafe(nil)); end + + def load(); end + + def save(offenses); end + + def valid?(); end + NON_CHANGING = ::T.let(nil, ::T.untyped) +end + +class RuboCop::ResultCache + def self.allow_symlinks_in_cache_location?(config_store); end + + def self.cache_root(config_store); end + + def self.cleanup(config_store, verbose, cache_root=T.unsafe(nil)); end + + def self.inhibit_cleanup(); end + + def self.inhibit_cleanup=(inhibit_cleanup); end + + def self.source_checksum(); end + + def self.source_checksum=(source_checksum); end +end + +class RuboCop::Runner + def aborting=(aborting); end + + def aborting?(); end + + def errors(); end + + def initialize(options, config_store); end + + def run(paths); end + + def warnings(); end + MAX_ITERATIONS = ::T.let(nil, ::T.untyped) +end + +class RuboCop::Runner::InfiniteCorrectionLoop + def initialize(path, offenses); end + + def offenses(); end +end + +class RuboCop::Runner::InfiniteCorrectionLoop +end + +class RuboCop::Runner +end + +class RuboCop::StringInterpreter + STRING_ESCAPES = ::T.let(nil, ::T.untyped) + STRING_ESCAPE_REGEX = ::T.let(nil, ::T.untyped) +end + +class RuboCop::StringInterpreter + def self.interpret(string); end +end + +module RuboCop::StringUtil +end + +module RuboCop::StringUtil + def self.similarity(string_a, string_b); end +end + +class RuboCop::TargetFinder + def all_cops_include(); end + + def configured_include?(file); end + + def debug?(); end + + def excluded_dirs(base_dir); end + + def fail_fast?(); end + + def find(args); end + + def find_files(base_dir, flags); end + + def force_exclusion?(); end + + def included_file?(file); end + + def initialize(config_store, options=T.unsafe(nil)); end + + def process_explicit_path(path); end + + def ruby_executable?(file); end + + def ruby_extension?(file); end + + def ruby_extensions(); end + + def ruby_file?(file); end + + def ruby_filename?(file); end + + def ruby_filenames(); end + + def ruby_interpreters(file); end + + def stdin?(); end + + def target_files_in_dir(base_dir=T.unsafe(nil)); end + + def to_inspect?(file, hidden_files, base_dir_config); end + + def toplevel_dirs(base_dir, flags); end +end + +class RuboCop::TargetFinder +end + +class RuboCop::TargetRuby + def initialize(config); end + + def rubocop_version_with_support(); end + + def source(); end + + def supported?(); end + + def version(); end + DEFAULT_VERSION = ::T.let(nil, ::T.untyped) +end + +class RuboCop::TargetRuby::BundlerLockFile +end + +class RuboCop::TargetRuby::BundlerLockFile +end + +class RuboCop::TargetRuby::Default +end + +class RuboCop::TargetRuby::Default +end + +class RuboCop::TargetRuby::RuboCopConfig +end + +class RuboCop::TargetRuby::RuboCopConfig +end + +class RuboCop::TargetRuby::RubyVersionFile + FILENAME = ::T.let(nil, ::T.untyped) +end + +class RuboCop::TargetRuby::RubyVersionFile +end + +class RuboCop::TargetRuby::Source + def initialize(config); end + + def name(); end + + def version(); end +end + +class RuboCop::TargetRuby::Source +end + +class RuboCop::TargetRuby + def self.supported_versions(); end +end + +class RuboCop::Token + def begin_pos(); end + + def column(); end + + def comma?(); end + + def comment?(); end + + def end?(); end + + def end_pos(); end + + def equal_sign?(); end + + def initialize(pos, type, text); end + + def left_array_bracket?(); end + + def left_brace?(); end + + def left_bracket?(); end + + def left_curly_brace?(); end + + def left_parens?(); end + + def left_ref_bracket?(); end + + def line(); end + + def pos(); end + + def rescue_modifier?(); end + + def right_bracket?(); end + + def right_curly_brace?(); end + + def right_parens?(); end + + def semicolon?(); end + + def space_after?(); end + + def space_before?(); end + + def text(); end + + def type(); end +end + +class RuboCop::Token + def self.from_parser_token(parser_token); end +end + +class RuboCop::ValidationError +end + +class RuboCop::ValidationError +end + +module RuboCop::Version + MSG = ::T.let(nil, ::T.untyped) + STRING = ::T.let(nil, ::T.untyped) +end + +module RuboCop::Version + def self.version(debug=T.unsafe(nil)); end +end + +class RuboCop::Warning +end + +class RuboCop::Warning +end + +module RuboCop::YAMLDuplicationChecker +end + +module RuboCop::YAMLDuplicationChecker + def self.check(yaml_string, filename, &on_duplicated); end +end + +module RuboCop +end + +module RubyVM::AbstractSyntaxTree +end + +class RubyVM::AbstractSyntaxTree::Node + def children(); end + + def first_column(); end + + def first_lineno(); end + + def last_column(); end + + def last_lineno(); end + + def pretty_print_children(q, names=T.unsafe(nil)); end + + def type(); end +end + +class RubyVM::AbstractSyntaxTree::Node +end + +module RubyVM::AbstractSyntaxTree + def self.of(_); end + + def self.parse(_); end + + def self.parse_file(_); end +end + +class RubyVM::InstructionSequence + def absolute_path(); end + + def base_label(); end + + def disasm(); end + + def disassemble(); end + + def each_child(); end + + def eval(); end + + def first_lineno(); end + + def label(); end + + def path(); end + + def to_a(); end + + def to_binary(*_); end + + def trace_points(); end +end + +class RubyVM::InstructionSequence + def self.compile(*_); end + + def self.compile_file(*_); end + + def self.compile_option(); end + + def self.compile_option=(compile_option); end + + def self.disasm(_); end + + def self.disassemble(_); end + + def self.load_from_binary(_); end + + def self.load_from_binary_extra_data(_); end + + def self.of(_); end +end + +module RubyVM::MJIT +end + +module RubyVM::MJIT + def self.enabled?(); end + + def self.pause(*_); end + + def self.resume(); end +end + +class RubyVM + def self.resolve_feature_path(_); end + + def self.stat(*_); end +end + +ScanError = StringScanner::Error + +module SecureRandom + def self.bytes(n); end +end + +class Set + def ==(other); end + + def ===(o); end + + def compare_by_identity(); end + + def compare_by_identity?(); end + + def divide(&func); end + + def eql?(o); end + + def flatten_merge(set, seen=T.unsafe(nil)); end + + def pretty_print(pp); end + + def pretty_print_cycle(pp); end + + def reset(); end + InspectKey = ::T.let(nil, ::T.untyped) +end + +module Shellwords +end + +module Shellwords + def self.escape(str); end + + def self.join(array); end + + def self.shellescape(str); end + + def self.shelljoin(array); end + + def self.shellsplit(line); end + + def self.shellwords(line); end + + def self.split(line); end +end + +class SignalException + def signm(); end + + def signo(); end +end + +module SingleForwardable + def def_delegator(accessor, method, ali=T.unsafe(nil)); end + + def def_delegators(accessor, *methods); end + + def def_single_delegator(accessor, method, ali=T.unsafe(nil)); end + + def def_single_delegators(accessor, *methods); end + + def delegate(hash); end + + def single_delegate(hash); end +end + +module Singleton + def _dump(depth=T.unsafe(nil)); end + + def clone(); end + + def dup(); end +end + +module Singleton::SingletonClassMethods + def _load(str); end + + def clone(); end +end + +module Singleton + def self.__init__(klass); end +end + +class Socket + IPV6_DONTFRAG = ::T.let(nil, ::T.untyped) + IPV6_PATHMTU = ::T.let(nil, ::T.untyped) + IPV6_RECVPATHMTU = ::T.let(nil, ::T.untyped) + SO_BPF_EXTENSIONS = ::T.let(nil, ::T.untyped) +end + +module Socket::Constants + IPV6_DONTFRAG = ::T.let(nil, ::T.untyped) + IPV6_PATHMTU = ::T.let(nil, ::T.untyped) + IPV6_RECVPATHMTU = ::T.let(nil, ::T.untyped) + SO_BPF_EXTENSIONS = ::T.let(nil, ::T.untyped) +end + +class Sorbet::Private::ConstantLookupCache + def all_module_aliases(); end + + def all_module_names(); end + + def all_named_modules(); end + + def class_by_name(name); end + + def name_by_class(klass); end + DEPRECATED_CONSTANTS = ::T.let(nil, ::T.untyped) +end + +class Sorbet::Private::ConstantLookupCache::ConstantEntry + def aliases(); end + + def aliases=(_); end + + def const(); end + + def const=(_); end + + def const_name(); end + + def const_name=(_); end + + def found_name(); end + + def found_name=(_); end + + def owner(); end + + def owner=(_); end + + def primary_name(); end + + def primary_name=(_); end +end + +class Sorbet::Private::ConstantLookupCache::ConstantEntry + def self.[](*_); end + + def self.members(); end +end + +class Sorbet::Private::ConstantLookupCache +end + +class Sorbet::Private::CreateConfig + include ::Sorbet::Private::StepInterface + SORBET_CONFIG_FILE = ::T.let(nil, ::T.untyped) + SORBET_DIR = ::T.let(nil, ::T.untyped) +end + +class Sorbet::Private::CreateConfig + def self.main(); end + + def self.output_file(); end +end + +class Sorbet::Private::FetchRBIs + include ::Sorbet::Private::StepInterface + HEADER = ::T.let(nil, ::T.untyped) + RBI_CACHE_DIR = ::T.let(nil, ::T.untyped) + SORBET_CONFIG_FILE = ::T.let(nil, ::T.untyped) + SORBET_DIR = ::T.let(nil, ::T.untyped) + SORBET_RBI_LIST = ::T.let(nil, ::T.untyped) + SORBET_RBI_SORBET_TYPED = ::T.let(nil, ::T.untyped) + SORBET_TYPED_REPO = ::T.let(nil, ::T.untyped) + SORBET_TYPED_REVISION = ::T.let(nil, ::T.untyped) + XDG_CACHE_HOME = ::T.let(nil, ::T.untyped) +end + +class Sorbet::Private::FetchRBIs + def self.fetch_sorbet_typed(); end + + def self.main(); end + + def self.matching_version_directories(root, version); end + + def self.output_file(); end + + def self.paths_for_gem_version(gemspec); end + + def self.paths_for_ruby_version(ruby_version); end + + def self.vendor_rbis_within_paths(vendor_paths); end +end + +class Sorbet::Private::FindGemRBIs + include ::Sorbet::Private::StepInterface + GEM_DIR = ::T.let(nil, ::T.untyped) + HEADER = ::T.let(nil, ::T.untyped) + RBI_CACHE_DIR = ::T.let(nil, ::T.untyped) + XDG_CACHE_HOME = ::T.let(nil, ::T.untyped) +end + +class Sorbet::Private::FindGemRBIs + def self.main(); end + + def self.output_file(); end + + def self.paths_within_gem_sources(gemspec); end +end + +module Sorbet::Private::GemGeneratorTracepoint + include ::Sorbet::Private::StepInterface + OUTPUT = ::T.let(nil, ::T.untyped) +end + +class Sorbet::Private::GemGeneratorTracepoint::ClassDefinition + def defs(); end + + def defs=(_); end + + def id(); end + + def id=(_); end + + def klass(); end + + def klass=(_); end +end + +class Sorbet::Private::GemGeneratorTracepoint::ClassDefinition + def self.[](*_); end + + def self.members(); end +end + +class Sorbet::Private::GemGeneratorTracepoint::TracepointSerializer + def initialize(files:, delegate_classes:); end + + def serialize(output_dir); end + BAD_METHODS = ::T.let(nil, ::T.untyped) + HEADER = ::T.let(nil, ::T.untyped) + SPECIAL_METHOD_NAMES = ::T.let(nil, ::T.untyped) +end + +class Sorbet::Private::GemGeneratorTracepoint::TracepointSerializer +end + +class Sorbet::Private::GemGeneratorTracepoint::Tracer +end + +class Sorbet::Private::GemGeneratorTracepoint::Tracer + def self.add_to_context(item); end + + def self.disable_tracepoints(); end + + def self.finish(); end + + def self.install_tracepoints(); end + + def self.on_method_added(mod, method, singleton); end + + def self.on_module_created(mod); end + + def self.on_module_extended(extended, extender); end + + def self.on_module_included(included, includer); end + + def self.pre_cache_module_methods(); end + + def self.register_delegate_class(klass, delegate); end + + def self.start(); end + + def self.trace(); end + + def self.trace_results(); end +end + +module Sorbet::Private::GemGeneratorTracepoint + def self.main(output_dir=T.unsafe(nil)); end + + def self.output_file(); end +end + +class Sorbet::Private::GemLoader + GEM_LOADER = ::T.let(nil, ::T.untyped) + NO_GEM = ::T.let(nil, ::T.untyped) +end + +class Sorbet::Private::GemLoader + def self.my_require(gem); end + + def self.require_all_gems(); end + + def self.require_gem(gem); end +end + +class Sorbet::Private::HiddenMethodFinder + include ::Sorbet::Private::StepInterface + def all_modules_and_aliases(); end + + def capture_stderr(); end + + def constant_cache(); end + + def gen_source_rbi(classes, aliases); end + + def looks_like_stub_name(name); end + + def main(); end + + def mk_dir(); end + + def read_constants(); end + + def real_name(mod); end + + def require_everything(); end + + def rm_dir(); end + + def serialize_alias(source_entry, rbi_entry, my_klass, source_symbols, rbi_symbols); end + + def serialize_class(source_entry, rbi_entry, klass, source_symbols, rbi_symbols, source_by_name); end + + def serialize_constants(source, rbi, klass, is_singleton, source_symbols, rbi_symbols); end + + def symbols_id_to_name(entry, prefix); end + + def write_constants(); end + + def write_diff(source, rbi); end + BLACKLIST = ::T.let(nil, ::T.untyped) + DIFF_RBI = ::T.let(nil, ::T.untyped) + ERRORS_RBI = ::T.let(nil, ::T.untyped) + HEADER = ::T.let(nil, ::T.untyped) + HIDDEN_RBI = ::T.let(nil, ::T.untyped) + PATH = ::T.let(nil, ::T.untyped) + RBI_CONSTANTS = ::T.let(nil, ::T.untyped) + RBI_CONSTANTS_ERR = ::T.let(nil, ::T.untyped) + SOURCE_CONSTANTS = ::T.let(nil, ::T.untyped) + SOURCE_CONSTANTS_ERR = ::T.let(nil, ::T.untyped) + TMP_PATH = ::T.let(nil, ::T.untyped) + TMP_RBI = ::T.let(nil, ::T.untyped) +end + +class Sorbet::Private::HiddenMethodFinder + def self.main(); end + + def self.output_file(); end +end + +module Sorbet::Private::Main +end + +module Sorbet::Private::Main + def self.cyan(msg); end + + def self.emojify(emoji, msg); end + + def self.init(); end + + def self.main(argv); end + + def self.make_step(step); end + + def self.usage(); end + + def self.yellow(msg); end +end + +module Sorbet::Private::RealStdlib +end + +module Sorbet::Private::RealStdlib + def self.real_ancestors(mod); end + + def self.real_autoload?(o, klass); end + + def self.real_const_get(obj, const, arg); end + + def self.real_constants(mod); end + + def self.real_eqeq(obj, other); end + + def self.real_hash(o); end + + def self.real_instance_methods(mod, arg); end + + def self.real_is_a?(o, klass); end + + def self.real_method(obj, sym); end + + def self.real_name(o); end + + def self.real_object_id(o); end + + def self.real_private_instance_methods(mod, arg); end + + def self.real_singleton_class(obj); end + + def self.real_singleton_methods(mod, arg); end + + def self.real_spaceship(obj, arg); end + + def self.real_superclass(o); end +end + +class Sorbet::Private::RequireEverything +end + +class Sorbet::Private::RequireEverything + def self.excluded_rails_files(); end + + def self.load_bundler(); end + + def self.load_rails(); end + + def self.my_require(abs_path, numerator, denominator); end + + def self.patch_kernel(); end + + def self.rails?(); end + + def self.rails_load_paths(); end + + def self.rb_file_paths(); end + + def self.require_all_files(); end + + def self.require_everything(); end +end + +class Sorbet::Private::Serialize + def alias(base, other_name); end + + def ancestor_has_method(method, klass); end + + def blacklisted_method(method); end + + def class_or_module(class_name); end + + def comparable?(value); end + + def constant(const, value); end + + def from_method(method); end + + def initialize(constant_cache); end + + def serialize_method(method, static=T.unsafe(nil), with_sig: T.unsafe(nil)); end + + def serialize_sig(parameters); end + + def to_sig(kind, name); end + + def valid_class_name(name); end + + def valid_method_name(name); end + BLACKLIST_CONSTANTS = ::T.let(nil, ::T.untyped) + KEYWORDS = ::T.let(nil, ::T.untyped) + SPECIAL_METHOD_NAMES = ::T.let(nil, ::T.untyped) +end + +class Sorbet::Private::Serialize + def self.header(typed=T.unsafe(nil), subcommand=T.unsafe(nil)); end +end + +module Sorbet::Private::Status +end + +module Sorbet::Private::Status + def self.done(); end + + def self.say(message, print_without_tty: T.unsafe(nil)); end +end + +module Sorbet::Private::StepInterface +end + +module Sorbet::Private::StepInterface + def self.main(); end + + def self.output_file(); end +end + +class Sorbet::Private::SuggestTyped + include ::Sorbet::Private::StepInterface +end + +class Sorbet::Private::SuggestTyped + def self.main(); end + + def self.output_file(); end + + def self.suggest_typed(); end +end + +class Sorbet::Private::TodoRBI + include ::Sorbet::Private::StepInterface + HEADER = ::T.let(nil, ::T.untyped) + OUTPUT = ::T.let(nil, ::T.untyped) +end + +class Sorbet::Private::TodoRBI + def self.main(); end + + def self.output_file(); end +end + +class SortedSet + def initialize(*args, &block); end +end + +class SortedSet + def self.setup(); end +end + +class StopIteration + def result(); end +end + +class String + include ::JSON::Ext::Generator::GeneratorMethods::String + def []=(*_); end + + def blank?(); end + + def casecmp?(_); end + + def each_grapheme_cluster(); end + + def encode!(*_); end + + def ext(newext=T.unsafe(nil)); end + + def grapheme_clusters(); end + + def pathmap(spec=T.unsafe(nil), &block); end + + def pathmap_explode(); end + + def pathmap_partial(n); end + + def pathmap_replace(patterns, &block); end + + def reverse!(); end + + def shellescape(); end + + def shellsplit(); end + + def succ!(); end + + def undump(); end + + def unicode_normalize(*_); end + + def unicode_normalize!(*_); end + + def unicode_normalized?(*_); end + + def unpack1(_); end +end + +class String + extend ::JSON::Ext::Generator::GeneratorMethods::String::Extend +end + +class StringIO + def length(); end + + def truncate(_); end +end + +class StringScanner + def <<(_); end + + def [](_); end + + def beginning_of_line?(); end + + def bol?(); end + + def captures(); end + + def charpos(); end + + def check(_); end + + def check_until(_); end + + def clear(); end + + def concat(_); end + + def empty?(); end + + def exist?(_); end + + def get_byte(); end + + def getbyte(); end + + def initialize(*_); end + + def match?(_); end + + def matched(); end + + def matched?(); end + + def matched_size(); end + + def peek(_); end + + def peep(_); end + + def pointer(); end + + def pointer=(pointer); end + + def pos(); end + + def pos=(pos); end + + def post_match(); end + + def pre_match(); end + + def reset(); end + + def rest(); end + + def rest?(); end + + def rest_size(); end + + def restsize(); end + + def scan_full(_, _1, _2); end + + def scan_until(_); end + + def search_full(_, _1, _2); end + + def size(); end + + def skip(_); end + + def skip_until(_); end + + def string(); end + + def string=(string); end + + def terminate(); end + + def unscan(); end + + def values_at(*_); end + Id = ::T.let(nil, ::T.untyped) + Version = ::T.let(nil, ::T.untyped) +end + +class StringScanner + def self.must_C_version(); end +end + +class Struct + def [](_); end + + def []=(_, _1); end + + def dig(*_); end + + def each_pair(); end + + def filter(*_); end + + def length(); end + + def members(); end + + def select(*_); end + + def size(); end + + def to_a(); end + + def to_h(); end + + def values(); end + + def values_at(*_); end +end + +Struct::Group = Etc::Group + +Struct::Passwd = Etc::Passwd + +Struct::Tms = Process::Tms + +class SystemCallError + def errno(); end +end + +class SystemExit + def status(); end + + def success?(); end +end + +class Tempfile + def _close(); end + + def inspect(); end +end + +class Tempfile::Remover + def call(*args); end + + def initialize(tmpfile); end +end + +class Tempfile::Remover +end + +class TracePoint + def __enable(_, _1); end + + def eval_script(); end + + def event(); end + + def instruction_sequence(); end + + def parameters(); end +end + +class TrueClass + include ::JSON::Ext::Generator::GeneratorMethods::TrueClass +end + +module URI + include ::URI::RFC2396_REGEXP +end + +module URI::Escape + def decode(*arg); end + + def encode(*arg); end + + def escape(*arg); end + + def unescape(*arg); end +end + +class URI::FTP + def set_typecode(v); end + + def typecode(); end + + def typecode=(typecode); end +end + +class URI::FTP + def self.new2(user, password, host, port, path, typecode=T.unsafe(nil), arg_check=T.unsafe(nil)); end +end + +class URI::File + def check_password(user); end + + def check_user(user); end + + def check_userinfo(user); end + + def set_userinfo(v); end + COMPONENT = ::T.let(nil, ::T.untyped) + DEFAULT_PORT = ::T.let(nil, ::T.untyped) +end + +class URI::File +end + +class URI::LDAP + def attributes(); end + + def attributes=(val); end + + def dn(); end + + def dn=(val); end + + def extensions(); end + + def extensions=(val); end + + def filter(); end + + def filter=(val); end + + def initialize(*arg); end + + def scope(); end + + def scope=(val); end + + def set_attributes(val); end + + def set_dn(val); end + + def set_extensions(val); end + + def set_filter(val); end + + def set_scope(val); end +end + +class URI::MailTo + def headers(); end + + def headers=(v); end + + def initialize(*arg); end + + def set_headers(v); end + + def set_to(v); end + + def to(); end + + def to=(v); end + + def to_mailtext(); end + + def to_rfc822text(); end +end + +URI::Parser = URI::RFC2396_Parser + +URI::REGEXP = URI::RFC2396_REGEXP + +class URI::RFC2396_Parser + def escape(str, unsafe=T.unsafe(nil)); end + + def extract(str, schemes=T.unsafe(nil)); end + + def initialize(opts=T.unsafe(nil)); end + + def join(*uris); end + + def make_regexp(schemes=T.unsafe(nil)); end + + def parse(uri); end + + def pattern(); end + + def regexp(); end + + def split(uri); end + + def unescape(str, escaped=T.unsafe(nil)); end +end + +class URI::RFC3986_Parser + def join(*uris); end + + def parse(uri); end + + def regexp(); end + + def split(uri); end + RFC3986_relative_ref = ::T.let(nil, ::T.untyped) +end + +module URI::Util + def self.make_components_hash(klass, array_hash); end +end + +module URI + extend ::URI::Escape + def self.get_encoding(label); end + +end + +class UnboundMethod + def clone(); end + + def original_name(); end +end + +class UncaughtThrowError + def tag(); end + + def value(); end +end + +module Unicode +end + +module Unicode::DisplayWidth + DATA_DIRECTORY = ::T.let(nil, ::T.untyped) + DEPTHS = ::T.let(nil, ::T.untyped) + INDEX = ::T.let(nil, ::T.untyped) + INDEX_FILENAME = ::T.let(nil, ::T.untyped) + NO_STRING_EXT = ::T.let(nil, ::T.untyped) + UNICODE_VERSION = ::T.let(nil, ::T.untyped) + VERSION = ::T.let(nil, ::T.untyped) +end + +module Unicode::DisplayWidth + def self.emoji_extra_width_of(string, ambiguous=T.unsafe(nil), overwrite=T.unsafe(nil), _=T.unsafe(nil)); end + + def self.of(string, ambiguous=T.unsafe(nil), overwrite=T.unsafe(nil), options=T.unsafe(nil)); end +end + +module Unicode +end + +module UnicodeNormalize +end + +module UnicodeNormalize +end + +Visitor = Psych::Visitors::Visitor + +module Warning + def warn(_); end +end + +module Warning + extend ::Warning +end + +YAML = Psych + +YAMLTree = Psych::Visitors::YAMLTree + +module Zlib + ASCII = ::T.let(nil, ::T.untyped) + BEST_COMPRESSION = ::T.let(nil, ::T.untyped) + BEST_SPEED = ::T.let(nil, ::T.untyped) + BINARY = ::T.let(nil, ::T.untyped) + DEFAULT_COMPRESSION = ::T.let(nil, ::T.untyped) + DEFAULT_STRATEGY = ::T.let(nil, ::T.untyped) + DEF_MEM_LEVEL = ::T.let(nil, ::T.untyped) + FILTERED = ::T.let(nil, ::T.untyped) + FINISH = ::T.let(nil, ::T.untyped) + FIXED = ::T.let(nil, ::T.untyped) + FULL_FLUSH = ::T.let(nil, ::T.untyped) + HUFFMAN_ONLY = ::T.let(nil, ::T.untyped) + MAX_MEM_LEVEL = ::T.let(nil, ::T.untyped) + MAX_WBITS = ::T.let(nil, ::T.untyped) + NO_COMPRESSION = ::T.let(nil, ::T.untyped) + NO_FLUSH = ::T.let(nil, ::T.untyped) + OS_AMIGA = ::T.let(nil, ::T.untyped) + OS_ATARI = ::T.let(nil, ::T.untyped) + OS_CODE = ::T.let(nil, ::T.untyped) + OS_CPM = ::T.let(nil, ::T.untyped) + OS_MACOS = ::T.let(nil, ::T.untyped) + OS_MSDOS = ::T.let(nil, ::T.untyped) + OS_OS2 = ::T.let(nil, ::T.untyped) + OS_QDOS = ::T.let(nil, ::T.untyped) + OS_RISCOS = ::T.let(nil, ::T.untyped) + OS_TOPS20 = ::T.let(nil, ::T.untyped) + OS_UNIX = ::T.let(nil, ::T.untyped) + OS_UNKNOWN = ::T.let(nil, ::T.untyped) + OS_VMCMS = ::T.let(nil, ::T.untyped) + OS_VMS = ::T.let(nil, ::T.untyped) + OS_WIN32 = ::T.let(nil, ::T.untyped) + OS_ZSYSTEM = ::T.let(nil, ::T.untyped) + RLE = ::T.let(nil, ::T.untyped) + SYNC_FLUSH = ::T.let(nil, ::T.untyped) + TEXT = ::T.let(nil, ::T.untyped) + UNKNOWN = ::T.let(nil, ::T.untyped) + VERSION = ::T.let(nil, ::T.untyped) + ZLIB_VERSION = ::T.let(nil, ::T.untyped) +end + +class Zlib::BufError +end + +class Zlib::BufError +end + +class Zlib::DataError +end + +class Zlib::DataError +end + +class Zlib::Deflate + def <<(_); end + + def deflate(*_); end + + def flush(*_); end + + def initialize(*_); end + + def params(_, _1); end + + def set_dictionary(_); end +end + +class Zlib::Deflate + def self.deflate(*_); end +end + +class Zlib::Error +end + +class Zlib::Error +end + +class Zlib::GzipFile + def close(); end + + def closed?(); end + + def comment(); end + + def crc(); end + + def finish(); end + + def level(); end + + def mtime(); end + + def orig_name(); end + + def os_code(); end + + def sync(); end + + def sync=(sync); end + + def to_io(); end +end + +class Zlib::GzipFile::CRCError +end + +class Zlib::GzipFile::CRCError +end + +class Zlib::GzipFile::Error + def input(); end +end + +class Zlib::GzipFile::Error +end + +class Zlib::GzipFile::LengthError +end + +class Zlib::GzipFile::LengthError +end + +class Zlib::GzipFile::NoFooter +end + +class Zlib::GzipFile::NoFooter +end + +class Zlib::GzipFile + def self.wrap(*_); end +end + +class Zlib::GzipReader + include ::Enumerable + def bytes(); end + + def each(*_, &blk); end + + def each_byte(); end + + def each_char(); end + + def each_line(*_); end + + def eof(); end + + def eof?(); end + + def external_encoding(); end + + def getbyte(); end + + def getc(); end + + def initialize(*_); end + + def lineno(); end + + def lineno=(lineno); end + + def lines(*_); end + + def pos(); end + + def read(*_); end + + def readbyte(); end + + def readchar(); end + + def readpartial(*_); end + + def rewind(); end + + def tell(); end + + def ungetbyte(_); end + + def ungetc(_); end + + def unused(); end +end + +class Zlib::GzipReader +end + +class Zlib::GzipWriter + def <<(_); end + + def comment=(comment); end + + def flush(*_); end + + def initialize(*_); end + + def mtime=(mtime); end + + def orig_name=(orig_name); end + + def pos(); end + + def tell(); end + + def write(*_); end +end + +class Zlib::GzipWriter +end + +class Zlib::Inflate + def <<(_); end + + def add_dictionary(_); end + + def inflate(_); end + + def initialize(*_); end + + def set_dictionary(_); end + + def sync(_); end + + def sync_point?(); end +end + +class Zlib::Inflate + def self.inflate(_); end +end + +class Zlib::MemError +end + +class Zlib::MemError +end + +class Zlib::NeedDict +end + +class Zlib::NeedDict +end + +class Zlib::StreamEnd +end + +class Zlib::StreamEnd +end + +class Zlib::StreamError +end + +class Zlib::StreamError +end + +class Zlib::VersionError +end + +class Zlib::VersionError +end + +class Zlib::ZStream + def adler(); end + + def avail_in(); end + + def avail_out(); end + + def avail_out=(avail_out); end + + def close(); end + + def closed?(); end + + def data_type(); end + + def end(); end + + def ended?(); end + + def finish(); end + + def finished?(); end + + def flush_next_in(); end + + def flush_next_out(); end + + def reset(); end + + def stream_end?(); end + + def total_in(); end + + def total_out(); end +end + +class Zlib::ZStream +end + +module Zlib + def self.adler32(*_); end + + def self.adler32_combine(_, _1, _2); end + + def self.crc32(*_); end + + def self.crc32_combine(_, _1, _2); end + + def self.crc_table(); end + + def self.deflate(*_); end + + def self.gunzip(_); end + + def self.gzip(*_); end + + def self.inflate(_); end + + def self.zlib_version(); end +end diff --git a/sorbet/rbi/jaeger-client.rbi b/sorbet/rbi/jaeger-client.rbi new file mode 100644 index 0000000..a8cab5d --- /dev/null +++ b/sorbet/rbi/jaeger-client.rbi @@ -0,0 +1,5 @@ +# typed: strong + +module Jaeger::Client + def self.build(*args); end +end diff --git a/sorbet/rbi/rack.rbi b/sorbet/rbi/rack.rbi new file mode 100644 index 0000000..094c70b --- /dev/null +++ b/sorbet/rbi/rack.rbi @@ -0,0 +1,5 @@ +# typed: strong + +class Rack::Auth::Basic + def initialize(app, *args); end +end diff --git a/sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi b/sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi new file mode 100644 index 0000000..f2db931 --- /dev/null +++ b/sorbet/rbi/sorbet-typed/lib/bundler/all/bundler.rbi @@ -0,0 +1,8684 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi sorbet-typed +# +# If you would like to make changes to this file, great! Please upstream any changes you make here: +# +# https://github.com/sorbet/sorbet-typed/edit/master/lib/bundler/all/bundler.rbi +# +# typed: strong + +module Bundler + FREEBSD = ::T.let(nil, T.untyped) + NULL = ::T.let(nil, T.untyped) + ORIGINAL_ENV = ::T.let(nil, T.untyped) + SUDO_MUTEX = ::T.let(nil, T.untyped) + VERSION = ::T.let(nil, T.untyped) + WINDOWS = ::T.let(nil, T.untyped) + + sig do + params( + custom_path: T.untyped, + ) + .returns(T.untyped) + end + def self.app_cache(custom_path=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def self.app_config_path(); end + + sig {returns(T.untyped)} + def self.bin_path(); end + + sig {returns(T.untyped)} + def self.bundle_path(); end + + sig {returns(T.untyped)} + def self.bundler_major_version(); end + + sig {returns(T.untyped)} + def self.clean_env(); end + + sig do + params( + args: T.untyped, + ) + .returns(T.untyped) + end + def self.clean_exec(*args); end + + sig do + params( + args: T.untyped, + ) + .returns(T.untyped) + end + def self.clean_system(*args); end + + sig {returns(T.untyped)} + def self.clear_gemspec_cache(); end + + sig {returns(T.untyped)} + def self.configure(); end + + sig {returns(T.untyped)} + def self.configured_bundle_path(); end + + sig {returns(T.untyped)} + def self.current_ruby(); end + + sig {returns(T.untyped)} + def self.default_bundle_dir(); end + + sig {returns(T.untyped)} + def self.default_gemfile(); end + + sig {returns(T.untyped)} + def self.default_lockfile(); end + + sig do + params( + unlock: T.untyped, + ) + .returns(T.untyped) + end + def self.definition(unlock=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def self.environment(); end + + sig {returns(T.untyped)} + def self.feature_flag(); end + + sig {returns(T.untyped)} + def self.frozen_bundle?(); end + + sig {returns(T.untyped)} + def self.git_present?(); end + + sig {returns(T.untyped)} + def self.home(); end + + sig {returns(T.untyped)} + def self.install_path(); end + + sig {returns(T.untyped)} + def self.load(); end + + sig do + params( + file: T.untyped, + validate: T.untyped, + ) + .returns(T.untyped) + end + def self.load_gemspec(file, validate=T.unsafe(nil)); end + + sig do + params( + file: T.untyped, + validate: T.untyped, + ) + .returns(T.untyped) + end + def self.load_gemspec_uncached(file, validate=T.unsafe(nil)); end + + sig do + params( + data: T.untyped, + ) + .returns(T.untyped) + end + def self.load_marshal(data); end + + sig {returns(T.untyped)} + def self.local_platform(); end + + sig {returns(T.untyped)} + def self.locked_gems(); end + + sig do + params( + path: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mkdir_p(path, options=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def self.original_env(); end + + sig do + params( + file: T.untyped, + ) + .returns(T.untyped) + end + def self.read_file(file); end + + sig do + params( + groups: T.untyped, + ) + .returns(T.untyped) + end + def self.require(*groups); end + + sig {returns(T.untyped)} + def self.require_thor_actions(); end + + sig {returns(T.untyped)} + def self.requires_sudo?(); end + + sig {returns(T.untyped)} + def self.reset!(); end + + sig {returns(T.untyped)} + def self.reset_paths!(); end + + sig {returns(T.untyped)} + def self.reset_rubygems!(); end + + sig do + params( + path: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_rf(path); end + + sig {returns(T.untyped)} + def self.root(); end + + sig {returns(T.untyped)} + def self.ruby_scope(); end + + sig {returns(T.untyped)} + def self.rubygems(); end + + sig {returns(T.untyped)} + def self.settings(); end + + sig do + params( + groups: T.untyped, + ) + .returns(T.untyped) + end + def self.setup(*groups); end + + sig {returns(T.untyped)} + def self.specs_path(); end + + sig do + params( + str: T.untyped, + ) + .returns(T.untyped) + end + def self.sudo(str); end + + sig {returns(T.untyped)} + def self.system_bindir(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def self.tmp(name=T.unsafe(nil)); end + + sig do + params( + login: T.untyped, + warning: T.untyped, + ) + .returns(T.untyped) + end + def self.tmp_home_path(login, warning); end + + sig {returns(T.untyped)} + def self.ui(); end + + sig do + params( + ui: T.untyped, + ) + .returns(T.untyped) + end + def self.ui=(ui); end + + sig {returns(T.untyped)} + def self.use_system_gems?(); end + + sig do + params( + dir: T.untyped, + ) + .returns(T.untyped) + end + def self.user_bundle_path(dir=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def self.user_cache(); end + + sig {returns(T.untyped)} + def self.user_home(); end + + sig do + params( + executable: T.untyped, + ) + .returns(T.untyped) + end + def self.which(executable); end + + sig {returns(T.untyped)} + def self.with_clean_env(); end + + sig {returns(T.untyped)} + def self.with_original_env(); end +end + +class Bundler::APIResponseMismatchError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +module Bundler::BuildMetadata + sig {returns(T.untyped)} + def self.built_at(); end + + sig {returns(T.untyped)} + def self.git_commit_sha(); end + + sig {returns(T.untyped)} + def self.release?(); end + + sig {returns(T.untyped)} + def self.to_h(); end +end + +class Bundler::BundlerError < StandardError + sig {returns(T.untyped)} + def self.all_errors(); end + + sig do + params( + code: T.untyped, + ) + .returns(T.untyped) + end + def self.status_code(code); end +end + +class Bundler::CurrentRuby + KNOWN_MAJOR_VERSIONS = ::T.let(nil, T.untyped) + KNOWN_MINOR_VERSIONS = ::T.let(nil, T.untyped) + KNOWN_PLATFORMS = ::T.let(nil, T.untyped) + + sig {returns(T.untyped)} + def jruby?(); end + + sig {returns(T.untyped)} + def jruby_18?(); end + + sig {returns(T.untyped)} + def jruby_19?(); end + + sig {returns(T.untyped)} + def jruby_1?(); end + + sig {returns(T.untyped)} + def jruby_20?(); end + + sig {returns(T.untyped)} + def jruby_21?(); end + + sig {returns(T.untyped)} + def jruby_22?(); end + + sig {returns(T.untyped)} + def jruby_23?(); end + + sig {returns(T.untyped)} + def jruby_24?(); end + + sig {returns(T.untyped)} + def jruby_25?(); end + + sig {returns(T.untyped)} + def jruby_26?(); end + + sig {returns(T.untyped)} + def jruby_27?(); end + + sig {returns(T.untyped)} + def jruby_2?(); end + + sig {returns(T.untyped)} + def maglev?(); end + + sig {returns(T.untyped)} + def maglev_18?(); end + + sig {returns(T.untyped)} + def maglev_19?(); end + + sig {returns(T.untyped)} + def maglev_1?(); end + + sig {returns(T.untyped)} + def maglev_20?(); end + + sig {returns(T.untyped)} + def maglev_21?(); end + + sig {returns(T.untyped)} + def maglev_22?(); end + + sig {returns(T.untyped)} + def maglev_23?(); end + + sig {returns(T.untyped)} + def maglev_24?(); end + + sig {returns(T.untyped)} + def maglev_25?(); end + + sig {returns(T.untyped)} + def maglev_26?(); end + + sig {returns(T.untyped)} + def maglev_27?(); end + + sig {returns(T.untyped)} + def maglev_2?(); end + + sig {returns(T.untyped)} + def mingw?(); end + + sig {returns(T.untyped)} + def mingw_18?(); end + + sig {returns(T.untyped)} + def mingw_19?(); end + + sig {returns(T.untyped)} + def mingw_1?(); end + + sig {returns(T.untyped)} + def mingw_20?(); end + + sig {returns(T.untyped)} + def mingw_21?(); end + + sig {returns(T.untyped)} + def mingw_22?(); end + + sig {returns(T.untyped)} + def mingw_23?(); end + + sig {returns(T.untyped)} + def mingw_24?(); end + + sig {returns(T.untyped)} + def mingw_25?(); end + + sig {returns(T.untyped)} + def mingw_26?(); end + + sig {returns(T.untyped)} + def mingw_27?(); end + + sig {returns(T.untyped)} + def mingw_2?(); end + + sig {returns(T.untyped)} + def mri?(); end + + sig {returns(T.untyped)} + def mri_18?(); end + + sig {returns(T.untyped)} + def mri_19?(); end + + sig {returns(T.untyped)} + def mri_1?(); end + + sig {returns(T.untyped)} + def mri_20?(); end + + sig {returns(T.untyped)} + def mri_21?(); end + + sig {returns(T.untyped)} + def mri_22?(); end + + sig {returns(T.untyped)} + def mri_23?(); end + + sig {returns(T.untyped)} + def mri_24?(); end + + sig {returns(T.untyped)} + def mri_25?(); end + + sig {returns(T.untyped)} + def mri_26?(); end + + sig {returns(T.untyped)} + def mri_27?(); end + + sig {returns(T.untyped)} + def mri_2?(); end + + sig {returns(T.untyped)} + def mswin64?(); end + + sig {returns(T.untyped)} + def mswin64_18?(); end + + sig {returns(T.untyped)} + def mswin64_19?(); end + + sig {returns(T.untyped)} + def mswin64_1?(); end + + sig {returns(T.untyped)} + def mswin64_20?(); end + + sig {returns(T.untyped)} + def mswin64_21?(); end + + sig {returns(T.untyped)} + def mswin64_22?(); end + + sig {returns(T.untyped)} + def mswin64_23?(); end + + sig {returns(T.untyped)} + def mswin64_24?(); end + + sig {returns(T.untyped)} + def mswin64_25?(); end + + sig {returns(T.untyped)} + def mswin64_26?(); end + + sig {returns(T.untyped)} + def mswin64_27?(); end + + sig {returns(T.untyped)} + def mswin64_2?(); end + + sig {returns(T.untyped)} + def mswin?(); end + + sig {returns(T.untyped)} + def mswin_18?(); end + + sig {returns(T.untyped)} + def mswin_19?(); end + + sig {returns(T.untyped)} + def mswin_1?(); end + + sig {returns(T.untyped)} + def mswin_20?(); end + + sig {returns(T.untyped)} + def mswin_21?(); end + + sig {returns(T.untyped)} + def mswin_22?(); end + + sig {returns(T.untyped)} + def mswin_23?(); end + + sig {returns(T.untyped)} + def mswin_24?(); end + + sig {returns(T.untyped)} + def mswin_25?(); end + + sig {returns(T.untyped)} + def mswin_26?(); end + + sig {returns(T.untyped)} + def mswin_27?(); end + + sig {returns(T.untyped)} + def mswin_2?(); end + + sig {returns(T.untyped)} + def on_18?(); end + + sig {returns(T.untyped)} + def on_19?(); end + + sig {returns(T.untyped)} + def on_1?(); end + + sig {returns(T.untyped)} + def on_20?(); end + + sig {returns(T.untyped)} + def on_21?(); end + + sig {returns(T.untyped)} + def on_22?(); end + + sig {returns(T.untyped)} + def on_23?(); end + + sig {returns(T.untyped)} + def on_24?(); end + + sig {returns(T.untyped)} + def on_25?(); end + + sig {returns(T.untyped)} + def on_26?(); end + + sig {returns(T.untyped)} + def on_27?(); end + + sig {returns(T.untyped)} + def on_2?(); end + + sig {returns(T.untyped)} + def rbx?(); end + + sig {returns(T.untyped)} + def rbx_18?(); end + + sig {returns(T.untyped)} + def rbx_19?(); end + + sig {returns(T.untyped)} + def rbx_1?(); end + + sig {returns(T.untyped)} + def rbx_20?(); end + + sig {returns(T.untyped)} + def rbx_21?(); end + + sig {returns(T.untyped)} + def rbx_22?(); end + + sig {returns(T.untyped)} + def rbx_23?(); end + + sig {returns(T.untyped)} + def rbx_24?(); end + + sig {returns(T.untyped)} + def rbx_25?(); end + + sig {returns(T.untyped)} + def rbx_26?(); end + + sig {returns(T.untyped)} + def rbx_27?(); end + + sig {returns(T.untyped)} + def rbx_2?(); end + + sig {returns(T.untyped)} + def ruby?(); end + + sig {returns(T.untyped)} + def ruby_18?(); end + + sig {returns(T.untyped)} + def ruby_19?(); end + + sig {returns(T.untyped)} + def ruby_1?(); end + + sig {returns(T.untyped)} + def ruby_20?(); end + + sig {returns(T.untyped)} + def ruby_21?(); end + + sig {returns(T.untyped)} + def ruby_22?(); end + + sig {returns(T.untyped)} + def ruby_23?(); end + + sig {returns(T.untyped)} + def ruby_24?(); end + + sig {returns(T.untyped)} + def ruby_25?(); end + + sig {returns(T.untyped)} + def ruby_26?(); end + + sig {returns(T.untyped)} + def ruby_27?(); end + + sig {returns(T.untyped)} + def ruby_2?(); end + + sig {returns(T.untyped)} + def truffleruby?(); end + + sig {returns(T.untyped)} + def truffleruby_18?(); end + + sig {returns(T.untyped)} + def truffleruby_19?(); end + + sig {returns(T.untyped)} + def truffleruby_1?(); end + + sig {returns(T.untyped)} + def truffleruby_20?(); end + + sig {returns(T.untyped)} + def truffleruby_21?(); end + + sig {returns(T.untyped)} + def truffleruby_22?(); end + + sig {returns(T.untyped)} + def truffleruby_23?(); end + + sig {returns(T.untyped)} + def truffleruby_24?(); end + + sig {returns(T.untyped)} + def truffleruby_25?(); end + + sig {returns(T.untyped)} + def truffleruby_26?(); end + + sig {returns(T.untyped)} + def truffleruby_27?(); end + + sig {returns(T.untyped)} + def truffleruby_2?(); end + + sig {returns(T.untyped)} + def x64_mingw?(); end + + sig {returns(T.untyped)} + def x64_mingw_18?(); end + + sig {returns(T.untyped)} + def x64_mingw_19?(); end + + sig {returns(T.untyped)} + def x64_mingw_1?(); end + + sig {returns(T.untyped)} + def x64_mingw_20?(); end + + sig {returns(T.untyped)} + def x64_mingw_21?(); end + + sig {returns(T.untyped)} + def x64_mingw_22?(); end + + sig {returns(T.untyped)} + def x64_mingw_23?(); end + + sig {returns(T.untyped)} + def x64_mingw_24?(); end + + sig {returns(T.untyped)} + def x64_mingw_25?(); end + + sig {returns(T.untyped)} + def x64_mingw_26?(); end + + sig {returns(T.untyped)} + def x64_mingw_27?(); end + + sig {returns(T.untyped)} + def x64_mingw_2?(); end +end + +class Bundler::CyclicDependencyError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::Definition + include ::Bundler::GemHelpers + sig {returns(T.untyped)} + def add_current_platform(); end + + sig do + params( + platform: T.untyped, + ) + .returns(T.untyped) + end + def add_platform(platform); end + + sig {returns(T.untyped)} + def current_dependencies(); end + + sig {returns(T.untyped)} + def dependencies(); end + + sig do + params( + explicit_flag: T.untyped, + ) + .returns(T.untyped) + end + def ensure_equivalent_gemfile_and_lockfile(explicit_flag=T.unsafe(nil)); end + + sig do + params( + current_spec: T.untyped, + ) + .returns(T.untyped) + end + def find_indexed_specs(current_spec); end + + sig do + params( + current_spec: T.untyped, + ) + .returns(T.untyped) + end + def find_resolved_spec(current_spec); end + + sig {returns(T.untyped)} + def gem_version_promoter(); end + + sig {returns(T.untyped)} + def gemfiles(); end + + sig {returns(T.untyped)} + def groups(); end + + sig {returns(T.untyped)} + def has_local_dependencies?(); end + + sig {returns(T.untyped)} + def has_rubygems_remotes?(); end + + sig {returns(T.untyped)} + def index(); end + + sig do + params( + lockfile: T.untyped, + dependencies: T.untyped, + sources: T.untyped, + unlock: T.untyped, + ruby_version: T.untyped, + optional_groups: T.untyped, + gemfiles: T.untyped, + ) + .returns(T.untyped) + end + def initialize(lockfile, dependencies, sources, unlock, ruby_version=T.unsafe(nil), optional_groups=T.unsafe(nil), gemfiles=T.unsafe(nil)); end + + sig do + params( + file: T.untyped, + preserve_unknown_sections: T.untyped, + ) + .returns(T.untyped) + end + def lock(file, preserve_unknown_sections=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def locked_bundler_version(); end + + sig {returns(T.untyped)} + def locked_deps(); end + + sig {returns(T.untyped)} + def locked_gems(); end + + sig {returns(T.untyped)} + def locked_ruby_version(); end + + sig {returns(T.untyped)} + def locked_ruby_version_object(); end + + sig {returns(T.untyped)} + def lockfile(); end + + sig {returns(T.untyped)} + def missing_specs(); end + + sig {returns(T.untyped)} + def missing_specs?(); end + + sig {returns(T.untyped)} + def new_platform?(); end + + sig {returns(T.untyped)} + def new_specs(); end + + sig {returns(T.untyped)} + def nothing_changed?(); end + + sig {returns(T.untyped)} + def platforms(); end + + sig do + params( + platform: T.untyped, + ) + .returns(T.untyped) + end + def remove_platform(platform); end + + sig {returns(T.untyped)} + def removed_specs(); end + + sig {returns(T.untyped)} + def requested_specs(); end + + sig {returns(T.untyped)} + def requires(); end + + sig {returns(T.untyped)} + def resolve(); end + + sig {returns(T.untyped)} + def resolve_remotely!(); end + + sig {returns(T.untyped)} + def resolve_with_cache!(); end + + sig {returns(T.untyped)} + def ruby_version(); end + + sig {returns(T.untyped)} + def spec_git_paths(); end + + sig {returns(T.untyped)} + def specs(); end + + sig do + params( + groups: T.untyped, + ) + .returns(T.untyped) + end + def specs_for(groups); end + + sig {returns(T.untyped)} + def to_lock(); end + + sig {returns(T.untyped)} + def unlocking?(); end + + sig {returns(T.untyped)} + def validate_platforms!(); end + + sig {returns(T.untyped)} + def validate_ruby!(); end + + sig {returns(T.untyped)} + def validate_runtime!(); end + + sig do + params( + gemfile: T.untyped, + lockfile: T.untyped, + unlock: T.untyped, + ) + .returns(T.untyped) + end + def self.build(gemfile, lockfile, unlock); end +end + +class Bundler::DepProxy + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def ==(other); end + + sig {returns(T.untyped)} + def __platform(); end + + sig {returns(T.untyped)} + def dep(); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def eql?(other); end + + sig {returns(T.untyped)} + def hash(); end + + sig do + params( + dep: T.untyped, + platform: T.untyped, + ) + .returns(T.untyped) + end + def initialize(dep, platform); end + + sig {returns(T.untyped)} + def name(); end + + sig {returns(T.untyped)} + def requirement(); end + + sig {returns(T.untyped)} + def to_s(); end + + sig {returns(T.untyped)} + def type(); end +end + +class Bundler::Dependency < Gem::Dependency + PLATFORM_MAP = ::T.let(nil, T.untyped) + REVERSE_PLATFORM_MAP = ::T.let(nil, T.untyped) + + sig {returns(T.untyped)} + def autorequire(); end + + sig {returns(T.untyped)} + def current_env?(); end + + sig {returns(T.untyped)} + def current_platform?(); end + + sig do + params( + valid_platforms: T.untyped, + ) + .returns(T.untyped) + end + def gem_platforms(valid_platforms); end + + sig {returns(T.untyped)} + def gemfile(); end + + sig {returns(T.untyped)} + def groups(); end + + sig do + params( + name: T.untyped, + version: T.untyped, + options: T.untyped, + blk: T.untyped, + ) + .returns(T.untyped) + end + def initialize(name, version, options=T.unsafe(nil), &blk); end + + sig {returns(T.untyped)} + def platforms(); end + + sig {returns(T.untyped)} + def should_include?(); end + + sig {returns(T.untyped)} + def specific?(); end + + sig {returns(T.untyped)} + def to_lock(); end +end + +class Bundler::DeprecatedError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::Dsl + include ::Bundler::RubyDsl + VALID_KEYS = ::T.let(nil, T.untyped) + VALID_PLATFORMS = ::T.let(nil, T.untyped) + + sig {returns(T.untyped)} + def dependencies(); end + + sig do + params( + dependencies: T.untyped, + ) + .returns(T.untyped) + end + def dependencies=(dependencies); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def env(name); end + + sig do + params( + gemfile: T.untyped, + contents: T.untyped, + ) + .returns(T.untyped) + end + def eval_gemfile(gemfile, contents=T.unsafe(nil)); end + + sig do + params( + name: T.untyped, + args: T.untyped, + ) + .returns(T.untyped) + end + def gem(name, *args); end + + sig do + params( + opts: T.untyped, + ) + .returns(T.untyped) + end + def gemspec(opts=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def gemspecs(); end + + sig do + params( + uri: T.untyped, + options: T.untyped, + blk: T.untyped, + ) + .returns(T.untyped) + end + def git(uri, options=T.unsafe(nil), &blk); end + + sig do + params( + name: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def git_source(name, &block); end + + sig do + params( + repo: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def github(repo, options=T.unsafe(nil)); end + + sig do + params( + args: T.untyped, + blk: T.untyped, + ) + .returns(T.untyped) + end + def group(*args, &blk); end + + sig {returns(T.untyped)} + def initialize(); end + + sig do + params( + args: T.untyped, + ) + .returns(T.untyped) + end + def install_if(*args); end + + sig do + params( + name: T.untyped, + args: T.untyped, + ) + .returns(T.untyped) + end + def method_missing(name, *args); end + + sig do + params( + path: T.untyped, + options: T.untyped, + blk: T.untyped, + ) + .returns(T.untyped) + end + def path(path, options=T.unsafe(nil), &blk); end + + sig do + params( + platforms: T.untyped, + ) + .returns(T.untyped) + end + def platform(*platforms); end + + sig do + params( + platforms: T.untyped, + ) + .returns(T.untyped) + end + def platforms(*platforms); end + + sig do + params( + args: T.untyped, + ) + .returns(T.untyped) + end + def plugin(*args); end + + sig do + params( + source: T.untyped, + args: T.untyped, + blk: T.untyped, + ) + .returns(T.untyped) + end + def source(source, *args, &blk); end + + sig do + params( + lockfile: T.untyped, + unlock: T.untyped, + ) + .returns(T.untyped) + end + def to_definition(lockfile, unlock); end + + sig do + params( + gemfile: T.untyped, + lockfile: T.untyped, + unlock: T.untyped, + ) + .returns(T.untyped) + end + def self.evaluate(gemfile, lockfile, unlock); end +end + +class Bundler::Dsl::DSLError < Bundler::GemfileError + sig {returns(T.untyped)} + def backtrace(); end + + sig {returns(T.untyped)} + def contents(); end + + sig {returns(T.untyped)} + def description(); end + + sig {returns(T.untyped)} + def dsl_path(); end + + sig do + params( + description: T.untyped, + dsl_path: T.untyped, + backtrace: T.untyped, + contents: T.untyped, + ) + .returns(T.untyped) + end + def initialize(description, dsl_path, backtrace, contents=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def status_code(); end + + sig {returns(T.untyped)} + def to_s(); end +end + +class Bundler::EndpointSpecification < Gem::Specification + # we need this because Gem::Specification extends Enumerable + Elem = type_template + ILLFORMED_MESSAGE = ::T.let(nil, T.untyped) + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def __swap__(spec); end + + sig {returns(T.untyped)} + def _local_specification(); end + + sig {returns(T.untyped)} + def bindir(); end + + sig {returns(T.untyped)} + def checksum(); end + + sig {returns(T.untyped)} + def dependencies(); end + + sig do + params( + dependencies: T.untyped, + ) + .returns(T.untyped) + end + def dependencies=(dependencies); end + + sig {returns(T.untyped)} + def executables(); end + + sig {returns(T.untyped)} + def extensions(); end + + sig {returns(T.untyped)} + def fetch_platform(); end + + sig do + params( + name: T.untyped, + version: T.untyped, + platform: T.untyped, + dependencies: T.untyped, + metadata: T.untyped, + ) + .returns(T.untyped) + end + def initialize(name, version, platform, dependencies, metadata=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def load_paths(); end + + sig {returns(T.untyped)} + def name(); end + + sig {returns(T.untyped)} + def platform(); end + + sig {returns(T.untyped)} + def post_install_message(); end + + sig {returns(T.untyped)} + def remote(); end + + sig do + params( + remote: T.untyped, + ) + .returns(T.untyped) + end + def remote=(remote); end + + sig {returns(T.untyped)} + def require_paths(); end + + sig {returns(T.untyped)} + def required_ruby_version(); end + + sig {returns(T.untyped)} + def required_rubygems_version(); end + + sig {returns(T.untyped)} + def source(); end + + sig do + params( + source: T.untyped, + ) + .returns(T.untyped) + end + def source=(source); end + + sig {returns(T.untyped)} + def version(); end +end + +class Bundler::EnvironmentPreserver + BUNDLER_KEYS = ::T.let(nil, T.untyped) + BUNDLER_PREFIX = ::T.let(nil, T.untyped) + INTENTIONALLY_NIL = ::T.let(nil, T.untyped) + + sig {returns(T.untyped)} + def backup(); end + + sig do + params( + env: T.untyped, + keys: T.untyped, + ) + .returns(T.untyped) + end + def initialize(env, keys); end + + sig {returns(T.untyped)} + def restore(); end +end + +class Bundler::FeatureFlag + sig {returns(T.untyped)} + def allow_bundler_dependency_conflicts?(); end + + sig {returns(T.untyped)} + def allow_offline_install?(); end + + sig {returns(T.untyped)} + def auto_clean_without_path?(); end + + sig {returns(T.untyped)} + def auto_config_jobs?(); end + + sig {returns(T.untyped)} + def bundler_10_mode?(); end + + sig {returns(T.untyped)} + def bundler_1_mode?(); end + + sig {returns(T.untyped)} + def bundler_2_mode?(); end + + sig {returns(T.untyped)} + def bundler_3_mode?(); end + + sig {returns(T.untyped)} + def bundler_4_mode?(); end + + sig {returns(T.untyped)} + def bundler_5_mode?(); end + + sig {returns(T.untyped)} + def bundler_6_mode?(); end + + sig {returns(T.untyped)} + def bundler_7_mode?(); end + + sig {returns(T.untyped)} + def bundler_8_mode?(); end + + sig {returns(T.untyped)} + def bundler_9_mode?(); end + + sig {returns(T.untyped)} + def cache_all?(); end + + sig {returns(T.untyped)} + def cache_command_is_package?(); end + + sig {returns(T.untyped)} + def console_command?(); end + + sig {returns(T.untyped)} + def default_cli_command(); end + + sig {returns(T.untyped)} + def default_install_uses_path?(); end + + sig {returns(T.untyped)} + def deployment_means_frozen?(); end + + sig {returns(T.untyped)} + def disable_multisource?(); end + + sig {returns(T.untyped)} + def error_on_stderr?(); end + + sig {returns(T.untyped)} + def forget_cli_options?(); end + + sig {returns(T.untyped)} + def global_gem_cache?(); end + + sig {returns(T.untyped)} + def global_path_appends_ruby_scope?(); end + + sig {returns(T.untyped)} + def init_gems_rb?(); end + + sig do + params( + bundler_version: T.untyped, + ) + .returns(T.untyped) + end + def initialize(bundler_version); end + + sig {returns(T.untyped)} + def list_command?(); end + + sig {returns(T.untyped)} + def lockfile_uses_separate_rubygems_sources?(); end + + sig {returns(T.untyped)} + def only_update_to_newer_versions?(); end + + sig {returns(T.untyped)} + def path_relative_to_cwd?(); end + + sig {returns(T.untyped)} + def plugins?(); end + + sig {returns(T.untyped)} + def prefer_gems_rb?(); end + + sig {returns(T.untyped)} + def print_only_version_number?(); end + + sig {returns(T.untyped)} + def setup_makes_kernel_gem_public?(); end + + sig {returns(T.untyped)} + def skip_default_git_sources?(); end + + sig {returns(T.untyped)} + def specific_platform?(); end + + sig {returns(T.untyped)} + def suppress_install_using_messages?(); end + + sig {returns(T.untyped)} + def unlock_source_unlocks_spec?(); end + + sig {returns(T.untyped)} + def update_requires_all_flag?(); end + + sig {returns(T.untyped)} + def use_gem_version_promoter_for_major_updates?(); end + + sig {returns(T.untyped)} + def viz_command?(); end +end + +module Bundler::FileUtils + include ::Bundler::FileUtils::StreamUtils_ + extend ::Bundler::FileUtils::StreamUtils_ + LOW_METHODS = ::T.let(nil, T.untyped) + METHODS = ::T.let(nil, T.untyped) + OPT_TABLE = ::T.let(nil, T.untyped) + + sig do + params( + dir: T.untyped, + verbose: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def self.cd(dir, verbose: T.unsafe(nil), &block); end + + sig do + params( + dir: T.untyped, + verbose: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def self.chdir(dir, verbose: T.unsafe(nil), &block); end + + sig do + params( + mode: T.untyped, + list: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.chmod(mode, list, noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + mode: T.untyped, + list: T.untyped, + noop: T.untyped, + verbose: T.untyped, + force: T.untyped, + ) + .returns(T.untyped) + end + def self.chmod_R(mode, list, noop: T.unsafe(nil), verbose: T.unsafe(nil), force: T.unsafe(nil)); end + + sig do + params( + user: T.untyped, + group: T.untyped, + list: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.chown(user, group, list, noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + user: T.untyped, + group: T.untyped, + list: T.untyped, + noop: T.untyped, + verbose: T.untyped, + force: T.untyped, + ) + .returns(T.untyped) + end + def self.chown_R(user, group, list, noop: T.unsafe(nil), verbose: T.unsafe(nil), force: T.unsafe(nil)); end + + sig do + params( + a: T.untyped, + b: T.untyped, + ) + .returns(T.untyped) + end + def self.cmp(a, b); end + + sig do + params( + opt: T.untyped, + ) + .returns(T.untyped) + end + def self.collect_method(opt); end + + sig {returns(T.untyped)} + def self.commands(); end + + sig do + params( + a: T.untyped, + b: T.untyped, + ) + .returns(T.untyped) + end + def self.compare_file(a, b); end + + sig do + params( + a: T.untyped, + b: T.untyped, + ) + .returns(T.untyped) + end + def self.compare_stream(a, b); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + preserve: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.copy(src, dest, preserve: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + preserve: T.untyped, + dereference_root: T.untyped, + remove_destination: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_entry(src, dest, preserve=T.unsafe(nil), dereference_root=T.unsafe(nil), remove_destination=T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + preserve: T.untyped, + dereference: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_file(src, dest, preserve=T.unsafe(nil), dereference=T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_stream(src, dest); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + preserve: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.cp(src, dest, preserve: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + preserve: T.untyped, + noop: T.untyped, + verbose: T.untyped, + dereference_root: T.untyped, + remove_destination: T.untyped, + ) + .returns(T.untyped) + end + def self.cp_r(src, dest, preserve: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil), dereference_root: T.unsafe(nil), remove_destination: T.unsafe(nil)); end + + sig {returns(T.untyped)} + def self.getwd(); end + + sig do + params( + mid: T.untyped, + opt: T.untyped, + ) + .returns(T.untyped) + end + def self.have_option?(mid, opt); end + + sig do + params( + a: T.untyped, + b: T.untyped, + ) + .returns(T.untyped) + end + def self.identical?(a, b); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + mode: T.untyped, + owner: T.untyped, + group: T.untyped, + preserve: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.install(src, dest, mode: T.unsafe(nil), owner: T.unsafe(nil), group: T.unsafe(nil), preserve: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + force: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.link(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + force: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.ln(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + force: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.ln_s(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.ln_sf(src, dest, noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + mode: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.makedirs(list, mode: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + mode: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.mkdir(list, mode: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + mode: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.mkdir_p(list, mode: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + mode: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.mkpath(list, mode: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + force: T.untyped, + noop: T.untyped, + verbose: T.untyped, + secure: T.untyped, + ) + .returns(T.untyped) + end + def self.move(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil), secure: T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + force: T.untyped, + noop: T.untyped, + verbose: T.untyped, + secure: T.untyped, + ) + .returns(T.untyped) + end + def self.mv(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil), secure: T.unsafe(nil)); end + + sig {returns(T.untyped)} + def self.options(); end + + sig do + params( + mid: T.untyped, + ) + .returns(T.untyped) + end + def self.options_of(mid); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def self.private_module_function(name); end + + sig {returns(T.untyped)} + def self.pwd(); end + + sig do + params( + list: T.untyped, + force: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.remove(list, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + path: T.untyped, + force: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_dir(path, force=T.unsafe(nil)); end + + sig do + params( + path: T.untyped, + force: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_entry(path, force=T.unsafe(nil)); end + + sig do + params( + path: T.untyped, + force: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_entry_secure(path, force=T.unsafe(nil)); end + + sig do + params( + path: T.untyped, + force: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_file(path, force=T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + force: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.rm(list, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_f(list, noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + force: T.untyped, + noop: T.untyped, + verbose: T.untyped, + secure: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_r(list, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil), secure: T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + noop: T.untyped, + verbose: T.untyped, + secure: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_rf(list, noop: T.unsafe(nil), verbose: T.unsafe(nil), secure: T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + parents: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.rmdir(list, parents: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + noop: T.untyped, + verbose: T.untyped, + secure: T.untyped, + ) + .returns(T.untyped) + end + def self.rmtree(list, noop: T.unsafe(nil), verbose: T.unsafe(nil), secure: T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.safe_unlink(list, noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + force: T.untyped, + noop: T.untyped, + verbose: T.untyped, + ) + .returns(T.untyped) + end + def self.symlink(src, dest, force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end + + sig do + params( + list: T.untyped, + noop: T.untyped, + verbose: T.untyped, + mtime: T.untyped, + nocreate: T.untyped, + ) + .returns(T.untyped) + end + def self.touch(list, noop: T.unsafe(nil), verbose: T.unsafe(nil), mtime: T.unsafe(nil), nocreate: T.unsafe(nil)); end + + sig do + params( + new: T.untyped, + old_list: T.untyped, + ) + .returns(T.untyped) + end + def self.uptodate?(new, old_list); end +end + +module Bundler::FileUtils::DryRun + include ::Bundler::FileUtils::LowMethods + include ::Bundler::FileUtils + include ::Bundler::FileUtils::StreamUtils_ + extend ::Bundler::FileUtils::DryRun + extend ::Bundler::FileUtils::LowMethods + extend ::Bundler::FileUtils + extend ::Bundler::FileUtils::StreamUtils_ + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.cd(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.chdir(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chmod(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chmod_R(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chown(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chown_R(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.cmp(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.compare_file(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.compare_stream(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.copy(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_entry(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_file(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_stream(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.cp(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.cp_r(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.getwd(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.identical?(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.install(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.link(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.ln(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.ln_s(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.ln_sf(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.makedirs(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mkdir(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mkdir_p(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mkpath(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.move(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mv(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.pwd(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.remove(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_dir(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_entry(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_entry_secure(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_file(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_f(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_r(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_rf(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rmdir(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rmtree(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.safe_unlink(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.symlink(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.touch(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.uptodate?(*_); end +end + +class Bundler::FileUtils::Entry_ + include ::Bundler::FileUtils::StreamUtils_ + DIRECTORY_TERM = ::T.let(nil, T.untyped) + SYSCASE = ::T.let(nil, T.untyped) + S_IF_DOOR = ::T.let(nil, T.untyped) + + sig {returns(T.untyped)} + def blockdev?(); end + + sig {returns(T.untyped)} + def chardev?(); end + + sig do + params( + mode: T.untyped, + ) + .returns(T.untyped) + end + def chmod(mode); end + + sig do + params( + uid: T.untyped, + gid: T.untyped, + ) + .returns(T.untyped) + end + def chown(uid, gid); end + + sig do + params( + dest: T.untyped, + ) + .returns(T.untyped) + end + def copy(dest); end + + sig do + params( + dest: T.untyped, + ) + .returns(T.untyped) + end + def copy_file(dest); end + + sig do + params( + path: T.untyped, + ) + .returns(T.untyped) + end + def copy_metadata(path); end + + sig {returns(T.untyped)} + def dereference?(); end + + sig {returns(T.untyped)} + def directory?(); end + + sig {returns(T.untyped)} + def door?(); end + + sig {returns(T.untyped)} + def entries(); end + + sig {returns(T.untyped)} + def exist?(); end + + sig {returns(T.untyped)} + def file?(); end + + sig do + params( + a: T.untyped, + b: T.untyped, + deref: T.untyped, + ) + .returns(T.untyped) + end + def initialize(a, b=T.unsafe(nil), deref=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def inspect(); end + + sig {returns(T.untyped)} + def lstat(); end + + sig {returns(T.untyped)} + def lstat!(); end + + sig {returns(T.untyped)} + def path(); end + + sig {returns(T.untyped)} + def pipe?(); end + + sig {returns(T.untyped)} + def platform_support(); end + + sig {returns(T.untyped)} + def postorder_traverse(); end + + sig {returns(T.untyped)} + def prefix(); end + + sig {returns(T.untyped)} + def preorder_traverse(); end + + sig {returns(T.untyped)} + def rel(); end + + sig {returns(T.untyped)} + def remove(); end + + sig {returns(T.untyped)} + def remove_dir1(); end + + sig {returns(T.untyped)} + def remove_file(); end + + sig {returns(T.untyped)} + def socket?(); end + + sig {returns(T.untyped)} + def stat(); end + + sig {returns(T.untyped)} + def stat!(); end + + sig {returns(T.untyped)} + def symlink?(); end + + sig {returns(T.untyped)} + def traverse(); end + + sig do + params( + pre: T.untyped, + post: T.untyped, + ) + .returns(T.untyped) + end + def wrap_traverse(pre, post); end +end + +module Bundler::FileUtils::LowMethods +end + +module Bundler::FileUtils::NoWrite + include ::Bundler::FileUtils::LowMethods + include ::Bundler::FileUtils + include ::Bundler::FileUtils::StreamUtils_ + extend ::Bundler::FileUtils::NoWrite + extend ::Bundler::FileUtils::LowMethods + extend ::Bundler::FileUtils + extend ::Bundler::FileUtils::StreamUtils_ + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.cd(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.chdir(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chmod(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chmod_R(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chown(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chown_R(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.cmp(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.compare_file(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.compare_stream(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.copy(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_entry(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_file(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_stream(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.cp(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.cp_r(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.getwd(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.identical?(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.install(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.link(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.ln(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.ln_s(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.ln_sf(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.makedirs(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mkdir(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mkdir_p(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mkpath(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.move(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mv(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.pwd(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.remove(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_dir(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_entry(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_entry_secure(*_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_file(*_); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_f(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_r(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_rf(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rmdir(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rmtree(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.safe_unlink(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.symlink(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.touch(*args, **options); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.uptodate?(*_); end +end + +module Bundler::FileUtils::StreamUtils_ +end + +module Bundler::FileUtils::Verbose + include ::Bundler::FileUtils + include ::Bundler::FileUtils::StreamUtils_ + extend ::Bundler::FileUtils::Verbose + extend ::Bundler::FileUtils + extend ::Bundler::FileUtils::StreamUtils_ + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.cd(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chdir(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chmod(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chmod_R(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chown(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.chown_R(*args, **options); end + + sig do + params( + a: T.untyped, + b: T.untyped, + ) + .returns(T.untyped) + end + def self.cmp(a, b); end + + sig do + params( + a: T.untyped, + b: T.untyped, + ) + .returns(T.untyped) + end + def self.compare_file(a, b); end + + sig do + params( + a: T.untyped, + b: T.untyped, + ) + .returns(T.untyped) + end + def self.compare_stream(a, b); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.copy(*args, **options); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + preserve: T.untyped, + dereference_root: T.untyped, + remove_destination: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_entry(src, dest, preserve=T.unsafe(nil), dereference_root=T.unsafe(nil), remove_destination=T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + preserve: T.untyped, + dereference: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_file(src, dest, preserve=T.unsafe(nil), dereference=T.unsafe(nil)); end + + sig do + params( + src: T.untyped, + dest: T.untyped, + ) + .returns(T.untyped) + end + def self.copy_stream(src, dest); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.cp(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.cp_r(*args, **options); end + + sig {returns(T.untyped)} + def self.getwd(); end + + sig do + params( + a: T.untyped, + b: T.untyped, + ) + .returns(T.untyped) + end + def self.identical?(a, b); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.install(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.link(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.ln(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.ln_s(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.ln_sf(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.makedirs(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mkdir(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mkdir_p(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mkpath(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.move(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.mv(*args, **options); end + + sig {returns(T.untyped)} + def self.pwd(); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.remove(*args, **options); end + + sig do + params( + path: T.untyped, + force: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_dir(path, force=T.unsafe(nil)); end + + sig do + params( + path: T.untyped, + force: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_entry(path, force=T.unsafe(nil)); end + + sig do + params( + path: T.untyped, + force: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_entry_secure(path, force=T.unsafe(nil)); end + + sig do + params( + path: T.untyped, + force: T.untyped, + ) + .returns(T.untyped) + end + def self.remove_file(path, force=T.unsafe(nil)); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_f(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_r(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rm_rf(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rmdir(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.rmtree(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.safe_unlink(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.symlink(*args, **options); end + + sig do + params( + args: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.touch(*args, **options); end + + sig do + params( + new: T.untyped, + old_list: T.untyped, + ) + .returns(T.untyped) + end + def self.uptodate?(new, old_list); end +end + +module Bundler::GemHelpers + GENERICS = ::T.let(nil, T.untyped) + GENERIC_CACHE = ::T.let(nil, T.untyped) + + sig do + params( + p: T.untyped, + ) + .returns(T.untyped) + end + def self.generic(p); end + + sig {returns(T.untyped)} + def self.generic_local_platform(); end + + sig do + params( + spec_platform: T.untyped, + user_platform: T.untyped, + ) + .returns(T.untyped) + end + def self.platform_specificity_match(spec_platform, user_platform); end + + sig do + params( + specs: T.untyped, + platform: T.untyped, + ) + .returns(T.untyped) + end + def self.select_best_platform_match(specs, platform); end +end + +class Bundler::GemHelpers::PlatformMatch < Struct + extend T::Generic + Elem = type_member(fixed: T.untyped) + + EXACT_MATCH = ::T.let(nil, T.untyped) + WORST_MATCH = ::T.let(nil, T.untyped) + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def <=>(other); end + + sig {returns(T.untyped)} + def cpu_match(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def cpu_match=(_); end + + sig {returns(T.untyped)} + def os_match(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def os_match=(_); end + + sig {returns(T.untyped)} + def platform_version_match(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def platform_version_match=(_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.[](*_); end + + sig do + params( + spec_platform: T.untyped, + user_platform: T.untyped, + ) + .returns(T.untyped) + end + def self.cpu_match(spec_platform, user_platform); end + + sig {returns(T.untyped)} + def self.members(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.new(*_); end + + sig do + params( + spec_platform: T.untyped, + user_platform: T.untyped, + ) + .returns(T.untyped) + end + def self.os_match(spec_platform, user_platform); end + + sig do + params( + spec_platform: T.untyped, + user_platform: T.untyped, + ) + .returns(T.untyped) + end + def self.platform_version_match(spec_platform, user_platform); end +end + +class Bundler::GemNotFound < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::GemRequireError < Bundler::BundlerError + sig do + params( + orig_exception: T.untyped, + msg: T.untyped, + ) + .returns(T.untyped) + end + def initialize(orig_exception, msg); end + + sig {returns(T.untyped)} + def orig_exception(); end + + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::GemfileError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::GemfileEvalError < Bundler::GemfileError +end + +class Bundler::GemfileLockNotFound < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::GemfileNotFound < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::GemspecError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::GenericSystemCallError < Bundler::BundlerError + sig do + params( + underlying_error: T.untyped, + message: T.untyped, + ) + .returns(T.untyped) + end + def initialize(underlying_error, message); end + + sig {returns(T.untyped)} + def status_code(); end + + sig {returns(T.untyped)} + def underlying_error(); end +end + +class Bundler::GitError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::HTTPError < Bundler::BundlerError + sig do + params( + uri: T.untyped, + ) + .returns(T.untyped) + end + def filter_uri(uri); end + + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::Fetcher::AuthenticationRequiredError < Bundler::HTTPError +end + +class Bundler::Fetcher::BadAuthenticationError < Bundler::HTTPError +end + +class Bundler::Fetcher::CertificateFailureError < Bundler::HTTPError +end + +class Bundler::Fetcher::FallbackError < Bundler::HTTPError +end + +class Bundler::Fetcher::NetworkDownError < Bundler::HTTPError +end + +class Bundler::Fetcher::SSLError < Bundler::HTTPError +end + +class Bundler::Index + include T::Enumerable + EMPTY_SEARCH = ::T.let(nil, T.untyped) + NULL = ::T.let(nil, T.untyped) + RUBY = ::T.let(nil, T.untyped) + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def <<(spec); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def ==(other); end + + sig do + params( + query: T.untyped, + base: T.untyped, + ) + .returns(T.untyped) + end + def [](query, base=T.unsafe(nil)); end + + sig do + params( + index: T.untyped, + ) + .returns(T.untyped) + end + def add_source(index); end + + sig {returns(T.untyped)} + def all_specs(); end + + sig do + params( + spec: T.untyped, + other_spec: T.untyped, + ) + .returns(T.untyped) + end + def dependencies_eql?(spec, other_spec); end + + sig {returns(T.untyped)} + def dependency_names(); end + + sig do + params( + blk: T.untyped, + ) + .returns(T.untyped) + end + def each(&blk); end + + sig {returns(T.untyped)} + def empty?(); end + + sig {returns(T.untyped)} + def initialize(); end + + sig {returns(T.untyped)} + def inspect(); end + + sig do + params( + query: T.untyped, + base: T.untyped, + ) + .returns(T.untyped) + end + def local_search(query, base=T.unsafe(nil)); end + + sig do + params( + query: T.untyped, + base: T.untyped, + ) + .returns(T.untyped) + end + def search(query, base=T.unsafe(nil)); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def search_all(name); end + + sig {returns(T.untyped)} + def size(); end + + sig do + params( + specs: T.untyped, + ) + .returns(T.untyped) + end + def sort_specs(specs); end + + sig {returns(T.untyped)} + def sources(); end + + sig {returns(T.untyped)} + def spec_names(); end + + sig {returns(T.untyped)} + def specs(); end + + sig {returns(T.untyped)} + def unmet_dependency_names(); end + + sig do + params( + query: T.untyped, + base: T.untyped, + ) + .returns(T.untyped) + end + def unsorted_search(query, base); end + + sig do + params( + other: T.untyped, + override_dupes: T.untyped, + ) + .returns(T.untyped) + end + def use(other, override_dupes=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def self.build(); end + + sig do + params( + specs: T.untyped, + ) + .returns(T.untyped) + end + def self.sort_specs(specs); end +end + +class Bundler::InstallError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::InstallHookError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::InvalidOption < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::LazySpecification + include ::Bundler::MatchPlatform + include ::Bundler::GemHelpers + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def ==(other); end + + sig {returns(T.untyped)} + def __materialize__(); end + + sig {returns(T.untyped)} + def dependencies(); end + + sig {returns(T.untyped)} + def full_name(); end + + sig {returns(T.untyped)} + def git_version(); end + + sig {returns(T.untyped)} + def identifier(); end + + sig do + params( + name: T.untyped, + version: T.untyped, + platform: T.untyped, + source: T.untyped, + ) + .returns(T.untyped) + end + def initialize(name, version, platform, source=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def name(); end + + sig {returns(T.untyped)} + def platform(); end + + sig {returns(T.untyped)} + def remote(); end + + sig do + params( + remote: T.untyped, + ) + .returns(T.untyped) + end + def remote=(remote); end + + sig do + params( + args: T.untyped, + ) + .returns(T.untyped) + end + def respond_to?(*args); end + + sig do + params( + dependency: T.untyped, + ) + .returns(T.untyped) + end + def satisfies?(dependency); end + + sig {returns(T.untyped)} + def source(); end + + sig do + params( + source: T.untyped, + ) + .returns(T.untyped) + end + def source=(source); end + + sig {returns(T.untyped)} + def to_lock(); end + + sig {returns(T.untyped)} + def to_s(); end + + sig {returns(T.untyped)} + def version(); end +end + +class Bundler::LazySpecification::Identifier < Struct + include ::Comparable + extend ::T::Generic + + Elem = type_member(fixed: T.untyped) + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def <=>(other); end + + sig {returns(T.untyped)} + def dependencies(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def dependencies=(_); end + + sig {returns(T.untyped)} + def name(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def name=(_); end + + sig {returns(T.untyped)} + def platform(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def platform=(_); end + + sig {returns(T.untyped)} + def platform_string(); end + + sig {returns(T.untyped)} + def source(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def source=(_); end + + sig {returns(T.untyped)} + def version(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def version=(_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.[](*_); end + + sig {returns(T.untyped)} + def self.members(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.new(*_); end +end + +class Bundler::LockfileError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::LockfileParser + BUNDLED = ::T.let(nil, T.untyped) + DEPENDENCIES = ::T.let(nil, T.untyped) + ENVIRONMENT_VERSION_SECTIONS = ::T.let(nil, T.untyped) + GEM = ::T.let(nil, T.untyped) + GIT = ::T.let(nil, T.untyped) + KNOWN_SECTIONS = ::T.let(nil, T.untyped) + NAME_VERSION = ::T.let(nil, T.untyped) + OPTIONS = ::T.let(nil, T.untyped) + PATH = ::T.let(nil, T.untyped) + PLATFORMS = ::T.let(nil, T.untyped) + PLUGIN = ::T.let(nil, T.untyped) + RUBY = ::T.let(nil, T.untyped) + SECTIONS_BY_VERSION_INTRODUCED = ::T.let(nil, T.untyped) + SOURCE = ::T.let(nil, T.untyped) + SPECS = ::T.let(nil, T.untyped) + TYPES = ::T.let(nil, T.untyped) + + sig {returns(T.untyped)} + def bundler_version(); end + + sig {returns(T.untyped)} + def dependencies(); end + + sig do + params( + lockfile: T.untyped, + ) + .returns(T.untyped) + end + def initialize(lockfile); end + + sig {returns(T.untyped)} + def platforms(); end + + sig {returns(T.untyped)} + def ruby_version(); end + + sig {returns(T.untyped)} + def sources(); end + + sig {returns(T.untyped)} + def specs(); end + + sig {returns(T.untyped)} + def warn_for_outdated_bundler_version(); end + + sig do + params( + lockfile_contents: T.untyped, + ) + .returns(T.untyped) + end + def self.sections_in_lockfile(lockfile_contents); end + + sig do + params( + base_version: T.untyped, + ) + .returns(T.untyped) + end + def self.sections_to_ignore(base_version=T.unsafe(nil)); end + + sig do + params( + lockfile_contents: T.untyped, + ) + .returns(T.untyped) + end + def self.unknown_sections_in_lockfile(lockfile_contents); end +end + +class Bundler::MarshalError < StandardError +end + +module Bundler::MatchPlatform + include ::Bundler::GemHelpers + sig do + params( + p: T.untyped, + ) + .returns(T.untyped) + end + def match_platform(p); end + + sig do + params( + gemspec_platform: T.untyped, + local_platform: T.untyped, + ) + .returns(T.untyped) + end + def self.platforms_match?(gemspec_platform, local_platform); end +end + +module Bundler::Molinillo + VERSION = ::T.let(nil, T.untyped) + +end + +class Bundler::Molinillo::CircularDependencyError < Bundler::Molinillo::ResolverError + sig {returns(T.untyped)} + def dependencies(); end + + sig do + params( + vertices: T.untyped, + ) + .returns(T.untyped) + end + def initialize(vertices); end +end + +module Bundler::Molinillo::Compatibility + sig do + params( + enum: T.untyped, + blk: T.untyped, + ) + .returns(T.untyped) + end + def self.flat_map(enum, &blk); end +end + +module Bundler::Molinillo::Delegates +end + +module Bundler::Molinillo::Delegates::ResolutionState + sig {returns(T.untyped)} + def activated(); end + + sig {returns(T.untyped)} + def conflicts(); end + + sig {returns(T.untyped)} + def depth(); end + + sig {returns(T.untyped)} + def name(); end + + sig {returns(T.untyped)} + def possibilities(); end + + sig {returns(T.untyped)} + def requirement(); end + + sig {returns(T.untyped)} + def requirements(); end + + sig {returns(T.untyped)} + def unused_unwind_options(); end +end + +module Bundler::Molinillo::Delegates::SpecificationProvider + sig do + params( + dependency: T.untyped, + ) + .returns(T.untyped) + end + def allow_missing?(dependency); end + + sig do + params( + specification: T.untyped, + ) + .returns(T.untyped) + end + def dependencies_for(specification); end + + sig do + params( + dependency: T.untyped, + ) + .returns(T.untyped) + end + def name_for(dependency); end + + sig {returns(T.untyped)} + def name_for_explicit_dependency_source(); end + + sig {returns(T.untyped)} + def name_for_locking_dependency_source(); end + + sig do + params( + requirement: T.untyped, + activated: T.untyped, + spec: T.untyped, + ) + .returns(T.untyped) + end + def requirement_satisfied_by?(requirement, activated, spec); end + + sig do + params( + dependency: T.untyped, + ) + .returns(T.untyped) + end + def search_for(dependency); end + + sig do + params( + dependencies: T.untyped, + activated: T.untyped, + conflicts: T.untyped, + ) + .returns(T.untyped) + end + def sort_dependencies(dependencies, activated, conflicts); end +end + +class Bundler::Molinillo::DependencyGraph + include ::TSort + include T::Enumerable + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def ==(other); end + + sig do + params( + name: T.untyped, + payload: T.untyped, + parent_names: T.untyped, + requirement: T.untyped, + ) + .returns(T.untyped) + end + def add_child_vertex(name, payload, parent_names, requirement); end + + sig do + params( + origin: T.untyped, + destination: T.untyped, + requirement: T.untyped, + ) + .returns(T.untyped) + end + def add_edge(origin, destination, requirement); end + + sig do + params( + name: T.untyped, + payload: T.untyped, + root: T.untyped, + ) + .returns(T.untyped) + end + def add_vertex(name, payload, root=T.unsafe(nil)); end + + sig do + params( + edge: T.untyped, + ) + .returns(T.untyped) + end + def delete_edge(edge); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def detach_vertex_named(name); end + + sig do + params( + blk: T.untyped, + ) + .returns(T.untyped) + end + def each(&blk); end + + sig {returns(T.untyped)} + def initialize(); end + + sig {returns(T.untyped)} + def inspect(); end + + sig {returns(T.untyped)} + def log(); end + + sig do + params( + tag: T.untyped, + ) + .returns(T.untyped) + end + def rewind_to(tag); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def root_vertex_named(name); end + + sig do + params( + name: T.untyped, + payload: T.untyped, + ) + .returns(T.untyped) + end + def set_payload(name, payload); end + + sig do + params( + tag: T.untyped, + ) + .returns(T.untyped) + end + def tag(tag); end + + sig do + params( + options: T.untyped, + ) + .returns(T.untyped) + end + def to_dot(options=T.unsafe(nil)); end + + sig do + params( + vertex: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def tsort_each_child(vertex, &block); end + + sig {returns(T.untyped)} + def tsort_each_node(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def vertex_named(name); end + + sig {returns(T.untyped)} + def vertices(); end + + sig do + params( + vertices: T.untyped, + ) + .returns(T.untyped) + end + def self.tsort(vertices); end +end + +class Bundler::Molinillo::DependencyGraph::Action + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def down(graph); end + + sig {returns(T.untyped)} + def next(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def next=(_); end + + sig {returns(T.untyped)} + def previous(); end + + sig do + params( + previous: T.untyped, + ) + .returns(T.untyped) + end + def previous=(previous); end + + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def up(graph); end + + sig {returns(T.untyped)} + def self.action_name(); end +end + +class Bundler::Molinillo::DependencyGraph::AddEdgeNoCircular < Bundler::Molinillo::DependencyGraph::Action + sig {returns(T.untyped)} + def destination(); end + + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def down(graph); end + + sig do + params( + origin: T.untyped, + destination: T.untyped, + requirement: T.untyped, + ) + .returns(T.untyped) + end + def initialize(origin, destination, requirement); end + + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def make_edge(graph); end + + sig {returns(T.untyped)} + def origin(); end + + sig {returns(T.untyped)} + def requirement(); end + + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def up(graph); end + + sig {returns(T.untyped)} + def self.action_name(); end +end + +class Bundler::Molinillo::DependencyGraph::AddVertex < Bundler::Molinillo::DependencyGraph::Action + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def down(graph); end + + sig do + params( + name: T.untyped, + payload: T.untyped, + root: T.untyped, + ) + .returns(T.untyped) + end + def initialize(name, payload, root); end + + sig {returns(T.untyped)} + def name(); end + + sig {returns(T.untyped)} + def payload(); end + + sig {returns(T.untyped)} + def root(); end + + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def up(graph); end + + sig {returns(T.untyped)} + def self.action_name(); end +end + +class Bundler::Molinillo::DependencyGraph::DeleteEdge < Bundler::Molinillo::DependencyGraph::Action + sig {returns(T.untyped)} + def destination_name(); end + + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def down(graph); end + + sig do + params( + origin_name: T.untyped, + destination_name: T.untyped, + requirement: T.untyped, + ) + .returns(T.untyped) + end + def initialize(origin_name, destination_name, requirement); end + + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def make_edge(graph); end + + sig {returns(T.untyped)} + def origin_name(); end + + sig {returns(T.untyped)} + def requirement(); end + + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def up(graph); end + + sig {returns(T.untyped)} + def self.action_name(); end +end + +class Bundler::Molinillo::DependencyGraph::DetachVertexNamed < Bundler::Molinillo::DependencyGraph::Action + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def down(graph); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def initialize(name); end + + sig {returns(T.untyped)} + def name(); end + + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def up(graph); end + + sig {returns(T.untyped)} + def self.action_name(); end +end + +class Bundler::Molinillo::DependencyGraph::Edge < Struct + extend T::Generic + Elem = type_member(fixed: T.untyped) + + sig {returns(T.untyped)} + def destination(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def destination=(_); end + + sig {returns(T.untyped)} + def origin(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def origin=(_); end + + sig {returns(T.untyped)} + def requirement(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def requirement=(_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.[](*_); end + + sig {returns(T.untyped)} + def self.members(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.new(*_); end +end + +class Bundler::Molinillo::DependencyGraph::Log + extend T::Enumerable + sig do + params( + graph: T.untyped, + origin: T.untyped, + destination: T.untyped, + requirement: T.untyped, + ) + .returns(T.untyped) + end + def add_edge_no_circular(graph, origin, destination, requirement); end + + sig do + params( + graph: T.untyped, + name: T.untyped, + payload: T.untyped, + root: T.untyped, + ) + .returns(T.untyped) + end + def add_vertex(graph, name, payload, root); end + + sig do + params( + graph: T.untyped, + origin_name: T.untyped, + destination_name: T.untyped, + requirement: T.untyped, + ) + .returns(T.untyped) + end + def delete_edge(graph, origin_name, destination_name, requirement); end + + sig do + params( + graph: T.untyped, + name: T.untyped, + ) + .returns(T.untyped) + end + def detach_vertex_named(graph, name); end + + sig do + params( + blk: T.untyped, + ) + .returns(T.untyped) + end + def each(&blk); end + + sig {returns(T.untyped)} + def initialize(); end + + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def pop!(graph); end + + sig {returns(T.untyped)} + def reverse_each(); end + + sig do + params( + graph: T.untyped, + tag: T.untyped, + ) + .returns(T.untyped) + end + def rewind_to(graph, tag); end + + sig do + params( + graph: T.untyped, + name: T.untyped, + payload: T.untyped, + ) + .returns(T.untyped) + end + def set_payload(graph, name, payload); end + + sig do + params( + graph: T.untyped, + tag: T.untyped, + ) + .returns(T.untyped) + end + def tag(graph, tag); end +end + +class Bundler::Molinillo::DependencyGraph::SetPayload < Bundler::Molinillo::DependencyGraph::Action + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def down(graph); end + + sig do + params( + name: T.untyped, + payload: T.untyped, + ) + .returns(T.untyped) + end + def initialize(name, payload); end + + sig {returns(T.untyped)} + def name(); end + + sig {returns(T.untyped)} + def payload(); end + + sig do + params( + graph: T.untyped, + ) + .returns(T.untyped) + end + def up(graph); end + + sig {returns(T.untyped)} + def self.action_name(); end +end + +class Bundler::Molinillo::DependencyGraph::Tag < Bundler::Molinillo::DependencyGraph::Action + sig do + params( + _graph: T.untyped, + ) + .returns(T.untyped) + end + def down(_graph); end + + sig do + params( + tag: T.untyped, + ) + .returns(T.untyped) + end + def initialize(tag); end + + sig {returns(T.untyped)} + def tag(); end + + sig do + params( + _graph: T.untyped, + ) + .returns(T.untyped) + end + def up(_graph); end + + sig {returns(T.untyped)} + def self.action_name(); end +end + +class Bundler::Molinillo::DependencyGraph::Vertex + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def ==(other); end + + sig do + params( + other: T.untyped, + visited: T.untyped, + ) + .returns(T.untyped) + end + def _path_to?(other, visited=T.unsafe(nil)); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def ancestor?(other); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def descendent?(other); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def eql?(other); end + + sig {returns(T.untyped)} + def explicit_requirements(); end + + sig {returns(T.untyped)} + def hash(); end + + sig {returns(T.untyped)} + def incoming_edges(); end + + sig do + params( + incoming_edges: T.untyped, + ) + .returns(T.untyped) + end + def incoming_edges=(incoming_edges); end + + sig do + params( + name: T.untyped, + payload: T.untyped, + ) + .returns(T.untyped) + end + def initialize(name, payload); end + + sig {returns(T.untyped)} + def inspect(); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def is_reachable_from?(other); end + + sig {returns(T.untyped)} + def name(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def name=(name); end + + sig {returns(T.untyped)} + def outgoing_edges(); end + + sig do + params( + outgoing_edges: T.untyped, + ) + .returns(T.untyped) + end + def outgoing_edges=(outgoing_edges); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def path_to?(other); end + + sig {returns(T.untyped)} + def payload(); end + + sig do + params( + payload: T.untyped, + ) + .returns(T.untyped) + end + def payload=(payload); end + + sig {returns(T.untyped)} + def predecessors(); end + + sig {returns(T.untyped)} + def recursive_predecessors(); end + + sig {returns(T.untyped)} + def recursive_successors(); end + + sig {returns(T.untyped)} + def requirements(); end + + sig {returns(T.untyped)} + def root(); end + + sig do + params( + root: T.untyped, + ) + .returns(T.untyped) + end + def root=(root); end + + sig {returns(T.untyped)} + def root?(); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def shallow_eql?(other); end + + sig {returns(T.untyped)} + def successors(); end +end + +class Bundler::Molinillo::DependencyState < Bundler::Molinillo::ResolutionState + extend T::Generic + Elem = type_member(fixed: T.untyped) + + sig {returns(T.untyped)} + def pop_possibility_state(); end +end + +class Bundler::Molinillo::NoSuchDependencyError < Bundler::Molinillo::ResolverError + sig {returns(T.untyped)} + def dependency(); end + + sig do + params( + dependency: T.untyped, + ) + .returns(T.untyped) + end + def dependency=(dependency); end + + sig do + params( + dependency: T.untyped, + required_by: T.untyped, + ) + .returns(T.untyped) + end + def initialize(dependency, required_by=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def message(); end + + sig {returns(T.untyped)} + def required_by(); end + + sig do + params( + required_by: T.untyped, + ) + .returns(T.untyped) + end + def required_by=(required_by); end +end + +class Bundler::Molinillo::PossibilityState < Bundler::Molinillo::ResolutionState + extend T::Generic + Elem = type_member(fixed: T.untyped) +end + +class Bundler::Molinillo::ResolutionState < Struct + extend T::Generic + Elem = type_member(fixed: T.untyped) + + sig {returns(T.untyped)} + def activated(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def activated=(_); end + + sig {returns(T.untyped)} + def conflicts(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def conflicts=(_); end + + sig {returns(T.untyped)} + def depth(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def depth=(_); end + + sig {returns(T.untyped)} + def name(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def name=(_); end + + sig {returns(T.untyped)} + def possibilities(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def possibilities=(_); end + + sig {returns(T.untyped)} + def requirement(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def requirement=(_); end + + sig {returns(T.untyped)} + def requirements(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def requirements=(_); end + + sig {returns(T.untyped)} + def unused_unwind_options(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def unused_unwind_options=(_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.[](*_); end + + sig {returns(T.untyped)} + def self.empty(); end + + sig {returns(T.untyped)} + def self.members(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.new(*_); end +end + +class Bundler::Molinillo::Resolver + sig do + params( + specification_provider: T.untyped, + resolver_ui: T.untyped, + ) + .returns(T.untyped) + end + def initialize(specification_provider, resolver_ui); end + + sig do + params( + requested: T.untyped, + base: T.untyped, + ) + .returns(T.untyped) + end + def resolve(requested, base=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def resolver_ui(); end + + sig {returns(T.untyped)} + def specification_provider(); end +end + +class Bundler::Molinillo::Resolver::Resolution + include ::Bundler::Molinillo::Delegates::SpecificationProvider + include ::Bundler::Molinillo::Delegates::ResolutionState + sig {returns(T.untyped)} + def base(); end + + sig do + params( + specification_provider: T.untyped, + resolver_ui: T.untyped, + requested: T.untyped, + base: T.untyped, + ) + .returns(T.untyped) + end + def initialize(specification_provider, resolver_ui, requested, base); end + + sig do + params( + iteration_rate: T.untyped, + ) + .returns(T.untyped) + end + def iteration_rate=(iteration_rate); end + + sig {returns(T.untyped)} + def original_requested(); end + + sig {returns(T.untyped)} + def resolve(); end + + sig {returns(T.untyped)} + def resolver_ui(); end + + sig {returns(T.untyped)} + def specification_provider(); end + + sig do + params( + started_at: T.untyped, + ) + .returns(T.untyped) + end + def started_at=(started_at); end + + sig do + params( + states: T.untyped, + ) + .returns(T.untyped) + end + def states=(states); end +end + +class Bundler::Molinillo::Resolver::Resolution::Conflict < Struct + extend T::Generic + Elem = type_member(fixed: T.untyped) + + sig {returns(T.untyped)} + def activated_by_name(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def activated_by_name=(_); end + + sig {returns(T.untyped)} + def existing(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def existing=(_); end + + sig {returns(T.untyped)} + def locked_requirement(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def locked_requirement=(_); end + + sig {returns(T.untyped)} + def possibility(); end + + sig {returns(T.untyped)} + def possibility_set(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def possibility_set=(_); end + + sig {returns(T.untyped)} + def requirement(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def requirement=(_); end + + sig {returns(T.untyped)} + def requirement_trees(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def requirement_trees=(_); end + + sig {returns(T.untyped)} + def requirements(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def requirements=(_); end + + sig {returns(T.untyped)} + def underlying_error(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def underlying_error=(_); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.[](*_); end + + sig {returns(T.untyped)} + def self.members(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.new(*_); end +end + +class Bundler::Molinillo::Resolver::Resolution::PossibilitySet < Struct + extend T::Generic + Elem = type_member(fixed: T.untyped) + + sig {returns(T.untyped)} + def dependencies(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def dependencies=(_); end + + sig {returns(T.untyped)} + def latest_version(); end + + sig {returns(T.untyped)} + def possibilities(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def possibilities=(_); end + + sig {returns(T.untyped)} + def to_s(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.[](*_); end + + sig {returns(T.untyped)} + def self.members(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.new(*_); end +end + +class Bundler::Molinillo::Resolver::Resolution::UnwindDetails < Struct + include ::Comparable + extend T::Generic + Elem = type_member(fixed: T.untyped) + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def <=>(other); end + + sig {returns(T.untyped)} + def all_requirements(); end + + sig {returns(T.untyped)} + def conflicting_requirements(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def conflicting_requirements=(_); end + + sig {returns(T.untyped)} + def requirement_tree(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def requirement_tree=(_); end + + sig {returns(T.untyped)} + def requirement_trees(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def requirement_trees=(_); end + + sig {returns(T.untyped)} + def requirements_unwound_to_instead(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def requirements_unwound_to_instead=(_); end + + sig {returns(T.untyped)} + def reversed_requirement_tree_index(); end + + sig {returns(T.untyped)} + def state_index(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def state_index=(_); end + + sig {returns(T.untyped)} + def state_requirement(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def state_requirement=(_); end + + sig {returns(T.untyped)} + def sub_dependencies_to_avoid(); end + + sig {returns(T.untyped)} + def unwinding_to_primary_requirement?(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.[](*_); end + + sig {returns(T.untyped)} + def self.members(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.new(*_); end +end + +class Bundler::Molinillo::ResolverError < StandardError +end + +module Bundler::Molinillo::SpecificationProvider + sig do + params( + dependency: T.untyped, + ) + .returns(T.untyped) + end + def allow_missing?(dependency); end + + sig do + params( + specification: T.untyped, + ) + .returns(T.untyped) + end + def dependencies_for(specification); end + + sig do + params( + dependency: T.untyped, + ) + .returns(T.untyped) + end + def name_for(dependency); end + + sig {returns(T.untyped)} + def name_for_explicit_dependency_source(); end + + sig {returns(T.untyped)} + def name_for_locking_dependency_source(); end + + sig do + params( + requirement: T.untyped, + activated: T.untyped, + spec: T.untyped, + ) + .returns(T.untyped) + end + def requirement_satisfied_by?(requirement, activated, spec); end + + sig do + params( + dependency: T.untyped, + ) + .returns(T.untyped) + end + def search_for(dependency); end + + sig do + params( + dependencies: T.untyped, + activated: T.untyped, + conflicts: T.untyped, + ) + .returns(T.untyped) + end + def sort_dependencies(dependencies, activated, conflicts); end +end + +module Bundler::Molinillo::UI + sig {returns(T.untyped)} + def after_resolution(); end + + sig {returns(T.untyped)} + def before_resolution(); end + + sig do + params( + depth: T.untyped, + ) + .returns(T.untyped) + end + def debug(depth=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def debug?(); end + + sig {returns(T.untyped)} + def indicate_progress(); end + + sig {returns(T.untyped)} + def output(); end + + sig {returns(T.untyped)} + def progress_rate(); end +end + +class Bundler::Molinillo::VersionConflict < Bundler::Molinillo::ResolverError + include ::Bundler::Molinillo::Delegates::SpecificationProvider + sig {returns(T.untyped)} + def conflicts(); end + + sig do + params( + conflicts: T.untyped, + specification_provider: T.untyped, + ) + .returns(T.untyped) + end + def initialize(conflicts, specification_provider); end + + sig do + params( + opts: T.untyped, + ) + .returns(T.untyped) + end + def message_with_trees(opts=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def specification_provider(); end +end + +class Bundler::NoSpaceOnDeviceError < Bundler::PermissionError + sig {returns(T.untyped)} + def message(); end + + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::OperationNotSupportedError < Bundler::PermissionError + sig {returns(T.untyped)} + def message(); end + + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::PathError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::PermissionError < Bundler::BundlerError + sig {returns(T.untyped)} + def action(); end + + sig do + params( + path: T.untyped, + permission_type: T.untyped, + ) + .returns(T.untyped) + end + def initialize(path, permission_type=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def message(); end + + sig {returns(T.untyped)} + def status_code(); end +end + +module Bundler::Plugin + PLUGIN_FILE_NAME = ::T.let(nil, T.untyped) + + sig do + params( + command: T.untyped, + cls: T.untyped, + ) + .returns(T.untyped) + end + def self.add_command(command, cls); end + + sig do + params( + event: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def self.add_hook(event, &block); end + + sig do + params( + source: T.untyped, + cls: T.untyped, + ) + .returns(T.untyped) + end + def self.add_source(source, cls); end + + sig {returns(T.untyped)} + def self.cache(); end + + sig do + params( + command: T.untyped, + ) + .returns(T.untyped) + end + def self.command?(command); end + + sig do + params( + command: T.untyped, + args: T.untyped, + ) + .returns(T.untyped) + end + def self.exec_command(command, args); end + + sig do + params( + gemfile: T.untyped, + inline: T.untyped, + ) + .returns(T.untyped) + end + def self.gemfile_install(gemfile=T.unsafe(nil), &inline); end + + sig {returns(T.untyped)} + def self.global_root(); end + + sig do + params( + event: T.untyped, + args: T.untyped, + arg_blk: T.untyped, + ) + .returns(T.untyped) + end + def self.hook(event, *args, &arg_blk); end + + sig {returns(T.untyped)} + def self.index(); end + + sig do + params( + names: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def self.install(names, options); end + + sig do + params( + plugin: T.untyped, + ) + .returns(T.untyped) + end + def self.installed?(plugin); end + + sig {returns(T.untyped)} + def self.local_root(); end + + sig {returns(T.untyped)} + def self.reset!(); end + + sig {returns(T.untyped)} + def self.root(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def self.source(name); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def self.source?(name); end + + sig do + params( + locked_opts: T.untyped, + ) + .returns(T.untyped) + end + def self.source_from_lock(locked_opts); end +end + +class Bundler::Plugin::API + sig {returns(T.untyped)} + def cache_dir(); end + + sig do + params( + name: T.untyped, + args: T.untyped, + blk: T.untyped, + ) + .returns(T.untyped) + end + def method_missing(name, *args, &blk); end + + sig do + params( + names: T.untyped, + ) + .returns(T.untyped) + end + def tmp(*names); end + + sig do + params( + command: T.untyped, + cls: T.untyped, + ) + .returns(T.untyped) + end + def self.command(command, cls=T.unsafe(nil)); end + + sig do + params( + event: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def self.hook(event, &block); end + + sig do + params( + source: T.untyped, + cls: T.untyped, + ) + .returns(T.untyped) + end + def self.source(source, cls=T.unsafe(nil)); end +end + +class Bundler::Plugin::DSL + sig do + params( + name: T.untyped, + args: T.untyped + ) + .returns(T.untyped) + end + def _gem(name, *args); end + + sig { returns(T.untyped) } + def inferred_plugins(); end + + sig do + params( + name: T.untyped, + args: T.untyped + ) + .returns(T.untyped) + end + def plugin(name, *args); end +end + +module Bundler::Plugin::Events + def self.defined_event?(event); end +end + +class Bundler::Plugin::Index + def command_plugin(command); end + + def commands(); end + + def global_index_file(); end + + def hook_plugins(event); end + + def index_file(); end + + def installed?(name); end + + def load_paths(name); end + + def local_index_file(); end + + def plugin_path(name); end + + def register_plugin(name, path, load_paths, commands, sources, hooks); end + + def source?(source); end + + def source_plugin(name); end +end + +class Bundler::Plugin::MalformattedPlugin < Bundler::PluginError +end + +class Bundler::Plugin::UndefinedCommandError < Bundler::PluginError +end + +class Bundler::Plugin::UnknownSourceError < Bundler::PluginError +end + +class Bundler::Plugin::DSL::PluginGemfileError < Bundler::PluginError +end + +class Bundler::PluginError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::ProductionError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::RemoteSpecification + include ::Comparable + include ::Bundler::MatchPlatform + include ::Bundler::GemHelpers + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def <=>(other); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def __swap__(spec); end + + sig {returns(T.untyped)} + def dependencies(); end + + sig do + params( + dependencies: T.untyped, + ) + .returns(T.untyped) + end + def dependencies=(dependencies); end + + sig {returns(T.untyped)} + def fetch_platform(); end + + sig {returns(T.untyped)} + def full_name(); end + + sig {returns(T.untyped)} + def git_version(); end + + sig do + params( + name: T.untyped, + version: T.untyped, + platform: T.untyped, + spec_fetcher: T.untyped, + ) + .returns(T.untyped) + end + def initialize(name, version, platform, spec_fetcher); end + + sig {returns(T.untyped)} + def name(); end + + sig {returns(T.untyped)} + def platform(); end + + sig {returns(T.untyped)} + def remote(); end + + sig do + params( + remote: T.untyped, + ) + .returns(T.untyped) + end + def remote=(remote); end + + sig do + params( + method: T.untyped, + include_all: T.untyped, + ) + .returns(T.untyped) + end + def respond_to?(method, include_all=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def sort_obj(); end + + sig {returns(T.untyped)} + def source(); end + + sig do + params( + source: T.untyped, + ) + .returns(T.untyped) + end + def source=(source); end + + sig {returns(T.untyped)} + def to_s(); end + + sig {returns(T.untyped)} + def version(); end +end + +class Bundler::Resolver + include ::Bundler::Molinillo::SpecificationProvider + include ::Bundler::Molinillo::UI + sig {returns(T.untyped)} + def after_resolution(); end + + sig {returns(T.untyped)} + def before_resolution(); end + + sig do + params( + depth: T.untyped, + ) + .returns(T.untyped) + end + def debug(depth=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def debug?(); end + + sig do + params( + specification: T.untyped, + ) + .returns(T.untyped) + end + def dependencies_for(specification); end + + sig do + params( + dependency: T.untyped, + ) + .returns(T.untyped) + end + def index_for(dependency); end + + sig {returns(T.untyped)} + def indicate_progress(); end + + sig do + params( + index: T.untyped, + source_requirements: T.untyped, + base: T.untyped, + gem_version_promoter: T.untyped, + additional_base_requirements: T.untyped, + platforms: T.untyped, + ) + .returns(T.untyped) + end + def initialize(index, source_requirements, base, gem_version_promoter, additional_base_requirements, platforms); end + + sig do + params( + dependency: T.untyped, + ) + .returns(T.untyped) + end + def name_for(dependency); end + + sig {returns(T.untyped)} + def name_for_explicit_dependency_source(); end + + sig {returns(T.untyped)} + def name_for_locking_dependency_source(); end + + sig do + params( + vertex: T.untyped, + ) + .returns(T.untyped) + end + def relevant_sources_for_vertex(vertex); end + + sig do + params( + requirement: T.untyped, + activated: T.untyped, + spec: T.untyped, + ) + .returns(T.untyped) + end + def requirement_satisfied_by?(requirement, activated, spec); end + + sig do + params( + dependency: T.untyped, + ) + .returns(T.untyped) + end + def search_for(dependency); end + + sig do + params( + dependencies: T.untyped, + activated: T.untyped, + conflicts: T.untyped, + ) + .returns(T.untyped) + end + def sort_dependencies(dependencies, activated, conflicts); end + + sig do + params( + requirements: T.untyped, + ) + .returns(T.untyped) + end + def start(requirements); end + + sig do + params( + platform: T.untyped, + ) + .returns(T.untyped) + end + def self.platform_sort_key(platform); end + + sig do + params( + requirements: T.untyped, + index: T.untyped, + source_requirements: T.untyped, + base: T.untyped, + gem_version_promoter: T.untyped, + additional_base_requirements: T.untyped, + platforms: T.untyped, + ) + .returns(T.untyped) + end + def self.resolve(requirements, index, source_requirements=T.unsafe(nil), base=T.unsafe(nil), gem_version_promoter=T.unsafe(nil), additional_base_requirements=T.unsafe(nil), platforms=T.unsafe(nil)); end + + sig do + params( + platforms: T.untyped, + ) + .returns(T.untyped) + end + def self.sort_platforms(platforms); end +end + +class Bundler::Resolver::SpecGroup + include ::Bundler::GemHelpers + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def ==(other); end + + sig do + params( + platform: T.untyped, + ) + .returns(T.untyped) + end + def activate_platform!(platform); end + + sig {returns(T.untyped)} + def dependencies_for_activated_platforms(); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def eql?(other); end + + sig do + params( + platform: T.untyped, + ) + .returns(T.untyped) + end + def for?(platform); end + + sig {returns(T.untyped)} + def hash(); end + + sig {returns(T.untyped)} + def ignores_bundler_dependencies(); end + + sig do + params( + ignores_bundler_dependencies: T.untyped, + ) + .returns(T.untyped) + end + def ignores_bundler_dependencies=(ignores_bundler_dependencies); end + + sig do + params( + all_specs: T.untyped, + ) + .returns(T.untyped) + end + def initialize(all_specs); end + + sig {returns(T.untyped)} + def name(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def name=(name); end + + sig {returns(T.untyped)} + def source(); end + + sig do + params( + source: T.untyped, + ) + .returns(T.untyped) + end + def source=(source); end + + sig {returns(T.untyped)} + def to_s(); end + + sig {returns(T.untyped)} + def to_specs(); end + + sig {returns(T.untyped)} + def version(); end + + sig do + params( + version: T.untyped, + ) + .returns(T.untyped) + end + def version=(version); end +end + +module Bundler::RubyDsl + sig do + params( + ruby_version: T.untyped, + ) + .returns(T.untyped) + end + def ruby(*ruby_version); end +end + +class Bundler::RubyVersion + PATTERN = ::T.let(nil, T.untyped) + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def ==(other); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def diff(other); end + + sig {returns(T.untyped)} + def engine(); end + + sig {returns(T.untyped)} + def engine_gem_version(); end + + sig {returns(T.untyped)} + def engine_versions(); end + + sig {returns(T.untyped)} + def exact?(); end + + sig {returns(T.untyped)} + def gem_version(); end + + sig {returns(T.untyped)} + def host(); end + + sig do + params( + versions: T.untyped, + patchlevel: T.untyped, + engine: T.untyped, + engine_version: T.untyped, + ) + .returns(T.untyped) + end + def initialize(versions, patchlevel, engine, engine_version); end + + sig {returns(T.untyped)} + def patchlevel(); end + + sig {returns(T.untyped)} + def single_version_string(); end + + sig {returns(T.untyped)} + def to_gem_version_with_patchlevel(); end + + sig do + params( + versions: T.untyped, + ) + .returns(T.untyped) + end + def to_s(versions=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def versions(); end + + sig do + params( + versions: T.untyped, + ) + .returns(T.untyped) + end + def versions_string(versions); end + + sig do + params( + string: T.untyped, + ) + .returns(T.untyped) + end + def self.from_string(string); end + + sig {returns(T.untyped)} + def self.system(); end +end + +class Bundler::RubyVersionMismatch < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::RubygemsIntegration + EXT_LOCK = ::T.let(nil, T.untyped) + + sig {returns(T.untyped)} + def backport_base_dir(); end + + sig {returns(T.untyped)} + def backport_cache_file(); end + + sig {returns(T.untyped)} + def backport_segment_generation(); end + + sig {returns(T.untyped)} + def backport_spec_file(); end + + sig {returns(T.untyped)} + def backport_yaml_initialize(); end + + sig do + params( + gem: T.untyped, + bin: T.untyped, + ver: T.untyped, + ) + .returns(T.untyped) + end + def bin_path(gem, bin, ver); end + + sig {returns(T.untyped)} + def binstubs_call_gem?(); end + + sig do + params( + spec: T.untyped, + skip_validation: T.untyped, + ) + .returns(T.untyped) + end + def build(spec, skip_validation=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def build_args(); end + + sig do + params( + args: T.untyped, + ) + .returns(T.untyped) + end + def build_args=(args); end + + sig do + params( + gem_dir: T.untyped, + spec: T.untyped, + ) + .returns(T.untyped) + end + def build_gem(gem_dir, spec); end + + sig {returns(T.untyped)} + def clear_paths(); end + + sig {returns(T.untyped)} + def config_map(); end + + sig {returns(T.untyped)} + def configuration(); end + + sig do + params( + spec: T.untyped, + uri: T.untyped, + path: T.untyped, + ) + .returns(T.untyped) + end + def download_gem(spec, uri, path); end + + sig {returns(T.untyped)} + def ext_lock(); end + + sig do + params( + remote: T.untyped, + ) + .returns(T.untyped) + end + def fetch_all_remote_specs(remote); end + + sig {returns(T.untyped)} + def fetch_prerelease_specs(); end + + sig do + params( + all: T.untyped, + pre: T.untyped, + blk: T.untyped, + ) + .returns(T.untyped) + end + def fetch_specs(all, pre, &blk); end + + sig {returns(T.untyped)} + def gem_bindir(); end + + sig {returns(T.untyped)} + def gem_cache(); end + + sig {returns(T.untyped)} + def gem_dir(); end + + sig do + params( + path: T.untyped, + policy: T.untyped, + ) + .returns(T.untyped) + end + def gem_from_path(path, policy=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def gem_path(); end + + sig do + params( + obj: T.untyped, + ) + .returns(T.untyped) + end + def inflate(obj); end + + sig {returns(T.untyped)} + def initialize(); end + + sig do + params( + args: T.untyped, + ) + .returns(T.untyped) + end + def install_with_build_args(args); end + + sig {returns(T.untyped)} + def load_path_insert_index(); end + + sig do + params( + files: T.untyped, + ) + .returns(T.untyped) + end + def load_plugin_files(files); end + + sig {returns(T.untyped)} + def load_plugins(); end + + sig {returns(T.untyped)} + def loaded_gem_paths(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def loaded_specs(name); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def mark_loaded(spec); end + + sig {returns(T.untyped)} + def marshal_spec_dir(); end + + sig do + params( + klass: T.untyped, + method: T.untyped, + ) + .returns(T.untyped) + end + def method_visibility(klass, method); end + + sig do + params( + obj: T.untyped, + ) + .returns(T.untyped) + end + def path(obj); end + + sig {returns(T.untyped)} + def path_separator(); end + + sig {returns(T.untyped)} + def platforms(); end + + sig {returns(T.untyped)} + def post_reset_hooks(); end + + sig {returns(T.untyped)} + def preserve_paths(); end + + sig do + params( + req_str: T.untyped, + ) + .returns(T.untyped) + end + def provides?(req_str); end + + sig do + params( + path: T.untyped, + ) + .returns(T.untyped) + end + def read_binary(path); end + + sig do + params( + klass: T.untyped, + method: T.untyped, + unbound_method: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def redefine_method(klass, method, unbound_method=T.unsafe(nil), &block); end + + sig do + params( + specs: T.untyped, + specs_by_name: T.untyped, + ) + .returns(T.untyped) + end + def replace_bin_path(specs, specs_by_name); end + + sig do + params( + specs: T.untyped, + ) + .returns(T.untyped) + end + def replace_entrypoints(specs); end + + sig do + params( + specs: T.untyped, + specs_by_name: T.untyped, + ) + .returns(T.untyped) + end + def replace_gem(specs, specs_by_name); end + + sig {returns(T.untyped)} + def replace_refresh(); end + + sig {returns(T.untyped)} + def repository_subdirectories(); end + + sig {returns(T.untyped)} + def reset(); end + + sig {returns(T.untyped)} + def reverse_rubygems_kernel_mixin(); end + + sig {returns(T.untyped)} + def ruby_engine(); end + + sig {returns(T.untyped)} + def security_policies(); end + + sig {returns(T.untyped)} + def security_policy_keys(); end + + sig do + params( + spec: T.untyped, + installed_by_version: T.untyped, + ) + .returns(T.untyped) + end + def set_installed_by_version(spec, installed_by_version=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def sources(); end + + sig do + params( + val: T.untyped, + ) + .returns(T.untyped) + end + def sources=(val); end + + sig {returns(T.untyped)} + def spec_cache_dirs(); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def spec_default_gem?(spec); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def spec_extension_dir(spec); end + + sig do + params( + path: T.untyped, + policy: T.untyped, + ) + .returns(T.untyped) + end + def spec_from_gem(path, policy=T.unsafe(nil)); end + + sig do + params( + spec: T.untyped, + glob: T.untyped, + ) + .returns(T.untyped) + end + def spec_matches_for_glob(spec, glob); end + + sig do + params( + spec: T.untyped, + default: T.untyped, + ) + .returns(T.untyped) + end + def spec_missing_extensions?(spec, default=T.unsafe(nil)); end + + sig do + params( + stub: T.untyped, + spec: T.untyped, + ) + .returns(T.untyped) + end + def stub_set_spec(stub, spec); end + + sig do + params( + specs: T.untyped, + ) + .returns(T.untyped) + end + def stub_source_index(specs); end + + sig {returns(T.untyped)} + def stubs_provide_full_functionality?(); end + + sig {returns(T.untyped)} + def suffix_pattern(); end + + sig do + params( + obj: T.untyped, + ) + .returns(T.untyped) + end + def ui=(obj); end + + sig {returns(T.untyped)} + def undo_replacements(); end + + sig {returns(T.untyped)} + def user_home(); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def validate(spec); end + + sig {returns(T.untyped)} + def version(); end + + sig do + params( + args: T.untyped, + ) + .returns(T.untyped) + end + def with_build_args(args); end + + sig do + params( + req_str: T.untyped, + ) + .returns(T.untyped) + end + def self.provides?(req_str); end + + sig {returns(T.untyped)} + def self.version(); end +end + +class Bundler::RubygemsIntegration::AlmostModern < Bundler::RubygemsIntegration::Modern + sig {returns(T.untyped)} + def preserve_paths(); end +end + +class Bundler::RubygemsIntegration::Ancient < Bundler::RubygemsIntegration::Legacy + sig {returns(T.untyped)} + def initialize(); end +end + +class Bundler::RubygemsIntegration::Future < Bundler::RubygemsIntegration + sig {returns(T.untyped)} + def all_specs(); end + + sig do + params( + spec: T.untyped, + skip_validation: T.untyped, + ) + .returns(T.untyped) + end + def build(spec, skip_validation=T.unsafe(nil)); end + + sig do + params( + spec: T.untyped, + uri: T.untyped, + path: T.untyped, + ) + .returns(T.untyped) + end + def download_gem(spec, uri, path); end + + sig do + params( + remote: T.untyped, + ) + .returns(T.untyped) + end + def fetch_all_remote_specs(remote); end + + sig do + params( + source: T.untyped, + remote: T.untyped, + name: T.untyped, + ) + .returns(T.untyped) + end + def fetch_specs(source, remote, name); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def find_name(name); end + + sig do + params( + path: T.untyped, + policy: T.untyped, + ) + .returns(T.untyped) + end + def gem_from_path(path, policy=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def gem_remote_fetcher(); end + + sig do + params( + args: T.untyped, + ) + .returns(T.untyped) + end + def install_with_build_args(args); end + + sig {returns(T.untyped)} + def path_separator(); end + + sig {returns(T.untyped)} + def repository_subdirectories(); end + + sig do + params( + specs: T.untyped, + ) + .returns(T.untyped) + end + def stub_rubygems(specs); end +end + +class Bundler::RubygemsIntegration::Legacy < Bundler::RubygemsIntegration + sig {returns(T.untyped)} + def all_specs(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def find_name(name); end + + sig {returns(T.untyped)} + def initialize(); end + + sig {returns(T.untyped)} + def post_reset_hooks(); end + + sig {returns(T.untyped)} + def reset(); end + + sig do + params( + specs: T.untyped, + ) + .returns(T.untyped) + end + def stub_rubygems(specs); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def validate(spec); end +end + +class Bundler::RubygemsIntegration::Modern < Bundler::RubygemsIntegration + sig {returns(T.untyped)} + def all_specs(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def find_name(name); end + + sig do + params( + specs: T.untyped, + ) + .returns(T.untyped) + end + def stub_rubygems(specs); end +end + +class Bundler::RubygemsIntegration::MoreFuture < Bundler::RubygemsIntegration::Future + sig {returns(T.untyped)} + def all_specs(); end + + sig {returns(T.untyped)} + def backport_ext_builder_monitor(); end + + sig {returns(T.untyped)} + def binstubs_call_gem?(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def find_name(name); end + + sig {returns(T.untyped)} + def initialize(); end + + sig {returns(T.untyped)} + def stubs_provide_full_functionality?(); end + + sig do + params( + gemfile: T.untyped, + ) + .returns(T.untyped) + end + def use_gemdeps(gemfile); end +end + +class Bundler::RubygemsIntegration::MoreModern < Bundler::RubygemsIntegration::Modern + sig do + params( + spec: T.untyped, + skip_validation: T.untyped, + ) + .returns(T.untyped) + end + def build(spec, skip_validation=T.unsafe(nil)); end +end + +class Bundler::RubygemsIntegration::Transitional < Bundler::RubygemsIntegration::Legacy + sig do + params( + specs: T.untyped, + ) + .returns(T.untyped) + end + def stub_rubygems(specs); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def validate(spec); end +end + +class Bundler::Runtime + include ::Bundler::SharedHelpers + REQUIRE_ERRORS = ::T.let(nil, T.untyped) + + sig do + params( + custom_path: T.untyped, + ) + .returns(T.untyped) + end + def cache(custom_path=T.unsafe(nil)); end + + sig do + params( + dry_run: T.untyped, + ) + .returns(T.untyped) + end + def clean(dry_run=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def current_dependencies(); end + + sig {returns(T.untyped)} + def dependencies(); end + + sig {returns(T.untyped)} + def gems(); end + + sig do + params( + root: T.untyped, + definition: T.untyped, + ) + .returns(T.untyped) + end + def initialize(root, definition); end + + sig do + params( + opts: T.untyped, + ) + .returns(T.untyped) + end + def lock(opts=T.unsafe(nil)); end + + sig do + params( + cache_path: T.untyped, + ) + .returns(T.untyped) + end + def prune_cache(cache_path); end + + sig {returns(T.untyped)} + def requested_specs(); end + + sig do + params( + groups: T.untyped, + ) + .returns(T.untyped) + end + def require(*groups); end + + sig {returns(T.untyped)} + def requires(); end + + sig do + params( + groups: T.untyped, + ) + .returns(T.untyped) + end + def setup(*groups); end + + sig {returns(T.untyped)} + def specs(); end +end + +class Bundler::SecurityError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::Settings + ARRAY_KEYS = ::T.let(nil, T.untyped) + BOOL_KEYS = ::T.let(nil, T.untyped) + CONFIG_REGEX = ::T.let(nil, T.untyped) + DEFAULT_CONFIG = ::T.let(nil, T.untyped) + NORMALIZE_URI_OPTIONS_PATTERN = ::T.let(nil, T.untyped) + NUMBER_KEYS = ::T.let(nil, T.untyped) + PER_URI_OPTIONS = ::T.let(nil, T.untyped) + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def [](name); end + + sig {returns(T.untyped)} + def all(); end + + sig {returns(T.untyped)} + def allow_sudo?(); end + + sig {returns(T.untyped)} + def app_cache_path(); end + + sig do + params( + uri: T.untyped, + ) + .returns(T.untyped) + end + def credentials_for(uri); end + + sig {returns(T.untyped)} + def gem_mirrors(); end + + sig {returns(T.untyped)} + def ignore_config?(); end + + sig do + params( + root: T.untyped, + ) + .returns(T.untyped) + end + def initialize(root=T.unsafe(nil)); end + + sig do + params( + key: T.untyped, + ) + .returns(T.untyped) + end + def key_for(key); end + + sig {returns(T.untyped)} + def local_overrides(); end + + sig do + params( + key: T.untyped, + ) + .returns(T.untyped) + end + def locations(key); end + + sig do + params( + uri: T.untyped, + ) + .returns(T.untyped) + end + def mirror_for(uri); end + + sig {returns(T.untyped)} + def path(); end + + sig do + params( + exposed_key: T.untyped, + ) + .returns(T.untyped) + end + def pretty_values_for(exposed_key); end + + sig do + params( + key: T.untyped, + value: T.untyped, + ) + .returns(T.untyped) + end + def set_command_option(key, value); end + + sig do + params( + key: T.untyped, + value: T.untyped, + ) + .returns(T.untyped) + end + def set_command_option_if_given(key, value); end + + sig do + params( + key: T.untyped, + value: T.untyped, + ) + .returns(T.untyped) + end + def set_global(key, value); end + + sig do + params( + key: T.untyped, + value: T.untyped, + ) + .returns(T.untyped) + end + def set_local(key, value); end + + sig do + params( + update: T.untyped, + ) + .returns(T.untyped) + end + def temporary(update); end + + sig {returns(T.untyped)} + def validate!(); end + + sig do + params( + uri: T.untyped, + ) + .returns(T.untyped) + end + def self.normalize_uri(uri); end +end + +class Bundler::Settings::Path < Struct + extend T::Generic + Elem = type_member(fixed: T.untyped) + + sig {returns(T.untyped)} + def append_ruby_scope(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def append_ruby_scope=(_); end + + sig {returns(T.untyped)} + def base_path(); end + + sig {returns(T.untyped)} + def base_path_relative_to_pwd(); end + + sig {returns(T.untyped)} + def default_install_uses_path(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def default_install_uses_path=(_); end + + sig {returns(T.untyped)} + def explicit_path(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def explicit_path=(_); end + + sig {returns(T.untyped)} + def path(); end + + sig {returns(T.untyped)} + def system_path(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def system_path=(_); end + + sig {returns(T.untyped)} + def use_system_gems?(); end + + sig {returns(T.untyped)} + def validate!(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.[](*_); end + + sig {returns(T.untyped)} + def self.members(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def self.new(*_); end +end + +module Bundler::SharedHelpers + extend ::Bundler::SharedHelpers + sig do + params( + dir: T.untyped, + blk: T.untyped, + ) + .returns(T.untyped) + end + def chdir(dir, &blk); end + + sig do + params( + constant_name: T.untyped, + namespace: T.untyped, + ) + .returns(T.untyped) + end + def const_get_safely(constant_name, namespace); end + + sig {returns(T.untyped)} + def default_bundle_dir(); end + + sig {returns(T.untyped)} + def default_gemfile(); end + + sig {returns(T.untyped)} + def default_lockfile(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def digest(name); end + + sig do + params( + spec: T.untyped, + old_deps: T.untyped, + new_deps: T.untyped, + ) + .returns(T.untyped) + end + def ensure_same_dependencies(spec, old_deps, new_deps); end + + sig do + params( + path: T.untyped, + action: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def filesystem_access(path, action=T.unsafe(nil), &block); end + + sig {returns(T.untyped)} + def in_bundle?(); end + + sig do + params( + major_version: T.untyped, + message: T.untyped, + ) + .returns(T.untyped) + end + def major_deprecation(major_version, message); end + + sig {returns(T.untyped)} + def md5_available?(); end + + sig do + params( + dep: T.untyped, + print_source: T.untyped, + ) + .returns(T.untyped) + end + def pretty_dependency(dep, print_source=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def print_major_deprecations!(); end + + sig {returns(T.untyped)} + def pwd(); end + + sig {returns(T.untyped)} + def root(); end + + sig {returns(T.untyped)} + def set_bundle_environment(); end + + sig do + params( + key: T.untyped, + value: T.untyped, + ) + .returns(T.untyped) + end + def set_env(key, value); end + + sig do + params( + signal: T.untyped, + override: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def trap(signal, override=T.unsafe(nil), &block); end + + sig do + params( + block: T.untyped, + ) + .returns(T.untyped) + end + def with_clean_git_env(&block); end + + sig do + params( + gemfile_path: T.untyped, + contents: T.untyped, + ) + .returns(T.untyped) + end + def write_to_gemfile(gemfile_path, contents); end +end + +class Bundler::Source + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def can_lock?(spec); end + + sig {returns(T.untyped)} + def dependency_names(); end + + sig do + params( + dependency_names: T.untyped, + ) + .returns(T.untyped) + end + def dependency_names=(dependency_names); end + + sig {returns(T.untyped)} + def dependency_names_to_double_check(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def double_check_for(*_); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def extension_cache_path(spec); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def include?(other); end + + sig {returns(T.untyped)} + def inspect(); end + + sig {returns(T.untyped)} + def path?(); end + + sig {returns(T.untyped)} + def unmet_deps(); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def version_message(spec); end +end + +class Bundler::Source::Gemspec < Bundler::Source::Path + sig {returns(T.untyped)} + def as_path_source(); end + + sig {returns(T.untyped)} + def gemspec(); end + + sig do + params( + options: T.untyped, + ) + .returns(T.untyped) + end + def initialize(options); end +end + +class Bundler::Source::Git < Bundler::Source::Path + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def ==(other); end + + sig {returns(T.untyped)} + def allow_git_ops?(); end + + sig {returns(T.untyped)} + def app_cache_dirname(); end + + sig {returns(T.untyped)} + def branch(); end + + sig do + params( + spec: T.untyped, + custom_path: T.untyped, + ) + .returns(T.untyped) + end + def cache(spec, custom_path=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def cache_path(); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def eql?(other); end + + sig {returns(T.untyped)} + def extension_dir_name(); end + + sig {returns(T.untyped)} + def hash(); end + + sig do + params( + options: T.untyped, + ) + .returns(T.untyped) + end + def initialize(options); end + + sig do + params( + spec: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def install(spec, options=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def install_path(); end + + sig {returns(T.untyped)} + def load_spec_files(); end + + sig do + params( + path: T.untyped, + ) + .returns(T.untyped) + end + def local_override!(path); end + + sig {returns(T.untyped)} + def name(); end + + sig {returns(T.untyped)} + def options(); end + + sig {returns(T.untyped)} + def path(); end + + sig {returns(T.untyped)} + def ref(); end + + sig {returns(T.untyped)} + def revision(); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def specs(*_); end + + sig {returns(T.untyped)} + def submodules(); end + + sig {returns(T.untyped)} + def to_lock(); end + + sig {returns(T.untyped)} + def to_s(); end + + sig {returns(T.untyped)} + def unlock!(); end + + sig {returns(T.untyped)} + def uri(); end + + sig do + params( + options: T.untyped, + ) + .returns(T.untyped) + end + def self.from_lock(options); end +end + +class Bundler::Source::Git::GitCommandError < Bundler::GitError + sig do + params( + command: T.untyped, + path: T.untyped, + extra_info: T.untyped, + ) + .returns(T.untyped) + end + def initialize(command, path=T.unsafe(nil), extra_info=T.unsafe(nil)); end +end + +class Bundler::Source::Git::GitNotAllowedError < Bundler::GitError + sig do + params( + command: T.untyped, + ) + .returns(T.untyped) + end + def initialize(command); end +end + +class Bundler::Source::Git::GitNotInstalledError < Bundler::GitError + sig {returns(T.untyped)} + def initialize(); end +end + +class Bundler::Source::Git::GitProxy + sig {returns(T.untyped)} + def branch(); end + + sig {returns(T.untyped)} + def checkout(); end + + sig do + params( + commit: T.untyped, + ) + .returns(T.untyped) + end + def contains?(commit); end + + sig do + params( + destination: T.untyped, + submodules: T.untyped, + ) + .returns(T.untyped) + end + def copy_to(destination, submodules=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def full_version(); end + + sig do + params( + path: T.untyped, + uri: T.untyped, + ref: T.untyped, + revision: T.untyped, + git: T.untyped, + ) + .returns(T.untyped) + end + def initialize(path, uri, ref, revision=T.unsafe(nil), git=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def path(); end + + sig do + params( + path: T.untyped, + ) + .returns(T.untyped) + end + def path=(path); end + + sig {returns(T.untyped)} + def ref(); end + + sig do + params( + ref: T.untyped, + ) + .returns(T.untyped) + end + def ref=(ref); end + + sig {returns(T.untyped)} + def revision(); end + + sig do + params( + revision: T.untyped, + ) + .returns(T.untyped) + end + def revision=(revision); end + + sig {returns(T.untyped)} + def uri(); end + + sig do + params( + uri: T.untyped, + ) + .returns(T.untyped) + end + def uri=(uri); end + + sig {returns(T.untyped)} + def version(); end +end + +class Bundler::Source::Git::MissingGitRevisionError < Bundler::GitError + sig do + params( + ref: T.untyped, + repo: T.untyped, + ) + .returns(T.untyped) + end + def initialize(ref, repo); end +end + +class Bundler::Source::Metadata < Bundler::Source + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def ==(other); end + + sig {returns(T.untyped)} + def cached!(); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def eql?(other); end + + sig {returns(T.untyped)} + def hash(); end + + sig do + params( + spec: T.untyped, + _opts: T.untyped, + ) + .returns(T.untyped) + end + def install(spec, _opts=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def options(); end + + sig {returns(T.untyped)} + def remote!(); end + + sig {returns(T.untyped)} + def specs(); end + + sig {returns(T.untyped)} + def to_s(); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def version_message(spec); end +end + +class Bundler::Source::Path < Bundler::Source + DEFAULT_GLOB = ::T.let(nil, T.untyped) + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def ==(other); end + + sig {returns(T.untyped)} + def app_cache_dirname(); end + + sig do + params( + spec: T.untyped, + custom_path: T.untyped, + ) + .returns(T.untyped) + end + def cache(spec, custom_path=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def cached!(); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def eql?(other); end + + sig {returns(T.untyped)} + def expanded_original_path(); end + + sig {returns(T.untyped)} + def hash(); end + + sig do + params( + options: T.untyped, + ) + .returns(T.untyped) + end + def initialize(options); end + + sig do + params( + spec: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def install(spec, options=T.unsafe(nil)); end + + sig do + params( + _: T.untyped, + ) + .returns(T.untyped) + end + def local_specs(*_); end + + sig {returns(T.untyped)} + def name(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def name=(name); end + + sig {returns(T.untyped)} + def options(); end + + sig {returns(T.untyped)} + def original_path(); end + + sig {returns(T.untyped)} + def path(); end + + sig {returns(T.untyped)} + def remote!(); end + + sig {returns(T.untyped)} + def root(); end + + sig {returns(T.untyped)} + def root_path(); end + + sig {returns(T.untyped)} + def specs(); end + + sig {returns(T.untyped)} + def to_lock(); end + + sig {returns(T.untyped)} + def to_s(); end + + sig {returns(T.untyped)} + def version(); end + + sig do + params( + version: T.untyped, + ) + .returns(T.untyped) + end + def version=(version); end + + sig do + params( + options: T.untyped, + ) + .returns(T.untyped) + end + def self.from_lock(options); end +end + +class Bundler::Source::Rubygems < Bundler::Source + API_REQUEST_LIMIT = ::T.let(nil, T.untyped) + API_REQUEST_SIZE = ::T.let(nil, T.untyped) + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def ==(other); end + + sig do + params( + source: T.untyped, + ) + .returns(T.untyped) + end + def add_remote(source); end + + sig {returns(T.untyped)} + def api_fetchers(); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def builtin_gem?(spec); end + + sig do + params( + spec: T.untyped, + custom_path: T.untyped, + ) + .returns(T.untyped) + end + def cache(spec, custom_path=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def cache_path(); end + + sig {returns(T.untyped)} + def cached!(); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def cached_built_in_gem(spec); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def cached_gem(spec); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def cached_path(spec); end + + sig {returns(T.untyped)} + def cached_specs(); end + + sig {returns(T.untyped)} + def caches(); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def can_lock?(spec); end + + sig {returns(T.untyped)} + def credless_remotes(); end + + sig {returns(T.untyped)} + def dependency_names_to_double_check(); end + + sig do + params( + unmet_dependency_names: T.untyped, + ) + .returns(T.untyped) + end + def double_check_for(unmet_dependency_names); end + + sig do + params( + other: T.untyped, + ) + .returns(T.untyped) + end + def eql?(other); end + + sig do + params( + other_remotes: T.untyped, + ) + .returns(T.untyped) + end + def equivalent_remotes?(other_remotes); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def fetch_gem(spec); end + + sig do + params( + fetchers: T.untyped, + dependency_names: T.untyped, + index: T.untyped, + override_dupes: T.untyped, + ) + .returns(T.untyped) + end + def fetch_names(fetchers, dependency_names, index, override_dupes); end + + sig {returns(T.untyped)} + def fetchers(); end + + sig {returns(T.untyped)} + def hash(); end + + sig do + params( + o: T.untyped, + ) + .returns(T.untyped) + end + def include?(o); end + + sig do + params( + options: T.untyped, + ) + .returns(T.untyped) + end + def initialize(options=T.unsafe(nil)); end + + sig do + params( + spec: T.untyped, + opts: T.untyped, + ) + .returns(T.untyped) + end + def install(spec, opts=T.unsafe(nil)); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def installed?(spec); end + + sig {returns(T.untyped)} + def installed_specs(); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def loaded_from(spec); end + + sig {returns(T.untyped)} + def name(); end + + sig do + params( + uri: T.untyped, + ) + .returns(T.untyped) + end + def normalize_uri(uri); end + + sig {returns(T.untyped)} + def options(); end + + sig {returns(T.untyped)} + def remote!(); end + + sig {returns(T.untyped)} + def remote_specs(); end + + sig {returns(T.untyped)} + def remotes(); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def remotes_for_spec(spec); end + + sig do + params( + remote: T.untyped, + ) + .returns(T.untyped) + end + def remove_auth(remote); end + + sig do + params( + other_remotes: T.untyped, + allow_equivalent: T.untyped, + ) + .returns(T.untyped) + end + def replace_remotes(other_remotes, allow_equivalent=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def requires_sudo?(); end + + sig {returns(T.untyped)} + def rubygems_dir(); end + + sig {returns(T.untyped)} + def specs(); end + + sig do + params( + remote: T.untyped, + ) + .returns(T.untyped) + end + def suppress_configured_credentials(remote); end + + sig {returns(T.untyped)} + def to_lock(); end + + sig {returns(T.untyped)} + def to_s(); end + + sig {returns(T.untyped)} + def unmet_deps(); end + + sig do + params( + options: T.untyped, + ) + .returns(T.untyped) + end + def self.from_lock(options); end +end + +class Bundler::SourceList + sig do + params( + options: T.untyped, + ) + .returns(T.untyped) + end + def add_git_source(options=T.unsafe(nil)); end + + sig do + params( + options: T.untyped, + ) + .returns(T.untyped) + end + def add_path_source(options=T.unsafe(nil)); end + + sig do + params( + source: T.untyped, + options: T.untyped, + ) + .returns(T.untyped) + end + def add_plugin_source(source, options=T.unsafe(nil)); end + + sig do + params( + uri: T.untyped, + ) + .returns(T.untyped) + end + def add_rubygems_remote(uri); end + + sig do + params( + options: T.untyped, + ) + .returns(T.untyped) + end + def add_rubygems_source(options=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def all_sources(); end + + sig {returns(T.untyped)} + def cached!(); end + + sig {returns(T.untyped)} + def default_source(); end + + sig do + params( + source: T.untyped, + ) + .returns(T.untyped) + end + def get(source); end + + sig {returns(T.untyped)} + def git_sources(); end + + sig {returns(T.untyped)} + def global_rubygems_source(); end + + sig do + params( + uri: T.untyped, + ) + .returns(T.untyped) + end + def global_rubygems_source=(uri); end + + sig {returns(T.untyped)} + def initialize(); end + + sig {returns(T.untyped)} + def lock_sources(); end + + sig {returns(T.untyped)} + def metadata_source(); end + + sig {returns(T.untyped)} + def path_sources(); end + + sig {returns(T.untyped)} + def plugin_sources(); end + + sig {returns(T.untyped)} + def remote!(); end + + sig do + params( + replacement_sources: T.untyped, + ) + .returns(T.untyped) + end + def replace_sources!(replacement_sources); end + + sig {returns(T.untyped)} + def rubygems_primary_remotes(); end + + sig {returns(T.untyped)} + def rubygems_remotes(); end + + sig {returns(T.untyped)} + def rubygems_sources(); end +end + +class Bundler::SpecSet + include ::TSort + include T::Enumerable + extend ::Forwardable + + sig do + params( + args: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def <<(*args, &block); end + + sig do + params( + key: T.untyped, + ) + .returns(T.untyped) + end + def [](key); end + + sig do + params( + key: T.untyped, + value: T.untyped, + ) + .returns(T.untyped) + end + def []=(key, value); end + + sig do + params( + args: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def add(*args, &block); end + + sig do + params( + args: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def each(*args, &block); end + + sig do + params( + args: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def empty?(*args, &block); end + + sig do + params( + name: T.untyped, + platform: T.untyped, + ) + .returns(T.untyped) + end + def find_by_name_and_platform(name, platform); end + + sig do + params( + dependencies: T.untyped, + skip: T.untyped, + check: T.untyped, + match_current_platform: T.untyped, + raise_on_missing: T.untyped, + ) + .returns(T.untyped) + end + def for(dependencies, skip=T.unsafe(nil), check=T.unsafe(nil), match_current_platform=T.unsafe(nil), raise_on_missing=T.unsafe(nil)); end + + sig do + params( + specs: T.untyped, + ) + .returns(T.untyped) + end + def initialize(specs); end + + sig do + params( + args: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def length(*args, &block); end + + sig do + params( + deps: T.untyped, + missing_specs: T.untyped, + ) + .returns(T.untyped) + end + def materialize(deps, missing_specs=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def materialized_for_all_platforms(); end + + sig do + params( + set: T.untyped, + ) + .returns(T.untyped) + end + def merge(set); end + + sig do + params( + args: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def remove(*args, &block); end + + sig do + params( + args: T.untyped, + block: T.untyped, + ) + .returns(T.untyped) + end + def size(*args, &block); end + + sig {returns(T.untyped)} + def sort!(); end + + sig {returns(T.untyped)} + def to_a(); end + + sig {returns(T.untyped)} + def to_hash(); end + + sig do + params( + deps: T.untyped, + ) + .returns(T.untyped) + end + def valid_for?(deps); end + + sig do + params( + spec: T.untyped, + ) + .returns(T.untyped) + end + def what_required(spec); end +end + +class Bundler::StubSpecification < Bundler::RemoteSpecification + sig {returns(T.untyped)} + def activated(); end + + sig do + params( + activated: T.untyped, + ) + .returns(T.untyped) + end + def activated=(activated); end + + sig {returns(T.untyped)} + def default_gem(); end + + sig {returns(T.untyped)} + def full_gem_path(); end + + sig {returns(T.untyped)} + def full_require_paths(); end + + sig {returns(T.untyped)} + def ignored(); end + + sig do + params( + ignored: T.untyped, + ) + .returns(T.untyped) + end + def ignored=(ignored); end + + sig {returns(T.untyped)} + def load_paths(); end + + sig {returns(T.untyped)} + def loaded_from(); end + + sig do + params( + glob: T.untyped, + ) + .returns(T.untyped) + end + def matches_for_glob(glob); end + + sig {returns(T.untyped)} + def missing_extensions?(); end + + sig {returns(T.untyped)} + def raw_require_paths(); end + + sig do + params( + source: T.untyped, + ) + .returns(T.untyped) + end + def source=(source); end + + sig {returns(T.untyped)} + def stub(); end + + sig do + params( + stub: T.untyped, + ) + .returns(T.untyped) + end + def stub=(stub); end + + sig {returns(T.untyped)} + def to_yaml(); end + + sig do + params( + stub: T.untyped, + ) + .returns(T.untyped) + end + def self.from_stub(stub); end +end + +class Bundler::SudoNotPermittedError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::TemporaryResourceError < Bundler::PermissionError + sig {returns(T.untyped)} + def message(); end + + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::ThreadCreationError < Bundler::BundlerError + sig {returns(T.untyped)} + def status_code(); end +end + +module Bundler::UI +end + +class Bundler::UI::RGProxy < Gem::SilentUI + sig do + params( + ui: T.untyped, + ) + .returns(T.untyped) + end + def initialize(ui); end + + sig do + params( + message: T.untyped, + ) + .returns(T.untyped) + end + def say(message); end +end + +class Bundler::UI::Silent + sig do + params( + string: T.untyped, + color: T.untyped, + ) + .returns(T.untyped) + end + def add_color(string, color); end + + sig do + params( + message: T.untyped, + ) + .returns(T.untyped) + end + def ask(message); end + + sig do + params( + message: T.untyped, + newline: T.untyped, + ) + .returns(T.untyped) + end + def confirm(message, newline=T.unsafe(nil)); end + + sig do + params( + message: T.untyped, + newline: T.untyped, + ) + .returns(T.untyped) + end + def debug(message, newline=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def debug?(); end + + sig do + params( + message: T.untyped, + newline: T.untyped, + ) + .returns(T.untyped) + end + def error(message, newline=T.unsafe(nil)); end + + sig do + params( + message: T.untyped, + newline: T.untyped, + ) + .returns(T.untyped) + end + def info(message, newline=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def initialize(); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def level(name=T.unsafe(nil)); end + + sig do + params( + name: T.untyped, + ) + .returns(T.untyped) + end + def level=(name); end + + sig {returns(T.untyped)} + def no?(); end + + sig {returns(T.untyped)} + def quiet?(); end + + sig do + params( + shell: T.untyped, + ) + .returns(T.untyped) + end + def shell=(shell); end + + sig {returns(T.untyped)} + def silence(); end + + sig do + params( + message: T.untyped, + newline: T.untyped, + force: T.untyped, + ) + .returns(T.untyped) + end + def trace(message, newline=T.unsafe(nil), force=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def unprinted_warnings(); end + + sig do + params( + message: T.untyped, + newline: T.untyped, + ) + .returns(T.untyped) + end + def warn(message, newline=T.unsafe(nil)); end + + sig do + params( + msg: T.untyped, + ) + .returns(T.untyped) + end + def yes?(msg); end +end + +module Bundler::URICredentialsFilter + sig do + params( + str_to_filter: T.untyped, + uri: T.untyped, + ) + .returns(T.untyped) + end + def self.credential_filtered_string(str_to_filter, uri); end + + sig do + params( + uri_to_anonymize: T.untyped, + ) + .returns(T.untyped) + end + def self.credential_filtered_uri(uri_to_anonymize); end +end + +class Bundler::VersionConflict < Bundler::BundlerError + sig {returns(T.untyped)} + def conflicts(); end + + sig do + params( + conflicts: T.untyped, + msg: T.untyped, + ) + .returns(T.untyped) + end + def initialize(conflicts, msg=T.unsafe(nil)); end + + sig {returns(T.untyped)} + def status_code(); end +end + +class Bundler::VirtualProtocolError < Bundler::BundlerError + sig {returns(T.untyped)} + def message(); end + + sig {returns(T.untyped)} + def status_code(); end +end + +module Bundler::YAMLSerializer + ARRAY_REGEX = ::T.let(nil, T.untyped) + HASH_REGEX = ::T.let(nil, T.untyped) + + sig do + params( + hash: T.untyped, + ) + .returns(T.untyped) + end + def self.dump(hash); end + + sig do + params( + str: T.untyped, + ) + .returns(T.untyped) + end + def self.load(str); end +end + +class Bundler::YamlSyntaxError < Bundler::BundlerError + sig do + params( + orig_exception: T.untyped, + msg: T.untyped, + ) + .returns(T.untyped) + end + def initialize(orig_exception, msg); end + + sig {returns(T.untyped)} + def orig_exception(); end + + sig {returns(T.untyped)} + def status_code(); end +end diff --git a/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi b/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi new file mode 100644 index 0000000..a486719 --- /dev/null +++ b/sorbet/rbi/sorbet-typed/lib/rainbow/all/rainbow.rbi @@ -0,0 +1,276 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi sorbet-typed +# +# If you would like to make changes to this file, great! Please upstream any changes you make here: +# +# https://github.com/sorbet/sorbet-typed/edit/master/lib/rainbow/all/rainbow.rbi +# +# typed: strong + +module Rainbow + sig { returns(T::Boolean) } + attr_accessor :enabled + + class Color + sig { returns(Symbol) } + attr_reader :ground + + sig do + params( + ground: Symbol, + values: T.any([Integer], [Integer, Integer, Integer]) + ).returns(Color) + end + def self.build(ground, values); end + + sig { params(hex: String).returns([Integer, Integer, Integer]) } + def self.parse_hex_color(hex); end + + class Indexed < Color + sig { returns(Integer) } + attr_reader :num + + sig { params(ground: Symbol, num: Integer).returns(Indexed) } + def initialize(ground, num); end + + sig { returns(T::Array[Integer]) } + def codes; end + end + + class Named < Indexed + NAMES = T.let(nil, T::Hash[Symbol, Integer]) + + sig { returns(T::Array[Symbol]) } + def self.color_names; end + + sig { returns(String) } + def self.valid_names; end + + sig { params(ground: Symbol, name: Symbol).returns(Named) } + def initialize(ground, name); end + end + + class RGB < Indexed + sig { returns(Integer) } + attr_accessor :r, :g, :b + + sig { params(value: Numeric).returns(Integer) } + def to_ansi_domain(value); end + + sig { params(ground: Symbol, values: Integer).returns(RGB) } + def initialize(ground, *values); end + + sig { returns(T::Array[Integer]) } + def codes; end + end + + class X11Named < RGB + include X11ColorNames + + sig { returns(T::Array[Symbol]) } + def self.color_names; end + + sig { returns(String) } + def self.valid_names; end + + sig { params(ground: Symbol, name: Symbol).returns(X11Named) } + def initialize(ground, name); end + end + end + + sig { returns(Wrapper) } + def self.global; end + + sig { returns(T::Boolean) } + def self.enabled; end + + sig { params(value: T::Boolean).returns(T::Boolean) } + def self.enabled=(value); end + + sig { params(string: String).returns(String) } + def self.uncolor(string); end + + class NullPresenter < String + sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) } + def color(*values); end + + sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) } + def foreground(*values); end + + sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) } + def fg(*values); end + + sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) } + def background(*values); end + + sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(NullPresenter) } + def bg(*values); end + + sig { returns(NullPresenter) } + def reset; end + + sig { returns(NullPresenter) } + def bright; end + + sig { returns(NullPresenter) } + def faint; end + + sig { returns(NullPresenter) } + def italic; end + + sig { returns(NullPresenter) } + def underline; end + + sig { returns(NullPresenter) } + def blink; end + + sig { returns(NullPresenter) } + def inverse; end + + sig { returns(NullPresenter) } + def hide; end + + sig { returns(NullPresenter) } + def cross_out; end + + sig { returns(NullPresenter) } + def black; end + + sig { returns(NullPresenter) } + def red; end + + sig { returns(NullPresenter) } + def green; end + + sig { returns(NullPresenter) } + def yellow; end + + sig { returns(NullPresenter) } + def blue; end + + sig { returns(NullPresenter) } + def magenta; end + + sig { returns(NullPresenter) } + def cyan; end + + sig { returns(NullPresenter) } + def white; end + + sig { returns(NullPresenter) } + def bold; end + + sig { returns(NullPresenter) } + def dark; end + + sig { returns(NullPresenter) } + def strike; end + end + + class Presenter < String + TERM_EFFECTS = T.let(nil, T::Hash[Symbol, Integer]) + + sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) } + def color(*values); end + + sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) } + def foreground(*values); end + + sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) } + def fg(*values); end + + sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) } + def background(*values); end + + sig { params(values: T.any([Integer], [Integer, Integer, Integer])).returns(Presenter) } + def bg(*values); end + + sig { returns(Presenter) } + def reset; end + + sig { returns(Presenter) } + def bright; end + + sig { returns(Presenter) } + def faint; end + + sig { returns(Presenter) } + def italic; end + + sig { returns(Presenter) } + def underline; end + + sig { returns(Presenter) } + def blink; end + + sig { returns(Presenter) } + def inverse; end + + sig { returns(Presenter) } + def hide; end + + sig { returns(Presenter) } + def cross_out; end + + sig { returns(Presenter) } + def black; end + + sig { returns(Presenter) } + def red; end + + sig { returns(Presenter) } + def green; end + + sig { returns(Presenter) } + def yellow; end + + sig { returns(Presenter) } + def blue; end + + sig { returns(Presenter) } + def magenta; end + + sig { returns(Presenter) } + def cyan; end + + sig { returns(Presenter) } + def white; end + + sig { returns(Presenter) } + def bold; end + + sig { returns(Presenter) } + def dark; end + + sig { returns(Presenter) } + def strike; end + end + + class StringUtils + sig { params(string: String, codes: T::Array[Integer]).returns(String) } + def self.wrap_with_sgr(string, codes); end + + sig { params(string: String).returns(String) } + def uncolor(string); end + end + + VERSION = T.let(nil, String) + + class Wrapper + sig { returns(T::Boolean) } + attr_accessor :enabled + + sig { params(enabled: T::Boolean).returns(Wrapper) } + def initialize(enabled = true); end + + sig { params(string: String).returns(T.any(Rainbow::Presenter, Rainbow::NullPresenter)) } + def wrap(string); end + end + + module X11ColorNames + NAMES = T.let(nil, T::Hash[Symbol, [Integer, Integer, Integer]]) + end +end + +sig { params(string: String).returns(Rainbow::Presenter) } +def Rainbow(string); end diff --git a/sorbet/rbi/sorbet-typed/lib/ruby/all/gem.rbi b/sorbet/rbi/sorbet-typed/lib/ruby/all/gem.rbi new file mode 100644 index 0000000..2f8d981 --- /dev/null +++ b/sorbet/rbi/sorbet-typed/lib/ruby/all/gem.rbi @@ -0,0 +1,4222 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi sorbet-typed +# +# If you would like to make changes to this file, great! Please upstream any changes you make here: +# +# https://github.com/sorbet/sorbet-typed/edit/master/lib/ruby/all/gem.rbi +# +# typed: strong +module Gem + ConfigMap = T.let(nil, T.untyped) + RbConfigPriorities = T.let(nil, T.untyped) + RubyGemsPackageVersion = T.let(nil, T.untyped) + RubyGemsVersion = T.let(nil, T.untyped) + USE_BUNDLER_FOR_GEMDEPS = T.let(nil, T.untyped) + + def self._deprecated_detect_gemdeps(path = T.unsafe(nil)); end + + def self._deprecated_gunzip(data); end + + def self._deprecated_gzip(data); end + + def self._deprecated_inflate(data); end + + def self.activate_bin_path(name, *args); end + + def self.default_ext_dir_for(base_dir); end + + def self.default_gems_use_full_paths?; end + + def self.default_spec_cache_dir; end + + def self.deflate(data); end + + def self.detect_gemdeps(*args, &block); end + + def self.dir; end + + def self.done_installing(&hook); end + + def self.done_installing_hooks; end + + def self.ensure_default_gem_subdirectories(dir = Gem.dir, mode = nil); end + + def self.ensure_gem_subdirectories(dir = Gem.dir, mode = nil); end + + def self.ensure_subdirectories(dir, mode, subdirs); end + + def self.env_requirement(gem_name); end + + def self.extension_api_version; end + + def self.find_files(glob, check_load_path = true); end + + def self.find_files_from_load_path(glob); end + + def self.find_latest_files(glob, check_load_path = T.unsafe(nil)); end + + def self.find_unresolved_default_spec(path); end + + def self.finish_resolve(*_); end + + def self.gemdeps; end + + def self.gunzip(*args, &block); end + + def self.gzip(*args, &block); end + + def self.host; end + + def self.host=(host); end + + def self.inflate(*args, &block); end + + def self.install(name, version = T.unsafe(nil), *options); end + + def self.install_extension_in_lib; end + + def self.latest_rubygems_version; end + + def self.latest_spec_for(name); end + + def self.latest_version_for(name); end + + def self.load_env_plugins; end + + def self.load_path_insert_index; end + + def self.load_plugin_files(plugins); end + + def self.load_plugins; end + + def self.load_yaml; end + + def self.loaded_specs; end + + def self.location_of_caller(depth = T.unsafe(nil)); end + + def self.marshal_version; end + + def self.needs; end + + def self.operating_system_defaults; end + + def self.path; end + + def self.path_separator; end + + def self.paths; end + + def self.paths=(env); end + + def self.platform_defaults; end + + def self.platforms; end + + def self.platforms=(platforms); end + + def self.post_build(&hook); end + + def self.post_build_hooks; end + + def self.post_install(&hook); end + + def self.post_install_hooks; end + + def self.post_reset(&hook); end + + def self.post_reset_hooks; end + + def self.post_uninstall(&hook); end + + def self.post_uninstall_hooks; end + + def self.pre_install(&hook); end + + def self.pre_install_hooks; end + + def self.pre_reset(&hook); end + + def self.pre_reset_hooks; end + + def self.pre_uninstall(&hook); end + + def self.pre_uninstall_hooks; end + + def self.prefix; end + + def self.read_binary(path); end + + def self.refresh; end + + def self.register_default_spec(spec); end + + def self.remove_unresolved_default_spec(spec); end + + def self.ruby; end + + def self.ruby_api_version; end + + def self.ruby_engine; end + + def self.ruby_version; end + + def self.rubygems_version; end + + def self.sources; end + + def self.sources=(new_sources); end + + def self.spec_cache_dir; end + + def self.suffix_pattern; end + + def self.suffixes; end + + def self.time(msg, width = T.unsafe(nil), display = T.unsafe(nil)); end + + def self.try_activate(path); end + + def self.ui; end + + def self.use_gemdeps(path = T.unsafe(nil)); end + + def self.use_paths(home, *paths); end + + def self.user_dir; end + + def self.user_home; end + + def self.vendor_dir; end + + def self.win_platform?; end + + def self.write_binary(path, data); end + + class AvailableSet + include Enumerable + Elem = type_member(fixed: T.untyped) + + def <<(o); end + + def add(spec, source); end + + def all_specs; end + + def each(&blk); end + + def each_spec; end + + def empty?; end + + def find_all(req); end + + def inject_into_list(dep_list); end + + def match_platform!; end + + def pick_best!; end + + def prefetch(reqs); end + + def remote; end + + def remote=(remote); end + + def remove_installed!(dep); end + + def set; end + + def size; end + + def sorted; end + + def source_for(spec); end + + def to_request_set(development = T.unsafe(nil)); end + + class Tuple + def source; end + + def source=(_); end + + def spec; end + + def spec=(_); end + + def self.[](*_); end + + def self.members; end + end + end + + class BasicSpecification + def activated?; end + + def base_dir; end + + def base_dir=(base_dir); end + + def contains_requirable_file?(file); end + + def datadir; end + + def default_gem?; end + + def extension_dir; end + + def extension_dir=(extension_dir); end + + def extensions_dir; end + + def full_gem_path; end + + def full_gem_path=(full_gem_path); end + + def full_name; end + + def full_require_paths; end + + def gem_build_complete_path; end + + def gem_dir; end + + def gems_dir; end + + def ignored=(ignored); end + + def internal_init; end + + def lib_dirs_glob; end + + def loaded_from; end + + def loaded_from=(loaded_from); end + + def matches_for_glob(glob); end + + def name; end + + def platform; end + + def raw_require_paths; end + + def require_paths; end + + def source_paths; end + + def stubbed?; end + + def this; end + + def to_fullpath(path); end + + def to_spec; end + + def version; end + + def self.default_specifications_dir; end + end + + module BundlerVersionFinder + def self.bundler_version; end + + def self.bundler_version_with_reason; end + + def self.compatible?(spec); end + + def self.filter!(specs); end + + def self.missing_version_message; end + end + + class Command + include Gem::UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + HELP = T.let(nil, T.untyped) + + def add_extra_args(args); end + + def add_option(*opts, &handler); end + + def arguments; end + + def begins?(long, short); end + + def command; end + + def defaults; end + + def defaults=(defaults); end + + def defaults_str; end + + def description; end + + def execute; end + + def get_all_gem_names; end + + def get_all_gem_names_and_versions; end + + def get_one_gem_name; end + + def get_one_optional_argument; end + + def handle_options(args); end + + def handles?(args); end + + def initialize(command, summary = T.unsafe(nil), defaults = T.unsafe(nil)); end + + def invoke(*args); end + + def invoke_with_build_args(args, build_args); end + + def merge_options(new_options); end + + def options; end + + def program_name; end + + def program_name=(program_name); end + + def remove_option(name); end + + def show_help; end + + def show_lookup_failure(gem_name, version, errors, domain, required_by = T.unsafe(nil)); end + + def summary; end + + def summary=(summary); end + + def usage; end + + def when_invoked(&block); end + + def self.add_common_option(*args, &handler); end + + def self.add_specific_extra_args(cmd, args); end + + def self.build_args; end + + def self.build_args=(value); end + + def self.common_options; end + + def self.extra_args; end + + def self.extra_args=(value); end + + def self.specific_extra_args(cmd); end + + def self.specific_extra_args_hash; end + + def clean_text(text); end + + def format_text(text, wrap, indent = T.unsafe(nil)); end + + def levenshtein_distance(str1, str2); end + + def min3(a, b, c); end + + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + def ui; end + + def ui=(new_ui); end + + def use_ui(new_ui, &block); end + + def alert(statement, question = T.unsafe(nil)); end + + def alert_error(statement, question = T.unsafe(nil)); end + + def alert_warning(statement, question = T.unsafe(nil)); end + + def ask(question); end + + def ask_for_password(prompt); end + + def ask_yes_no(question, default = T.unsafe(nil)); end + + def choose_from_list(question, list); end + + def say(statement = T.unsafe(nil)); end + + def terminate_interaction(exit_code = T.unsafe(nil)); end + + def verbose(msg = T.unsafe(nil)); end + end + + module Commands + end + + class ConfigFile + include Gem::UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + DEFAULT_BACKTRACE = T.let(nil, T.untyped) + DEFAULT_BULK_THRESHOLD = T.let(nil, T.untyped) + DEFAULT_CERT_EXPIRATION_LENGTH_DAYS = T.let(nil, T.untyped) + DEFAULT_CONCURRENT_DOWNLOADS = T.let(nil, T.untyped) + DEFAULT_UPDATE_SOURCES = T.let(nil, T.untyped) + DEFAULT_VERBOSITY = T.let(nil, T.untyped) + OPERATING_SYSTEM_DEFAULTS = T.let(nil, T.untyped) + PLATFORM_DEFAULTS = T.let(nil, T.untyped) + SYSTEM_CONFIG_PATH = T.let(nil, T.untyped) + SYSTEM_WIDE_CONFIG_FILE = T.let(nil, T.untyped) + + def ==(other); end + + def [](key); end + + def []=(key, value); end + + def api_keys; end + + def args; end + + def backtrace; end + + def backtrace=(backtrace); end + + def bulk_threshold; end + + def bulk_threshold=(bulk_threshold); end + + def cert_expiration_length_days; end + + def cert_expiration_length_days=(cert_expiration_length_days); end + + def check_credentials_permissions; end + + def concurrent_downloads; end + + def concurrent_downloads=(concurrent_downloads); end + + def config_file_name; end + + def credentials_path; end + + def disable_default_gem_server; end + + def disable_default_gem_server=(disable_default_gem_server); end + + def each(&block); end + + def handle_arguments(arg_list); end + + def home; end + + def home=(home); end + + def initialize(args); end + + def load_api_keys; end + + def load_file(filename); end + + def path; end + + def path=(path); end + + def really_verbose; end + + def rubygems_api_key; end + + def rubygems_api_key=(api_key); end + + def set_api_key(host, api_key); end + + def sources; end + + def sources=(sources); end + + def ssl_ca_cert; end + + def ssl_ca_cert=(ssl_ca_cert); end + + def ssl_client_cert; end + + def ssl_verify_mode; end + + def to_yaml; end + + def unset_api_key!; end + + def update_sources; end + + def update_sources=(update_sources); end + + def verbose; end + + def verbose=(verbose); end + + def write; end + + def clean_text(text); end + + def format_text(text, wrap, indent = T.unsafe(nil)); end + + def levenshtein_distance(str1, str2); end + + def min3(a, b, c); end + + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + def ui; end + + def ui=(new_ui); end + + def use_ui(new_ui, &block); end + + def alert(statement, question = T.unsafe(nil)); end + + def alert_error(statement, question = T.unsafe(nil)); end + + def alert_warning(statement, question = T.unsafe(nil)); end + + def ask(question); end + + def ask_for_password(prompt); end + + def ask_yes_no(question, default = T.unsafe(nil)); end + + def choose_from_list(question, list); end + + def say(statement = T.unsafe(nil)); end + + def terminate_interaction(exit_code = T.unsafe(nil)); end + end + + class ConflictError + def conflicts; end + + def initialize(target, conflicts); end + + def target; end + end + + class ConsoleUI + def initialize; end + end + + module DefaultUserInteraction + include Gem::Text + + def ui; end + + def ui=(new_ui); end + + def use_ui(new_ui, &block); end + + def self.ui; end + + def self.ui=(new_ui); end + + def self.use_ui(new_ui); end + + def clean_text(text); end + + def format_text(text, wrap, indent = T.unsafe(nil)); end + + def levenshtein_distance(str1, str2); end + + def min3(a, b, c); end + + def truncate_text(text, description, max_length = T.unsafe(nil)); end + end + + class Dependency + def ==(other); end + + def ===(other); end + + def =~(other); end + + def all_sources; end + + def all_sources=(all_sources); end + + def encode_with(coder); end + + def eql?(other); end + + def groups; end + + def groups=(groups); end + + def initialize(name, *requirements); end + + def latest_version?; end + + def match?(obj, version = T.unsafe(nil), allow_prerelease = T.unsafe(nil)); end + + def matches_spec?(spec); end + + def matching_specs(platform_only = T.unsafe(nil)); end + + def merge(other); end + + def name; end + + def name=(name); end + + def prerelease=(prerelease); end + + def prerelease?; end + + def pretty_print(q); end + + def requirement; end + + def requirements_list; end + + def runtime?; end + + def source; end + + def source=(source); end + + def specific?; end + + def to_lock; end + + def to_spec; end + + def to_specs; end + + def to_yaml_properties; end + + def type; end + end + + class DependencyInstaller + include Gem::UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + extend Gem::Deprecate + DEFAULT_OPTIONS = T.let(nil, T.untyped) + + def _deprecated_add_found_dependencies(to_do, dependency_list); end + + def _deprecated_gather_dependencies; end + + def add_found_dependencies(*args, &block); end + + def available_set_for(dep_or_name, version); end + + def consider_local?; end + + def consider_remote?; end + + def document; end + + def errors; end + + def find_gems_with_sources(dep, best_only = T.unsafe(nil)); end + + def find_spec_by_name_and_version(gem_name, version = T.unsafe(nil), prerelease = T.unsafe(nil)); end + + def gather_dependencies(*args, &block); end + + def in_background(what); end + + def initialize(options = T.unsafe(nil)); end + + def install(dep_or_name, version = T.unsafe(nil)); end + + def install_development_deps; end + + def installed_gems; end + + def resolve_dependencies(dep_or_name, version); end + + def clean_text(text); end + + def format_text(text, wrap, indent = T.unsafe(nil)); end + + def levenshtein_distance(str1, str2); end + + def min3(a, b, c); end + + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + def ui; end + + def ui=(new_ui); end + + def use_ui(new_ui, &block); end + + def alert(statement, question = T.unsafe(nil)); end + + def alert_error(statement, question = T.unsafe(nil)); end + + def alert_warning(statement, question = T.unsafe(nil)); end + + def ask(question); end + + def ask_for_password(prompt); end + + def ask_yes_no(question, default = T.unsafe(nil)); end + + def choose_from_list(question, list); end + + def say(statement = T.unsafe(nil)); end + + def terminate_interaction(exit_code = T.unsafe(nil)); end + + def verbose(msg = T.unsafe(nil)); end + end + + class DependencyList + include Enumerable + include TSort + Elem = type_member(fixed: T.untyped) + + def add(*gemspecs); end + + def clear; end + + def dependency_order; end + + def development; end + + def development=(development); end + + def each(&block); end + + def find_name(full_name); end + + def initialize(development = T.unsafe(nil)); end + + def ok?; end + + def ok_to_remove?(full_name, check_dev = T.unsafe(nil)); end + + def remove_by_name(full_name); end + + def remove_specs_unsatisfied_by(dependencies); end + + def spec_predecessors; end + + def specs; end + + def tsort_each_node(&block); end + + def why_not_ok?(quick = T.unsafe(nil)); end + + def self.from_specs; end + end + + class DependencyResolutionError + def conflict; end + + def conflicting_dependencies; end + + def initialize(conflict); end + end + + module Deprecate + def self.deprecate(name, repl, year, month); end + + def self.skip; end + + def self.skip=(v); end + + def self.skip_during; end + end + + class Exception + extend Gem::Deprecate + + def _deprecated_source_exception; end + + def source_exception(*args, &block); end + + def source_exception=(source_exception); end + end + + module Ext + class BuildError + end + + class Builder + include Gem::UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + CHDIR_MONITOR = T.let(nil, T.untyped) + CHDIR_MUTEX = T.let(nil, T.untyped) + + def build_args; end + + def build_args=(build_args); end + + def build_error(build_dir, output, backtrace = T.unsafe(nil)); end + + def build_extension(extension, dest_path); end + + def build_extensions; end + + def builder_for(extension); end + + def initialize(spec, build_args = T.unsafe(nil)); end + + def write_gem_make_out(output); end + + def self.class_name; end + + def self.make(dest_path, results); end + + def self.redirector; end + + def self.run(command, results, command_name = T.unsafe(nil)); end + + def clean_text(text); end + + def format_text(text, wrap, indent = T.unsafe(nil)); end + + def levenshtein_distance(str1, str2); end + + def min3(a, b, c); end + + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + def ui; end + + def ui=(new_ui); end + + def use_ui(new_ui, &block); end + + def alert(statement, question = T.unsafe(nil)); end + + def alert_error(statement, question = T.unsafe(nil)); end + + def alert_warning(statement, question = T.unsafe(nil)); end + + def ask(question); end + + def ask_for_password(prompt); end + + def ask_yes_no(question, default = T.unsafe(nil)); end + + def choose_from_list(question, list); end + + def say(statement = T.unsafe(nil)); end + + def terminate_interaction(exit_code = T.unsafe(nil)); end + + def verbose(msg = T.unsafe(nil)); end + end + + class CmakeBuilder + def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end + end + + class ConfigureBuilder + def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end + end + + class ExtConfBuilder + def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end + + def self.get_relative_path(path); end + end + + class RakeBuilder + def self.build(extension, dest_path, results, args = T.unsafe(nil), lib_dir = T.unsafe(nil)); end + end + end + + class FilePermissionError + def directory; end + + def initialize(directory); end + end + + class FormatException + def file_path; end + + def file_path=(file_path); end + end + + class GemNotInHomeException + def spec; end + + def spec=(spec); end + end + + class ImpossibleDependenciesError + def build_message; end + + def conflicts; end + + def dependency; end + + def initialize(request, conflicts); end + + def request; end + end + + class Installer + include Gem::UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + extend Gem::Deprecate + ENV_PATHS = T.let(nil, T.untyped) + + def _deprecated_extension_build_error(build_dir, output, backtrace = T.unsafe(nil)); end + + def app_script_text(bin_file_name); end + + def bin_dir; end + + def build_extensions; end + + def build_root; end + + def check_executable_overwrite(filename); end + + def check_that_user_bin_dir_is_in_path; end + + def default_spec_file; end + + def dir; end + + def ensure_dependencies_met; end + + def ensure_dependency(spec, dependency); end + + def ensure_loadable_spec; end + + def ensure_required_ruby_version_met; end + + def ensure_required_rubygems_version_met; end + + def extension_build_error(*args, &block); end + + def extract_bin; end + + def extract_files; end + + def formatted_program_filename(filename); end + + def gem; end + + def gem_dir; end + + def gem_home; end + + def generate_bin; end + + def generate_bin_script(filename, bindir); end + + def generate_bin_symlink(filename, bindir); end + + def generate_windows_script(filename, bindir); end + + def initialize(package, options = T.unsafe(nil)); end + + def install; end + + def installation_satisfies_dependency?(dependency); end + + def installed_specs; end + + def options; end + + def pre_install_checks; end + + def process_options; end + + def run_post_build_hooks; end + + def run_post_install_hooks; end + + def run_pre_install_hooks; end + + def shebang(bin_file_name); end + + def spec; end + + def spec_file; end + + def unpack(directory); end + + def verify_gem_home(unpack = T.unsafe(nil)); end + + def verify_spec; end + + def windows_stub_script(bindir, bin_file_name); end + + def write_build_info_file; end + + def write_cache_file; end + + def write_default_spec; end + + def write_spec; end + + def self.at(path, options = T.unsafe(nil)); end + + def self.exec_format; end + + def self.exec_format=(exec_format); end + + def self.for_spec(spec, options = T.unsafe(nil)); end + + def self.install_lock; end + + def self.path_warning; end + + def self.path_warning=(path_warning); end + + def clean_text(text); end + + def format_text(text, wrap, indent = T.unsafe(nil)); end + + def levenshtein_distance(str1, str2); end + + def min3(a, b, c); end + + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + def ui; end + + def ui=(new_ui); end + + def use_ui(new_ui, &block); end + + def alert(statement, question = T.unsafe(nil)); end + + def alert_error(statement, question = T.unsafe(nil)); end + + def alert_warning(statement, question = T.unsafe(nil)); end + + def ask(question); end + + def ask_for_password(prompt); end + + def ask_yes_no(question, default = T.unsafe(nil)); end + + def choose_from_list(question, list); end + + def say(statement = T.unsafe(nil)); end + + def terminate_interaction(exit_code = T.unsafe(nil)); end + + def verbose(msg = T.unsafe(nil)); end + end + + class Licenses + extend Gem::Text + EXCEPTION_IDENTIFIERS = T.let(nil, T.untyped) + LICENSE_IDENTIFIERS = T.let(nil, T.untyped) + NONSTANDARD = T.let(nil, T.untyped) + REGEXP = T.let(nil, T.untyped) + + def self.match?(license); end + + def self.suggestions(license); end + + def self.clean_text(text); end + + def self.format_text(text, wrap, indent = T.unsafe(nil)); end + + def self.levenshtein_distance(str1, str2); end + + def self.min3(a, b, c); end + + def self.truncate_text(text, description, max_length = T.unsafe(nil)); end + end + + class List + def each(&blk); end + + def initialize(value = T.unsafe(nil), tail = T.unsafe(nil)); end + + def prepend(value); end + + def pretty_print(q); end + + def tail; end + + def tail=(tail); end + + def to_a; end + + def value; end + + def value=(value); end + + def self.prepend(list, value); end + end + + class LoadError + def name; end + + def name=(name); end + + def requirement; end + + def requirement=(requirement); end + end + + class MissingSpecError + def initialize(name, requirement); end + end + + class MissingSpecVersionError + def initialize(name, requirement, specs); end + + def specs; end + end + + class NameTuple + include Comparable + + def ==(other); end + + def eql?(other); end + + def full_name; end + + def initialize(name, version, platform = T.unsafe(nil)); end + + def match_platform?; end + + def name; end + + def platform; end + + def prerelease?; end + + def spec_name; end + + def to_a; end + + def version; end + + def self.from_list(list); end + + def self.null; end + + def self.to_basic(list); end + end + + class Package + include Gem::UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + + def add_checksums(tar); end + + def add_contents(tar); end + + def add_files(tar); end + + def add_metadata(tar); end + + def build(skip_validation = T.unsafe(nil), strict_validation = T.unsafe(nil)); end + + def build_time; end + + def build_time=(build_time); end + + def checksums; end + + def contents; end + + def copy_to(path); end + + def data_mode; end + + def data_mode=(data_mode); end + + def digest(entry); end + + def dir_mode; end + + def dir_mode=(dir_mode); end + + def extract_files(destination_dir, pattern = T.unsafe(nil)); end + + def extract_tar_gz(io, destination_dir, pattern = T.unsafe(nil)); end + + def file_mode(mode); end + + def files; end + + def gzip_to(io); end + + def initialize(gem, security_policy); end + + def install_location(filename, destination_dir); end + + def load_spec(entry); end + + def mkdir_p_safe(mkdir, mkdir_options, destination_dir, file_name); end + + def normalize_path(pathname); end + + def open_tar_gz(io); end + + def prog_mode; end + + def prog_mode=(prog_mode); end + + def read_checksums(gem); end + + def security_policy; end + + def security_policy=(security_policy); end + + def setup_signer(signer_options: T.unsafe(nil)); end + + def spec; end + + def spec=(spec); end + + def verify; end + + def verify_checksums(digests, checksums); end + + def verify_entry(entry); end + + def verify_files(gem); end + + def verify_gz(entry); end + + def self.build(spec, skip_validation = T.unsafe(nil), strict_validation = T.unsafe(nil), file_name = T.unsafe(nil)); end + + def self.new(gem, security_policy = T.unsafe(nil)); end + + def clean_text(text); end + + def format_text(text, wrap, indent = T.unsafe(nil)); end + + def levenshtein_distance(str1, str2); end + + def min3(a, b, c); end + + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + def ui; end + + def ui=(new_ui); end + + def use_ui(new_ui, &block); end + + def alert(statement, question = T.unsafe(nil)); end + + def alert_error(statement, question = T.unsafe(nil)); end + + def alert_warning(statement, question = T.unsafe(nil)); end + + def ask(question); end + + def ask_for_password(prompt); end + + def ask_yes_no(question, default = T.unsafe(nil)); end + + def choose_from_list(question, list); end + + def say(statement = T.unsafe(nil)); end + + def terminate_interaction(exit_code = T.unsafe(nil)); end + + def verbose(msg = T.unsafe(nil)); end + + class DigestIO + def digests; end + + def initialize(io, digests); end + + def write(data); end + + def self.wrap(io, digests); end + end + + class Error + end + + class FileSource + def initialize(path); end + + def path; end + + def present?; end + + def start; end + + def with_read_io(&block); end + + def with_write_io(&block); end + end + + class FormatError + def initialize(message, source = T.unsafe(nil)); end + + def path; end + end + + class IOSource + def initialize(io); end + + def io; end + + def path; end + + def present?; end + + def start; end + + def with_read_io; end + + def with_write_io; end + end + + class NonSeekableIO + end + + class Old + def extract_files(destination_dir); end + + def file_list(io); end + + def read_until_dashes(io); end + + def skip_ruby(io); end + end + + class PathError + def initialize(destination, destination_dir); end + end + + class Source + end + + class TarHeader + EMPTY_HEADER = T.let(nil, T.untyped) + FIELDS = T.let(nil, T.untyped) + PACK_FORMAT = T.let(nil, T.untyped) + UNPACK_FORMAT = T.let(nil, T.untyped) + + def ==(other); end + + def checksum; end + + def devmajor; end + + def devminor; end + + def empty?; end + + def gid; end + + def gname; end + + def initialize(vals); end + + def linkname; end + + def magic; end + + def mode; end + + def mtime; end + + def name; end + + def prefix; end + + def size; end + + def typeflag; end + + def uid; end + + def uname; end + + def update_checksum; end + + def version; end + + def self.from(stream); end + + def self.strict_oct(str); end + end + + class TarInvalidError + end + + class TarReader + include Enumerable + Elem = type_member(fixed: T.untyped) + + def close; end + + def each(&blk); end + + def each_entry; end + + def initialize(io); end + + def rewind; end + + def seek(name); end + + def self.new(io); end + + class Entry + def bytes_read; end + + def check_closed; end + + def close; end + + def closed?; end + + def directory?; end + + def eof?; end + + def file?; end + + def full_name; end + + def getc; end + + def header; end + + def initialize(header, io); end + + def length; end + + def pos; end + + def read(len = T.unsafe(nil)); end + + def readpartial(maxlen = T.unsafe(nil), outbuf = T.unsafe(nil)); end + + def rewind; end + + def size; end + + def symlink?; end + end + + class UnexpectedEOF + end + end + + class TarWriter + def add_file(name, mode); end + + def add_file_digest(name, mode, digest_algorithms); end + + def add_file_signed(name, mode, signer); end + + def add_file_simple(name, mode, size); end + + def add_symlink(name, target, mode); end + + def check_closed; end + + def close; end + + def closed?; end + + def flush; end + + def initialize(io); end + + def mkdir(name, mode); end + + def split_name(name); end + + def self.new(io); end + + class BoundedStream + def initialize(io, limit); end + + def limit; end + + def write(data); end + + def written; end + end + + class FileOverflow + end + + class RestrictedStream + def initialize(io); end + + def write(data); end + end + end + + class TooLongFileName + end + end + + class PathSupport + def home; end + + def initialize(env); end + + def path; end + + def spec_cache_dir; end + end + + class Platform + JAVA = T.let(nil, T.untyped) + MINGW = T.let(nil, T.untyped) + MSWIN = T.let(nil, T.untyped) + MSWIN64 = T.let(nil, T.untyped) + X64_MINGW = T.let(nil, T.untyped) + + def ==(other); end + + def ===(other); end + + def =~(other); end + + def cpu; end + + def cpu=(cpu); end + + def eql?(other); end + + def initialize(arch); end + + def os; end + + def os=(os); end + + def to_a; end + + def version; end + + def version=(version); end + + def self.installable?(spec); end + + def self.local; end + + def self.match(platform); end + + def self.new(arch); end + end + + class PlatformMismatch + def add_platform(platform); end + + def initialize(name, version); end + + def name; end + + def platforms; end + + def version; end + + def wordy; end + end + + class RemoteFetcher + include Gem::UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + BASE64_URI_TRANSLATE = T.let(nil, T.untyped) + + def cache_update_path(uri, path = T.unsafe(nil), update = T.unsafe(nil)); end + + def close_all; end + + def correct_for_windows_path(path); end + + def download(spec, source_uri, install_dir = T.unsafe(nil)); end + + def download_to_cache(dependency); end + + def fetch_file(uri, *_); end + + def fetch_http(uri, last_modified = T.unsafe(nil), head = T.unsafe(nil), depth = T.unsafe(nil)); end + + def fetch_https(uri, last_modified = T.unsafe(nil), head = T.unsafe(nil), depth = T.unsafe(nil)); end + + def fetch_path(uri, mtime = T.unsafe(nil), head = T.unsafe(nil)); end + + def fetch_s3(uri, mtime = T.unsafe(nil), head = T.unsafe(nil)); end + + def fetch_size(uri); end + + def headers; end + + def headers=(headers); end + + def https?(uri); end + + def initialize(proxy = T.unsafe(nil), dns = T.unsafe(nil), headers = T.unsafe(nil)); end + + def request(uri, request_class, last_modified = T.unsafe(nil)); end + + def s3_expiration; end + + def sign_s3_url(uri, expiration = T.unsafe(nil)); end + + def self.fetcher; end + + def clean_text(text); end + + def format_text(text, wrap, indent = T.unsafe(nil)); end + + def levenshtein_distance(str1, str2); end + + def min3(a, b, c); end + + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + def ui; end + + def ui=(new_ui); end + + def use_ui(new_ui, &block); end + + def alert(statement, question = T.unsafe(nil)); end + + def alert_error(statement, question = T.unsafe(nil)); end + + def alert_warning(statement, question = T.unsafe(nil)); end + + def ask(question); end + + def ask_for_password(prompt); end + + def ask_yes_no(question, default = T.unsafe(nil)); end + + def choose_from_list(question, list); end + + def say(statement = T.unsafe(nil)); end + + def terminate_interaction(exit_code = T.unsafe(nil)); end + + def verbose(msg = T.unsafe(nil)); end + end + + class Request + include Gem::UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + extend Gem::UserInteraction + extend Gem::DefaultUserInteraction + extend Gem::Text + + def cert_files; end + + def connection_for(uri); end + + def fetch; end + + def initialize(uri, request_class, last_modified, pool); end + + def perform_request(request); end + + def proxy_uri; end + + def reset(connection); end + + def user_agent; end + + def self.configure_connection_for_https(connection, cert_files); end + + def self.create_with_proxy(uri, request_class, last_modified, proxy); end + + def self.get_cert_files; end + + def self.get_proxy_from_env(scheme = T.unsafe(nil)); end + + def self.proxy_uri(proxy); end + + def self.verify_certificate(store_context); end + + def self.verify_certificate_message(error_number, cert); end + + def self.clean_text(text); end + + def self.format_text(text, wrap, indent = T.unsafe(nil)); end + + def self.levenshtein_distance(str1, str2); end + + def self.min3(a, b, c); end + + def self.truncate_text(text, description, max_length = T.unsafe(nil)); end + + def self.ui; end + + def self.ui=(new_ui); end + + def self.use_ui(new_ui, &block); end + + def self.alert(statement, question = T.unsafe(nil)); end + + def self.alert_error(statement, question = T.unsafe(nil)); end + + def self.alert_warning(statement, question = T.unsafe(nil)); end + + def self.ask(question); end + + def self.ask_for_password(prompt); end + + def self.ask_yes_no(question, default = T.unsafe(nil)); end + + def self.choose_from_list(question, list); end + + def self.say(statement = T.unsafe(nil)); end + + def self.terminate_interaction(exit_code = T.unsafe(nil)); end + + def self.verbose(msg = T.unsafe(nil)); end + + def clean_text(text); end + + def format_text(text, wrap, indent = T.unsafe(nil)); end + + def levenshtein_distance(str1, str2); end + + def min3(a, b, c); end + + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + def ui; end + + def ui=(new_ui); end + + def use_ui(new_ui, &block); end + + def alert(statement, question = T.unsafe(nil)); end + + def alert_error(statement, question = T.unsafe(nil)); end + + def alert_warning(statement, question = T.unsafe(nil)); end + + def ask(question); end + + def ask_for_password(prompt); end + + def ask_yes_no(question, default = T.unsafe(nil)); end + + def choose_from_list(question, list); end + + def say(statement = T.unsafe(nil)); end + + def terminate_interaction(exit_code = T.unsafe(nil)); end + + def verbose(msg = T.unsafe(nil)); end + + class ConnectionPools + def close_all; end + + def initialize(proxy_uri, cert_files); end + + def pool_for(uri); end + + def self.client; end + + def self.client=(client); end + end + + class HTTPPool + def cert_files; end + + def checkin(connection); end + + def checkout; end + + def close_all; end + + def initialize(http_args, cert_files, proxy_uri); end + + def proxy_uri; end + end + + class HTTPSPool + end + end + + class RequestSet + include TSort + + def always_install; end + + def always_install=(always_install); end + + def dependencies; end + + def development; end + + def development=(development); end + + def development_shallow; end + + def development_shallow=(development_shallow); end + + def errors; end + + def gem(name, *reqs); end + + def git_set; end + + def ignore_dependencies; end + + def ignore_dependencies=(ignore_dependencies); end + + def import(deps); end + + def initialize(*deps); end + + def install(options, &block); end + + def install_dir; end + + def install_from_gemdeps(options, &block); end + + def install_hooks(requests, options); end + + def install_into(dir, force = T.unsafe(nil), options = T.unsafe(nil)); end + + def load_gemdeps(path, without_groups = T.unsafe(nil), installing = T.unsafe(nil)); end + + def prerelease; end + + def prerelease=(prerelease); end + + def pretty_print(q); end + + def remote; end + + def remote=(remote); end + + def resolve(set = T.unsafe(nil)); end + + def resolve_current; end + + def resolver; end + + def sets; end + + def soft_missing; end + + def soft_missing=(soft_missing); end + + def sorted_requests; end + + def source_set; end + + def specs; end + + def specs_in(dir); end + + def tsort_each_node(&block); end + + def vendor_set; end + + class GemDependencyAPI + ENGINE_MAP = T.let(nil, T.untyped) + PLATFORM_MAP = T.let(nil, T.untyped) + VERSION_MAP = T.let(nil, T.untyped) + WINDOWS = T.let(nil, T.untyped) + + def dependencies; end + + def find_gemspec(name, path); end + + def gem(name, *requirements); end + + def gem_deps_file; end + + def gem_git_reference(options); end + + def gemspec(options = T.unsafe(nil)); end + + def git(repository); end + + def git_set; end + + def git_source(name, &callback); end + + def group(*groups); end + + def initialize(set, path); end + + def installing=(installing); end + + def load; end + + def platform(*platforms); end + + def platforms(*platforms); end + + def requires; end + + def ruby(version, options = T.unsafe(nil)); end + + def source(url); end + + def vendor_set; end + + def without_groups; end + + def without_groups=(without_groups); end + end + + class Lockfile + def add_DEPENDENCIES(out); end + + def add_GEM(out, spec_groups); end + + def add_GIT(out, git_requests); end + + def add_PATH(out, path_requests); end + + def add_PLATFORMS(out); end + + def initialize(request_set, gem_deps_file, dependencies); end + + def platforms; end + + def relative_path_from(dest, base); end + + def spec_groups; end + + def write; end + + def self.build(request_set, gem_deps_file, dependencies = T.unsafe(nil)); end + + def self.requests_to_deps(requests); end + + class ParseError + def column; end + + def initialize(message, column, line, path); end + + def line; end + + def path; end + end + + class Parser + def get(expected_types = T.unsafe(nil), expected_value = T.unsafe(nil)); end + + def initialize(tokenizer, set, platforms, filename = T.unsafe(nil)); end + + def parse; end + + def parse_DEPENDENCIES; end + + def parse_GEM; end + + def parse_GIT; end + + def parse_PATH; end + + def parse_PLATFORMS; end + + def parse_dependency(name, op); end + end + + class Tokenizer + EOF = T.let(nil, T.untyped) + + def empty?; end + + def initialize(input, filename = T.unsafe(nil), line = T.unsafe(nil), pos = T.unsafe(nil)); end + + def make_parser(set, platforms); end + + def next_token; end + + def peek; end + + def shift; end + + def skip(type); end + + def to_a; end + + def token_pos(byte_offset); end + + def unshift(token); end + + def self.from_file(file); end + + class Token + def column; end + + def column=(_); end + + def line; end + + def line=(_); end + + def type; end + + def type=(_); end + + def value; end + + def value=(_); end + + def self.[](*_); end + + def self.members; end + end + end + end + end + + class Requirement + DefaultRequirement = T.let(nil, T.untyped) + + def ==(other); end + + def ===(version); end + + def =~(version); end + + def _tilde_requirements; end + + def as_list; end + + def concat(new); end + + def encode_with(coder); end + + def exact?; end + + def for_lockfile; end + + def init_with(coder); end + + def initialize(*requirements); end + + def marshal_dump; end + + def marshal_load(array); end + + def none?; end + + def prerelease?; end + + def pretty_print(q); end + + def requirements; end + + def satisfied_by?(version); end + + def specific?; end + + def to_yaml_properties; end + + def yaml_initialize(tag, vals); end + + def self.create(*inputs); end + + def self.default; end + + def self.parse(obj); end + + def self.source_set; end + end + + class Resolver + include Gem::Resolver::Molinillo::UI + include Gem::Resolver::Molinillo::SpecificationProvider + DEBUG_RESOLVER = T.let(nil, T.untyped) + + def activation_request(dep, possible); end + + def development; end + + def development=(development); end + + def development_shallow; end + + def development_shallow=(development_shallow); end + + def explain(stage, *data); end + + def explain_list(stage); end + + def find_possible(dependency); end + + def ignore_dependencies; end + + def ignore_dependencies=(ignore_dependencies); end + + def initialize(needed, set = T.unsafe(nil)); end + + def missing; end + + def requests(s, act, reqs = T.unsafe(nil)); end + + def resolve; end + + def select_local_platforms(specs); end + + def skip_gems; end + + def skip_gems=(skip_gems); end + + def soft_missing; end + + def soft_missing=(soft_missing); end + + def stats; end + + def self.compose_sets(*sets); end + + def self.for_current_gems(needed); end + + def allow_missing?(dependency); end + + def dependencies_for(specification); end + + def name_for(dependency); end + + def name_for_explicit_dependency_source; end + + def name_for_locking_dependency_source; end + + def requirement_satisfied_by?(requirement, activated, spec); end + + def search_for(dependency); end + + def sort_dependencies(dependencies, activated, conflicts); end + + def after_resolution; end + + def before_resolution; end + + def debug(depth = T.unsafe(nil)); end + + def debug?; end + + def indicate_progress; end + + def output; end + + def progress_rate; end + + class APISet + def dep_uri; end + + def initialize(dep_uri = T.unsafe(nil)); end + + def prefetch_now; end + + def pretty_print(q); end + + def source; end + + def uri; end + + def versions(name); end + end + + class APISpecification + def ==(other); end + + def initialize(set, api_data); end + + def pretty_print(q); end + end + + class ActivationRequest + def ==(other); end + + def development?; end + + def download(path); end + + def full_name; end + + def full_spec; end + + def initialize(spec, request, others_possible = T.unsafe(nil)); end + + def installed?; end + + def name; end + + def others_possible?; end + + def parent; end + + def pretty_print(q); end + + def request; end + + def spec; end + + def version; end + end + + class BestSet + def initialize(sources = T.unsafe(nil)); end + + def pick_sets; end + + def pretty_print(q); end + + def replace_failed_api_set(error); end + end + + class ComposedSet + def initialize(*sets); end + + def prerelease=(allow_prerelease); end + + def remote=(remote); end + + def sets; end + end + + class Conflict + def ==(other); end + + def activated; end + + def conflicting_dependencies; end + + def dependency; end + + def explain; end + + def explanation; end + + def failed_dep; end + + def for_spec?(spec); end + + def initialize(dependency, activated, failed_dep = T.unsafe(nil)); end + + def pretty_print(q); end + + def request_path(current); end + + def requester; end + end + + class CurrentSet + end + + class DependencyRequest + def ==(other); end + + def dependency; end + + def development?; end + + def explicit?; end + + def implicit?; end + + def initialize(dependency, requester); end + + def match?(spec, allow_prerelease = T.unsafe(nil)); end + + def matches_spec?(spec); end + + def name; end + + def pretty_print(q); end + + def request_context; end + + def requester; end + + def requirement; end + + def type; end + end + + class GitSet + def add_git_gem(name, repository, reference, submodules); end + + def add_git_spec(name, version, repository, reference, submodules); end + + def need_submodules; end + + def pretty_print(q); end + + def repositories; end + + def root_dir; end + + def root_dir=(root_dir); end + + def specs; end + end + + class GitSpecification + def ==(other); end + + def add_dependency(dependency); end + + def pretty_print(q); end + end + + class IndexSet + def initialize(source = T.unsafe(nil)); end + + def pretty_print(q); end + end + + class IndexSpecification + def initialize(set, name, version, source, platform); end + + def pretty_print(q); end + end + + class InstalledSpecification + def ==(other); end + + def pretty_print(q); end + end + + class InstallerSet + def add_always_install(dependency); end + + def add_local(dep_name, spec, source); end + + def always_install; end + + def consider_local?; end + + def consider_remote?; end + + def ignore_dependencies; end + + def ignore_dependencies=(ignore_dependencies); end + + def ignore_installed; end + + def ignore_installed=(ignore_installed); end + + def initialize(domain); end + + def load_spec(name, ver, platform, source); end + + def local?(dep_name); end + + def prerelease=(allow_prerelease); end + + def pretty_print(q); end + + def remote=(remote); end + + def remote_set; end + end + + class LocalSpecification + def pretty_print(q); end + end + + class LockSet + def add(name, version, platform); end + + def initialize(sources); end + + def load_spec(name, version, platform, source); end + + def pretty_print(q); end + + def specs; end + end + + class LockSpecification + def add_dependency(dependency); end + + def initialize(set, name, version, sources, platform); end + + def pretty_print(q); end + + def sources; end + end + + module Molinillo + VERSION = T.let(nil, T.untyped) + + class CircularDependencyError + def dependencies; end + + def initialize(nodes); end + end + + module Delegates + module ResolutionState + def activated; end + + def conflicts; end + + def depth; end + + def name; end + + def possibilities; end + + def requirement; end + + def requirements; end + end + + module SpecificationProvider + def allow_missing?(dependency); end + + def dependencies_for(specification); end + + def name_for(dependency); end + + def name_for_explicit_dependency_source; end + + def name_for_locking_dependency_source; end + + def requirement_satisfied_by?(requirement, activated, spec); end + + def search_for(dependency); end + + def sort_dependencies(dependencies, activated, conflicts); end + end + end + + class DependencyGraph + include Enumerable + include TSort + Elem = type_member(fixed: T.untyped) + + def ==(other); end + + def add_child_vertex(name, payload, parent_names, requirement); end + + def add_edge(origin, destination, requirement); end + + def add_vertex(name, payload, root = T.unsafe(nil)); end + + def delete_edge(edge); end + + def detach_vertex_named(name); end + + def each(&blk); end + + def log; end + + def rewind_to(tag); end + + def root_vertex_named(name); end + + def set_payload(name, payload); end + + def tag(tag); end + + def to_dot(options = T.unsafe(nil)); end + + def tsort_each_child(vertex, &block); end + + def vertex_named(name); end + + def vertices; end + + def self.tsort(vertices); end + + class Action + def down(graph); end + + def next; end + + def next=(_); end + + def previous; end + + def previous=(previous); end + + def up(graph); end + + def self.action_name; end + end + + class AddEdgeNoCircular + def destination; end + + def initialize(origin, destination, requirement); end + + def make_edge(graph); end + + def origin; end + + def requirement; end + end + + class AddVertex + def initialize(name, payload, root); end + + def name; end + + def payload; end + + def root; end + end + + class DeleteEdge + def destination_name; end + + def initialize(origin_name, destination_name, requirement); end + + def make_edge(graph); end + + def origin_name; end + + def requirement; end + end + + class DetachVertexNamed + def initialize(name); end + + def name; end + end + + class Edge + def destination; end + + def destination=(_); end + + def origin; end + + def origin=(_); end + + def requirement; end + + def requirement=(_); end + + def self.[](*_); end + + def self.members; end + end + + class Log + extend T::Enumerable + Elem = type_member(fixed: T.untyped) + + def add_edge_no_circular(graph, origin, destination, requirement); end + + def add_vertex(graph, name, payload, root); end + + def delete_edge(graph, origin_name, destination_name, requirement); end + + def detach_vertex_named(graph, name); end + + def each(&blk); end + + def pop!(graph); end + + def reverse_each; end + + def rewind_to(graph, tag); end + + def set_payload(graph, name, payload); end + + def tag(graph, tag); end + end + + class SetPayload + def initialize(name, payload); end + + def name; end + + def payload; end + end + + class Tag + def down(_graph); end + + def initialize(tag); end + + def tag; end + + def up(_graph); end + end + + class Vertex + def ==(other); end + + def ancestor?(other); end + + def descendent?(other); end + + def eql?(other); end + + def explicit_requirements; end + + def incoming_edges; end + + def incoming_edges=(incoming_edges); end + + def initialize(name, payload); end + + def is_reachable_from?(other); end + + def name; end + + def name=(name); end + + def outgoing_edges; end + + def outgoing_edges=(outgoing_edges); end + + def path_to?(other); end + + def payload; end + + def payload=(payload); end + + def predecessors; end + + def recursive_predecessors; end + + def recursive_successors; end + + def requirements; end + + def root; end + + def root=(root); end + + def root?; end + + def shallow_eql?(other); end + + def successors; end + end + end + + class DependencyState + def pop_possibility_state; end + end + + class NoSuchDependencyError + def dependency; end + + def dependency=(dependency); end + + def initialize(dependency, required_by = T.unsafe(nil)); end + + def required_by; end + + def required_by=(required_by); end + end + + class PossibilityState + end + + class ResolutionState + def activated; end + + def activated=(_); end + + def conflicts; end + + def conflicts=(_); end + + def depth; end + + def depth=(_); end + + def name; end + + def name=(_); end + + def possibilities; end + + def possibilities=(_); end + + def requirement; end + + def requirement=(_); end + + def requirements; end + + def requirements=(_); end + + def self.[](*_); end + + def self.empty; end + + def self.members; end + end + + class Resolver + def initialize(specification_provider, resolver_ui); end + + def resolve(requested, base = T.unsafe(nil)); end + + def resolver_ui; end + + def specification_provider; end + + class Resolution + include Gem::Resolver::Molinillo::Delegates::ResolutionState + include Gem::Resolver::Molinillo::Delegates::SpecificationProvider + + def base; end + + def initialize(specification_provider, resolver_ui, requested, base); end + + def iteration_rate=(iteration_rate); end + + def original_requested; end + + def resolve; end + + def resolver_ui; end + + def specification_provider; end + + def started_at=(started_at); end + + def states=(states); end + + def allow_missing?(dependency); end + + def dependencies_for(specification); end + + def name_for(dependency); end + + def name_for_explicit_dependency_source; end + + def name_for_locking_dependency_source; end + + def requirement_satisfied_by?(requirement, activated, spec); end + + def search_for(dependency); end + + def sort_dependencies(dependencies, activated, conflicts); end + + def activated; end + + def conflicts; end + + def depth; end + + def name; end + + def possibilities; end + + def requirement; end + + def requirements; end + + class Conflict + def activated_by_name; end + + def activated_by_name=(_); end + + def existing; end + + def existing=(_); end + + def locked_requirement; end + + def locked_requirement=(_); end + + def possibility; end + + def possibility=(_); end + + def requirement; end + + def requirement=(_); end + + def requirement_trees; end + + def requirement_trees=(_); end + + def requirements; end + + def requirements=(_); end + + def self.[](*_); end + + def self.members; end + end + end + end + + class ResolverError + end + + module SpecificationProvider + def allow_missing?(dependency); end + + def dependencies_for(specification); end + + def name_for(dependency); end + + def name_for_explicit_dependency_source; end + + def name_for_locking_dependency_source; end + + def requirement_satisfied_by?(requirement, activated, spec); end + + def search_for(dependency); end + + def sort_dependencies(dependencies, activated, conflicts); end + end + + module UI + def after_resolution; end + + def before_resolution; end + + def debug(depth = T.unsafe(nil)); end + + def debug?; end + + def indicate_progress; end + + def output; end + + def progress_rate; end + end + + class VersionConflict + def conflicts; end + + def initialize(conflicts); end + end + end + + class RequirementList + include Enumerable + Elem = type_member(fixed: T.untyped) + + def add(req); end + + def each(&blk); end + + def empty?; end + + def next5; end + + def remove; end + + def size; end + end + + class Set + def errors; end + + def errors=(errors); end + + def find_all(req); end + + def prefetch(reqs); end + + def prerelease; end + + def prerelease=(prerelease); end + + def remote; end + + def remote=(remote); end + + def remote?; end + end + + class SourceSet + def add_source_gem(name, source); end + end + + class SpecSpecification + def initialize(set, spec, source = T.unsafe(nil)); end + end + + class Specification + def dependencies; end + + def download(options); end + + def fetch_development_dependencies; end + + def full_name; end + + def install(options = T.unsafe(nil)); end + + def installable_platform?; end + + def local?; end + + def name; end + + def platform; end + + def set; end + + def source; end + + def spec; end + + def version; end + end + + class Stats + PATTERN = T.let(nil, T.untyped) + + def backtracking!; end + + def display; end + + def iteration!; end + + def record_depth(stack); end + + def record_requirements(reqs); end + + def requirement!; end + end + + class VendorSet + def add_vendor_gem(name, directory); end + + def load_spec(name, version, platform, source); end + + def pretty_print(q); end + + def specs; end + end + + class VendorSpecification + def ==(other); end + end + end + + class RuntimeRequirementNotMetError + def suggestion; end + + def suggestion=(suggestion); end + end + + module Security + AlmostNoSecurity = T.let(nil, T.untyped) + DIGEST_NAME = T.let(nil, T.untyped) + EXTENSIONS = T.let(nil, T.untyped) + HighSecurity = T.let(nil, T.untyped) + KEY_CIPHER = T.let(nil, T.untyped) + KEY_LENGTH = T.let(nil, T.untyped) + LowSecurity = T.let(nil, T.untyped) + MediumSecurity = T.let(nil, T.untyped) + NoSecurity = T.let(nil, T.untyped) + ONE_DAY = T.let(nil, T.untyped) + ONE_YEAR = T.let(nil, T.untyped) + Policies = T.let(nil, T.untyped) + SigningPolicy = T.let(nil, T.untyped) + + def self.alt_name_or_x509_entry(certificate, x509_entry); end + + def self.create_cert(subject, key, age = T.unsafe(nil), extensions = T.unsafe(nil), serial = T.unsafe(nil)); end + + def self.create_cert_email(email, key, age = T.unsafe(nil), extensions = T.unsafe(nil)); end + + def self.create_cert_self_signed(subject, key, age = T.unsafe(nil), extensions = T.unsafe(nil), serial = T.unsafe(nil)); end + + def self.create_key(length = T.unsafe(nil), algorithm = T.unsafe(nil)); end + + def self.email_to_name(email_address); end + + def self.re_sign(expired_certificate, private_key, age = T.unsafe(nil), extensions = T.unsafe(nil)); end + + def self.reset; end + + def self.sign(certificate, signing_key, signing_cert, age = T.unsafe(nil), extensions = T.unsafe(nil), serial = T.unsafe(nil)); end + + def self.trust_dir; end + + def self.trusted_certificates(&block); end + + def self.write(pemmable, path, permissions = T.unsafe(nil), passphrase = T.unsafe(nil), cipher = T.unsafe(nil)); end + + class DIGEST_ALGORITHM + def initialize(data = T.unsafe(nil)); end + + def self.digest(data); end + + def self.hexdigest(data); end + end + + class Exception + end + + class KEY_ALGORITHM + NO_PADDING = T.let(nil, T.untyped) + PKCS1_OAEP_PADDING = T.let(nil, T.untyped) + PKCS1_PADDING = T.let(nil, T.untyped) + SSLV23_PADDING = T.let(nil, T.untyped) + + def d; end + + def d=(d); end + + def dmp1; end + + def dmp1=(dmp1); end + + def dmq1; end + + def dmq1=(dmq1); end + + def e; end + + def e=(e); end + + def export(*_); end + + def initialize(*_); end + + def iqmp; end + + def iqmp=(iqmp); end + + def n; end + + def n=(n); end + + def p; end + + def p=(p); end + + def params; end + + def private?; end + + def private_decrypt(*_); end + + def private_encrypt(*_); end + + def public?; end + + def public_decrypt(*_); end + + def public_encrypt(*_); end + + def public_key; end + + def q; end + + def q=(q); end + + def set_crt_params(_, _1, _2); end + + def set_factors(_, _1); end + + def set_key(_, _1, _2); end + + def sign_pss(*_); end + + def to_der; end + + def to_pem(*_); end + + def to_s(*_); end + + def to_text; end + + def verify_pss(*_); end + + def self.generate(*_); end + end + + class Policy + include Gem::UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + + def check_cert(signer, issuer, time); end + + def check_chain(chain, time); end + + def check_data(public_key, digest, signature, data); end + + def check_key(signer, key); end + + def check_root(chain, time); end + + def check_trust(chain, digester, trust_dir); end + + def initialize(name, policy = T.unsafe(nil), opt = T.unsafe(nil)); end + + def name; end + + def only_signed; end + + def only_signed=(only_signed); end + + def only_trusted; end + + def only_trusted=(only_trusted); end + + def subject(certificate); end + + def verify(chain, key = T.unsafe(nil), digests = T.unsafe(nil), signatures = T.unsafe(nil), full_name = T.unsafe(nil)); end + + def verify_chain; end + + def verify_chain=(verify_chain); end + + def verify_data; end + + def verify_data=(verify_data); end + + def verify_root; end + + def verify_root=(verify_root); end + + def verify_signatures(spec, digests, signatures); end + + def verify_signer; end + + def verify_signer=(verify_signer); end + + def clean_text(text); end + + def format_text(text, wrap, indent = T.unsafe(nil)); end + + def levenshtein_distance(str1, str2); end + + def min3(a, b, c); end + + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + def ui; end + + def ui=(new_ui); end + + def use_ui(new_ui, &block); end + + def alert(statement, question = T.unsafe(nil)); end + + def alert_error(statement, question = T.unsafe(nil)); end + + def alert_warning(statement, question = T.unsafe(nil)); end + + def ask(question); end + + def ask_for_password(prompt); end + + def ask_yes_no(question, default = T.unsafe(nil)); end + + def choose_from_list(question, list); end + + def say(statement = T.unsafe(nil)); end + + def terminate_interaction(exit_code = T.unsafe(nil)); end + + def verbose(msg = T.unsafe(nil)); end + end + + class Signer + include Gem::UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + DEFAULT_OPTIONS = T.let(nil, T.untyped) + + def cert_chain; end + + def cert_chain=(cert_chain); end + + def digest_algorithm; end + + def digest_name; end + + def extract_name(cert); end + + def initialize(key, cert_chain, passphrase = T.unsafe(nil), options = T.unsafe(nil)); end + + def key; end + + def key=(key); end + + def load_cert_chain; end + + def options; end + + def re_sign_key(expiration_length: T.unsafe(nil)); end + + def sign(data); end + + def self.re_sign_cert(expired_cert, expired_cert_path, private_key); end + + def clean_text(text); end + + def format_text(text, wrap, indent = T.unsafe(nil)); end + + def levenshtein_distance(str1, str2); end + + def min3(a, b, c); end + + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + def ui; end + + def ui=(new_ui); end + + def use_ui(new_ui, &block); end + + def alert(statement, question = T.unsafe(nil)); end + + def alert_error(statement, question = T.unsafe(nil)); end + + def alert_warning(statement, question = T.unsafe(nil)); end + + def ask(question); end + + def ask_for_password(prompt); end + + def ask_yes_no(question, default = T.unsafe(nil)); end + + def choose_from_list(question, list); end + + def say(statement = T.unsafe(nil)); end + + def terminate_interaction(exit_code = T.unsafe(nil)); end + + def verbose(msg = T.unsafe(nil)); end + end + + class TrustDir + DEFAULT_PERMISSIONS = T.let(nil, T.untyped) + + def cert_path(certificate); end + + def dir; end + + def each_certificate; end + + def initialize(dir, permissions = T.unsafe(nil)); end + + def issuer_of(certificate); end + + def load_certificate(certificate_file); end + + def name_path(name); end + + def trust_cert(certificate); end + + def verify; end + end + end + + class SilentUI + def initialize; end + end + + class Source + include Comparable + FILES = T.let(nil, T.untyped) + + def ==(other); end + + def cache_dir(uri); end + + def dependency_resolver_set; end + + def download(spec, dir = T.unsafe(nil)); end + + def eql?(other); end + + def fetch_spec(name_tuple); end + + def initialize(uri); end + + def load_specs(type); end + + def pretty_print(q); end + + def update_cache?; end + + def uri; end + + class Git + def base_dir; end + + def cache; end + + def checkout; end + + def dir_shortref; end + + def download(full_spec, path); end + + def initialize(name, repository, reference, submodules = T.unsafe(nil)); end + + def install_dir; end + + def name; end + + def need_submodules; end + + def reference; end + + def remote; end + + def remote=(remote); end + + def repo_cache_dir; end + + def repository; end + + def rev_parse; end + + def root_dir; end + + def root_dir=(root_dir); end + + def specs; end + + def uri_hash; end + end + + class Installed + def download(spec, path); end + + def initialize; end + end + + class Local + def download(spec, cache_dir = T.unsafe(nil)); end + + def fetch_spec(name); end + + def find_gem(gem_name, version = T.unsafe(nil), prerelease = T.unsafe(nil)); end + + def initialize; end + end + + class Lock + def initialize(source); end + + def wrapped; end + end + + class SpecificFile + def fetch_spec(name); end + + def initialize(file); end + + def load_specs(*a); end + + def path; end + + def spec; end + end + + class Vendor + def initialize(path); end + end + end + + class SourceFetchProblem + def error; end + + def exception; end + + def initialize(source, error); end + + def source; end + + def wordy; end + end + + class SourceList + include Enumerable + Elem = type_member(fixed: T.untyped) + + def <<(obj); end + + def ==(other); end + + def clear; end + + def delete(source); end + + def each(&blk); end + + def each_source(&b); end + + def empty?; end + + def first; end + + def include?(other); end + + def replace(other); end + + def sources; end + + def to_a; end + + def to_ary; end + + def self.from(ary); end + end + + class SpecFetcher + include Gem::UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + + def available_specs(type); end + + def detect(type = T.unsafe(nil)); end + + def initialize(sources = T.unsafe(nil)); end + + def latest_specs; end + + def prerelease_specs; end + + def search_for_dependency(dependency, matching_platform = T.unsafe(nil)); end + + def sources; end + + def spec_for_dependency(dependency, matching_platform = T.unsafe(nil)); end + + def specs; end + + def suggest_gems_from_name(gem_name, type = T.unsafe(nil)); end + + def tuples_for(source, type, gracefully_ignore = T.unsafe(nil)); end + + def self.fetcher; end + + def self.fetcher=(fetcher); end + + def clean_text(text); end + + def format_text(text, wrap, indent = T.unsafe(nil)); end + + def levenshtein_distance(str1, str2); end + + def min3(a, b, c); end + + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + def ui; end + + def ui=(new_ui); end + + def use_ui(new_ui, &block); end + + def alert(statement, question = T.unsafe(nil)); end + + def alert_error(statement, question = T.unsafe(nil)); end + + def alert_warning(statement, question = T.unsafe(nil)); end + + def ask(question); end + + def ask_for_password(prompt); end + + def ask_yes_no(question, default = T.unsafe(nil)); end + + def choose_from_list(question, list); end + + def say(statement = T.unsafe(nil)); end + + def terminate_interaction(exit_code = T.unsafe(nil)); end + + def verbose(msg = T.unsafe(nil)); end + end + + class SpecificGemNotFoundException + def errors; end + + def initialize(name, version, errors = T.unsafe(nil)); end + + def name; end + + def version; end + end + + class Specification + include Bundler::MatchPlatform + include Bundler::GemHelpers + extend Gem::Deprecate + DateLike = T.let(nil, T.untyped) + DateTimeFormat = T.let(nil, T.untyped) + INITIALIZE_CODE_FOR_DEFAULTS = T.let(nil, T.untyped) + + def ==(other); end + + def _deprecated_default_executable; end + + def _deprecated_default_executable=(_deprecated_default_executable); end + + def _deprecated_has_rdoc; end + + def _deprecated_has_rdoc=(ignored); end + + def _deprecated_has_rdoc?(*args, &block); end + + def _dump(limit); end + + def abbreviate; end + + def activate; end + + def activate_dependencies; end + + def activated; end + + def activated=(activated); end + + def add_bindir(executables); end + + def add_dependency(gem, *requirements); end + + def add_development_dependency(gem, *requirements); end + + def add_runtime_dependency(gem, *requirements); end + + def add_self_to_load_path; end + + def author; end + + def author=(o); end + + def authors; end + + def authors=(value); end + + def autorequire; end + + def autorequire=(autorequire); end + + def bin_dir; end + + def bin_file(name); end + + def bindir; end + + def bindir=(bindir); end + + def build_args; end + + def build_extensions; end + + def build_info_dir; end + + def build_info_file; end + + def cache_dir; end + + def cache_file; end + + def cert_chain; end + + def cert_chain=(cert_chain); end + + def conficts_when_loaded_with?(list_of_specs); end + + def conflicts; end + + def date; end + + def date=(date); end + + def default_executable(*args, &block); end + + def default_executable=(*args, &block); end + + def default_value(name); end + + def dependencies; end + + def dependent_gems; end + + def dependent_specs; end + + def description; end + + def description=(str); end + + def development_dependencies; end + + def doc_dir(type = T.unsafe(nil)); end + + def email; end + + def email=(email); end + + def encode_with(coder); end + + def eql?(other); end + + def executable; end + + def executable=(o); end + + def executables; end + + def executables=(value); end + + def extensions; end + + def extensions=(extensions); end + + def extra_rdoc_files; end + + def extra_rdoc_files=(files); end + + def file_name; end + + def files; end + + def files=(files); end + + def for_cache; end + + def git_version; end + + def groups; end + + def has_conflicts?; end + + def has_rdoc(*args, &block); end + + def has_rdoc=(*args, &block); end + + def has_rdoc?(*args, &block); end + + def has_test_suite?; end + + def has_unit_tests?; end + + def homepage; end + + def homepage=(homepage); end + + def init_with(coder); end + + def initialize(name = T.unsafe(nil), version = T.unsafe(nil)); end + + def installed_by_version; end + + def installed_by_version=(version); end + + def keep_only_files_and_directories; end + + def lib_files; end + + def license; end + + def license=(o); end + + def licenses; end + + def licenses=(licenses); end + + def load_paths; end + + def location; end + + def location=(location); end + + def mark_version; end + + def metadata; end + + def metadata=(metadata); end + + def method_missing(sym, *a, &b); end + + def missing_extensions?; end + + def name=(name); end + + def name_tuple; end + + def nondevelopment_dependencies; end + + def normalize; end + + def original_name; end + + def original_platform; end + + def original_platform=(original_platform); end + + def platform=(platform); end + + def post_install_message; end + + def post_install_message=(post_install_message); end + + def pretty_print(q); end + + def raise_if_conflicts; end + + def rdoc_options; end + + def rdoc_options=(options); end + + def relative_loaded_from; end + + def relative_loaded_from=(relative_loaded_from); end + + def remote; end + + def remote=(remote); end + + def require_path; end + + def require_path=(path); end + + def require_paths=(val); end + + def required_ruby_version; end + + def required_ruby_version=(req); end + + def required_rubygems_version; end + + def required_rubygems_version=(req); end + + def requirements; end + + def requirements=(req); end + + def reset_nil_attributes_to_default; end + + def rg_extension_dir; end + + def rg_full_gem_path; end + + def rg_loaded_from; end + + def ri_dir; end + + def rubyforge_project=(rubyforge_project); end + + def rubygems_version; end + + def rubygems_version=(rubygems_version); end + + def runtime_dependencies; end + + def sanitize; end + + def sanitize_string(string); end + + def satisfies_requirement?(dependency); end + + def signing_key; end + + def signing_key=(signing_key); end + + def sort_obj; end + + def source; end + + def source=(source); end + + def spec_dir; end + + def spec_file; end + + def spec_name; end + + def specification_version; end + + def specification_version=(specification_version); end + + def summary; end + + def summary=(str); end + + def test_file; end + + def test_file=(file); end + + def test_files; end + + def test_files=(files); end + + def to_gemfile(path = T.unsafe(nil)); end + + def to_ruby; end + + def to_ruby_for_cache; end + + def to_yaml(opts = T.unsafe(nil)); end + + def traverse(trail = T.unsafe(nil), visited = T.unsafe(nil), &block); end + + def validate(packaging = T.unsafe(nil), strict = T.unsafe(nil)); end + + def validate_dependencies; end + + def validate_metadata; end + + def validate_permissions; end + + def version=(version); end + + def yaml_initialize(tag, vals); end + + def self._all; end + + def self._clear_load_cache; end + + def self._latest_specs(specs, prerelease = T.unsafe(nil)); end + + def self._load(str); end + + def self._resort!(specs); end + + def self.add_spec(spec); end + + def self.add_specs(*specs); end + + def self.all; end + + def self.all=(specs); end + + def self.all_names; end + + def self.array_attributes; end + + def self.attribute_names; end + + def self.dirs; end + + def self.dirs=(dirs); end + + def self.each(&blk); end + + def self.each_gemspec(dirs); end + + def self.each_spec(dirs); end + + def self.find_active_stub_by_path(path); end + + def self.find_all_by_full_name(full_name); end + + def self.find_all_by_name(name, *requirements); end + + def self.find_by_name(name, *requirements); end + + def self.find_by_path(path); end + + def self.find_in_unresolved(path); end + + def self.find_in_unresolved_tree(path); end + + def self.find_inactive_by_path(path); end + + def self.from_yaml(input); end + + def self.latest_specs(prerelease = T.unsafe(nil)); end + + def self.load(file); end + + def self.load_defaults; end + + def self.non_nil_attributes; end + + def self.normalize_yaml_input(input); end + + def self.outdated; end + + def self.outdated_and_latest_version; end + + def self.remove_spec(spec); end + + def self.required_attribute?(name); end + + def self.required_attributes; end + + def self.reset; end + + def self.stubs; end + + def self.stubs_for(name); end + + def self.unresolved_deps; end + end + + class SpecificationPolicy + HOMEPAGE_URI_PATTERN = T.let(nil, T.untyped) + LAZY = T.let(nil, T.untyped) + LAZY_PATTERN = T.let(nil, T.untyped) + METADATA_LINK_KEYS = T.let(nil, T.untyped) + SPECIAL_CHARACTERS = T.let(nil, T.untyped) + VALID_NAME_PATTERN = T.let(nil, T.untyped) + VALID_URI_PATTERN = T.let(nil, T.untyped) + + def initialize(specification); end + + def packaging; end + + def packaging=(packaging); end + + def validate(strict = T.unsafe(nil)); end + + def validate_dependencies; end + + def validate_metadata; end + + def validate_permissions; end + end + + class StreamUI + extend Gem::Deprecate + + def _deprecated_debug(statement); end + + def _gets_noecho; end + + def alert(statement, question = T.unsafe(nil)); end + + def alert_error(statement, question = T.unsafe(nil)); end + + def alert_warning(statement, question = T.unsafe(nil)); end + + def ask(question); end + + def ask_for_password(question); end + + def ask_yes_no(question, default = T.unsafe(nil)); end + + def backtrace(exception); end + + def choose_from_list(question, list); end + + def close; end + + def debug(*args, &block); end + + def download_reporter(*args); end + + def errs; end + + def initialize(in_stream, out_stream, err_stream = T.unsafe(nil), usetty = T.unsafe(nil)); end + + def ins; end + + def outs; end + + def progress_reporter(*args); end + + def require_io_console; end + + def say(statement = T.unsafe(nil)); end + + def terminate_interaction(status = T.unsafe(nil)); end + + def tty?; end + end + + class StubSpecification + def build_extensions; end + + def extensions; end + + def initialize(filename, base_dir, gems_dir, default_gem); end + + def missing_extensions?; end + + def valid?; end + + def self.default_gemspec_stub(filename, base_dir, gems_dir); end + + def self.gemspec_stub(filename, base_dir, gems_dir); end + + class StubLine + def extensions; end + + def full_name; end + + def initialize(data, extensions); end + + def name; end + + def platform; end + + def require_paths; end + + def version; end + end + end + + class SystemExitException + def exit_code; end + + def exit_code=(exit_code); end + + def initialize(exit_code); end + end + + module Text + def clean_text(text); end + + def format_text(text, wrap, indent = T.unsafe(nil)); end + + def levenshtein_distance(str1, str2); end + + def min3(a, b, c); end + + def truncate_text(text, description, max_length = T.unsafe(nil)); end + end + + class UninstallError + def spec; end + + def spec=(spec); end + end + + class UnsatisfiableDependencyError + def dependency; end + + def errors; end + + def errors=(errors); end + + def initialize(dep, platform_mismatch = T.unsafe(nil)); end + + def name; end + + def version; end + end + + class UriFormatter + def escape; end + + def initialize(uri); end + + def normalize; end + + def unescape; end + + def uri; end + end + + module UserInteraction + include Gem::DefaultUserInteraction + include Gem::Text + + def alert(statement, question = T.unsafe(nil)); end + + def alert_error(statement, question = T.unsafe(nil)); end + + def alert_warning(statement, question = T.unsafe(nil)); end + + def ask(question); end + + def ask_for_password(prompt); end + + def ask_yes_no(question, default = T.unsafe(nil)); end + + def choose_from_list(question, list); end + + def say(statement = T.unsafe(nil)); end + + def terminate_interaction(exit_code = T.unsafe(nil)); end + + def verbose(msg = T.unsafe(nil)); end + + def clean_text(text); end + + def format_text(text, wrap, indent = T.unsafe(nil)); end + + def levenshtein_distance(str1, str2); end + + def min3(a, b, c); end + + def truncate_text(text, description, max_length = T.unsafe(nil)); end + + def ui; end + + def ui=(new_ui); end + + def use_ui(new_ui, &block); end + end + + module Util + def self.glob_files_in_dir(glob, base_path); end + + def self.gunzip(data); end + + def self.gzip(data); end + + def self.inflate(data); end + + def self.popen(*command); end + + def self.silent_system(*command); end + + def self.traverse_parents(directory, &block); end + end + + class Version + def _segments; end + + def _split_segments; end + + def _version; end + + def approximate_recommendation; end + + def bump; end + + def canonical_segments; end + + def encode_with(coder); end + + def eql?(other); end + + def init_with(coder); end + + def marshal_dump; end + + def marshal_load(array); end + + def prerelease?; end + + def pretty_print(q); end + + def release; end + + def segments; end + + def to_yaml_properties; end + + def version; end + + def yaml_initialize(tag, map); end + + def self.correct?(version); end + + def self.create(input); end + + def self.new(version); end + end +end + +Gem::UnsatisfiableDepedencyError = Gem::UnsatisfiableDependencyError +Gem::Ext::ExtConfBuilder::FileEntry = FileUtils::Entry_ +Gem::Version::Requirement = Gem::Requirement +Gem::Resolver::DependencyConflict = Gem::Resolver::Conflict diff --git a/sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi b/sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi new file mode 100644 index 0000000..22474d7 --- /dev/null +++ b/sorbet/rbi/sorbet-typed/lib/ruby/all/open3.rbi @@ -0,0 +1,111 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi sorbet-typed +# +# If you would like to make changes to this file, great! Please upstream any changes you make here: +# +# https://github.com/sorbet/sorbet-typed/edit/master/lib/ruby/all/open3.rbi +# +# typed: strong + +module Open3 + sig do + params( + cmd: T.any(String, T::Array[String]), + opts: T.untyped, + block: T.nilable(T.proc.params(stdin: IO, stdout: IO, stderr: IO, wait_thr: Process::Waiter).void) + ).returns([IO, IO, IO, Process::Waiter]) + end + def self.popen3(*cmd, **opts, &block); end + + sig do + params( + cmd: T.any(String, T::Array[String]), + opts: T.untyped, + block: T.nilable(T.proc.params(stdin: IO, stdout: IO, wait_thr: Process::Waiter).void) + ).returns([IO, IO, Process::Waiter]) + end + def self.popen2(*cmd, **opts, &block); end + + sig do + params( + cmd: T.any(String, T::Array[String]), + opts: T.untyped, + block: T.nilable(T.proc.params(stdin: IO, stdout_and_stderr: IO, wait_thr: Process::Waiter).void) + ).returns([IO, IO, Process::Waiter]) + end + def self.popen2e(*cmd, **opts, &block); end + + sig do + params( + cmd: T.any(String, T::Array[String]), + stdin_data: T.nilable(String), + binmode: T.any(FalseClass, TrueClass), + opts: T::Hash[Symbol, T.untyped] + ).returns([String, String, Process::Status]) + end + def self.capture3(*cmd, stdin_data: '', binmode: false, **opts); end + + sig do + params( + cmd: T.any(String, T::Array[String]), + stdin_data: T.nilable(String), + binmode: T.any(FalseClass, TrueClass), + opts: T::Hash[Symbol, T.untyped] + ).returns([String, Process::Status]) + end + def self.capture2(*cmd, stdin_data: nil, binmode: false, **opts); end + + sig do + params( + cmd: T.any(String, T::Array[String]), + stdin_data: T.nilable(String), + binmode: T.any(FalseClass, TrueClass), + opts: T::Hash[Symbol, T.untyped] + ).returns([String, Process::Status]) + end + def self.capture2e(*cmd, stdin_data: nil, binmode: false, **opts); end + + sig do + params( + cmds: T.any(String, T::Array[String]), + opts: T.untyped, + block: T.nilable(T.proc.params(first_stdin: IO, last_stdout: IO, wait_threads: T::Array[Process::Waiter]).void) + ).returns([IO, IO, T::Array[Process::Waiter]]) + end + def self.pipeline_rw(*cmds, **opts, &block); end + + sig do + params( + cmds: T.any(String, T::Array[String]), + opts: T.untyped, + block: T.nilable(T.proc.params(last_stdout: IO, wait_threads: T::Array[Process::Waiter]).void) + ).returns([IO, T::Array[Process::Waiter]]) + end + def self.pipeline_r(*cmds, **opts, &block); end + + sig do + params( + cmds: T.any(String, T::Array[String]), + opts: T.untyped, + block: T.nilable(T.proc.params(first_stdin: IO, wait_threads: T::Array[Process::Waiter]).void) + ).returns([IO, T::Array[Process::Waiter]]) + end + def self.pipeline_w(*cmds, **opts, &block); end + + sig do + params( + cmds: T.any(String, T::Array[String]), + opts: T.untyped, + block: T.nilable(T.proc.params(wait_threads: T::Array[Process::Waiter]).void) + ).returns(T::Array[Process::Waiter]) + end + def self.pipeline_start(*cmds, **opts, &block); end + + sig do + params( + cmds: T.any(String, T::Array[String]), + opts: T.untyped + ).returns(T::Array[Process::Status]) + end + def self.pipeline(*cmds, **opts); end +end diff --git a/sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi b/sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi new file mode 100644 index 0000000..487e803 --- /dev/null +++ b/sorbet/rbi/sorbet-typed/lib/ruby/all/resolv.rbi @@ -0,0 +1,543 @@ +# This file is autogenerated. Do not edit it by hand. Regenerate it with: +# srb rbi sorbet-typed +# +# If you would like to make changes to this file, great! Please upstream any changes you make here: +# +# https://github.com/sorbet/sorbet-typed/edit/master/lib/ruby/all/resolv.rbi +# +# typed: strong + +class Resolv + sig { params(name: String).returns(String) } + def self.getaddress(name); end + + sig { params(name: String).returns(T::Array[String]) } + def self.getaddresses(name); end + + sig { params(name: String, block: T.proc.params(address: String).void).void } + def self.each_address(name, &block); end + + sig { params(address: String).returns(String) } + def self.getname(address); end + + sig { params(address: String).returns(T::Array[String]) } + def self.getnames(address); end + + sig { params(address: String, proc: T.proc.params(name: String).void).void } + def self.each_name(address, &proc); end + + sig { params(resolvers: [Hosts, DNS]).void } + def initialize(resolvers=[Hosts.new, DNS.new]); end + + sig { params(name: String).returns(String) } + def getaddress(name); end + + sig { params(name: String).returns(T::Array[String]) } + def getaddresses(name); end + + sig { params(name: String, block: T.proc.params(address: String).void).void } + def each_address(name, &block); end + + sig { params(address: String).returns(String) } + def getname(address); end + + sig { params(address: String).returns(T::Array[String]) } + def getnames(address); end + + sig { params(address: String, proc: T.proc.params(name: String).void).void } + def each_name(address, &proc); end + + class ResolvError < StandardError; end + class ResolvTimeout < Timeout::Error; end + + class Hosts + DefaultFileName = T.let(T.unsafe(nil), String) + + sig { params(filename: String).void } + def initialize(filename = DefaultFileName); end + + sig { params(name: String).returns(String) } + def getaddress(name); end + + sig { params(name: String).returns(T::Array[String]) } + def getaddresses(name); end + + sig { params(name: String, block: T.proc.params(address: String).void).void } + def each_address(name, &block); end + + sig { params(address: String).returns(String) } + def getname(address); end + + sig { params(address: String).returns(T::Array[String]) } + def getnames(address); end + + sig { params(address: String, proc: T.proc.params(name: String).void).void } + def each_name(address, &proc); end + end + + class DNS + Port = T.let(T.unsafe(nil), Integer) + + UDPSize = T.let(T.unsafe(nil), Integer) + + sig do + params( + config_info: T.any( + NilClass, + String, + { nameserver: T.any(String, T::Array[String]), search: T::Array[String], ndots: Integer }, + { nameserver_port: T::Array[[String, Integer]], search: T::Array[String], ndots: Integer } + ) + ).returns(Resolv::DNS) + end + def self.open(config_info = nil); end + + sig do + params( + config_info: T.any( + NilClass, + String, + { nameserver: T.any(String, T::Array[String]), search: T::Array[String], ndots: Integer }, + { nameserver_port: T::Array[[String, Integer]], search: T::Array[String], ndots: Integer } + ) + ).void + end + def initialize(config_info = nil); end + + sig { params(values: T.any(NilClass, Integer, T::Array[Integer])).void } + def timeouts=(values); end + + sig { void } + def close; end + + sig { params(name: String).returns(String) } + def getaddress(name); end + + sig { params(name: String).returns(T::Array[String]) } + def getaddresses(name); end + + sig { params(name: String, block: T.proc.params(address: String).void).void } + def each_address(name, &block); end + + sig { params(address: String).returns(String) } + def getname(address); end + + sig { params(address: String).returns(T::Array[String]) } + def getnames(address); end + + sig { params(address: String, proc: T.proc.params(name: String).void).void } + def each_name(address, &proc); end + + sig do + params( + name: T.any(String, Resolv::DNS::Name), + typeclass: T.class_of(Resolv::DNS::Resource) + ).returns(Resolv::DNS::Resource) + end + def getresource(name, typeclass); end + + sig do + params( + name: T.any(String, Resolv::DNS::Name), + typeclass: T.class_of(Resolv::DNS::Resource) + ).returns(T::Array[Resolv::DNS::Resource]) + end + def getresources(name, typeclass); end + + sig do + params( + name: T.any(String, Resolv::DNS::Name), + typeclass: T.class_of(Resolv::DNS::Resource), + proc: T.proc.params(resource: Resolv::DNS::Resource).void + ).void + end + def each_resource(name, typeclass, &proc); end + + class DecodeError < StandardError; end + class EncodeError < StandardError; end + + class Name + sig { params(arg: T.any(String, Resolv::DNS::Name)).returns(Resolv::DNS::Name) } + def self.create(arg); end + + sig { params(labels: T::Array[String], absolute: T.any(FalseClass, TrueClass)).void } + def initialize(labels, absolute=true); end + + sig { returns(T.any(FalseClass, TrueClass)) } + def absolute?; end + + sig { params(other: Resolv::DNS::Name).returns(T.any(FalseClass, TrueClass)) } + def subdomain_of?(other); end + end + + class Query; end + + class Resource < Query + sig { returns(T.nilable(Integer)) } + attr_reader :ttl + + sig { void } + def initialize + @ttl = T.let(T.unsafe(nil), T.nilable(Integer)) + end + + class Generic < Resource + sig { params(data: T.untyped).void } + def initialize(data) + @data = T.let(T.unsafe(nil), T.untyped) + end + + sig { returns(T.untyped) } + attr_reader :data + end + + class DomainName < Resource + sig { params(name: String).void } + def initialize(name) + @name = T.let(T.unsafe(nil), String) + end + + sig { returns(String) } + attr_reader :name + end + + class NS < DomainName; end + + class CNAME < DomainName; end + + class SOA < Resource + sig do + params( + mname: String, + rname: String, + serial: Integer, + refresh: Integer, + retry_: Integer, + expire: Integer, + minimum: Integer + ).void + end + def initialize(mname, rname, serial, refresh, retry_, expire, minimum) + @mname = T.let(T.unsafe(nil), String) + @rname = T.let(T.unsafe(nil), String) + @serial = T.let(T.unsafe(nil), Integer) + @refresh = T.let(T.unsafe(nil), Integer) + @retry = T.let(T.unsafe(nil), Integer) + @expire = T.let(T.unsafe(nil), Integer) + @minimum = T.let(T.unsafe(nil), Integer) + end + + sig { returns(String) } + attr_reader :mname + + sig { returns(String) } + attr_reader :rname + + sig { returns(Integer) } + attr_reader :serial + + sig { returns(Integer) } + attr_reader :refresh + + sig { returns(Integer) } + attr_reader :retry + + sig { returns(Integer) } + attr_reader :expire + + sig { returns(Integer) } + attr_reader :minimum + end + + class PTR < DomainName; end + + class HINFO < Resource + sig { params(cpu: String, os: String).void } + def initialize(cpu, os) + @cpu = T.let(T.unsafe(nil), String) + @os = T.let(T.unsafe(nil), String) + end + + sig { returns(String) } + attr_reader :cpu + + sig { returns(String) } + attr_reader :os + end + + class MINFO < Resource + sig { params(rmailbx: String, emailbx: String).void } + def initialize(rmailbx, emailbx) + @rmailbx = T.let(T.unsafe(nil), String) + @emailbx = T.let(T.unsafe(nil), String) + end + + sig { returns(String) } + attr_reader :rmailbx + + sig { returns(String) } + attr_reader :emailbx + end + + class MX < Resource + sig { params(preference: Integer, exchange: String).void } + def initialize(preference, exchange) + @preference = T.let(T.unsafe(nil), Integer) + @exchange = T.let(T.unsafe(nil), String) + end + + sig { returns(Integer) } + attr_reader :preference + + sig { returns(String) } + attr_reader :exchange + end + + class TXT < Resource + sig { params(first_string: String, rest_strings: String).void } + def initialize(first_string, *rest_strings) + @strings = T.let(T.unsafe(nil), T::Array[String]) + end + + sig { returns(T::Array[String]) } + attr_reader :strings + + sig { returns(String) } + def data; end + end + + class LOC < Resource + sig do + params( + version: String, + ssize: T.any(String, Resolv::LOC::Size), + hprecision: T.any(String, Resolv::LOC::Size), + vprecision: T.any(String, Resolv::LOC::Size), + latitude: T.any(String, Resolv::LOC::Coord), + longitude: T.any(String, Resolv::LOC::Coord), + altitude: T.any(String, Resolv::LOC::Alt) + ).void + end + def initialize(version, ssize, hprecision, vprecision, latitude, longitude, altitude) + @version = T.let(T.unsafe(nil), String) + @ssize = T.let(T.unsafe(nil), Resolv::LOC::Size) + @hprecision = T.let(T.unsafe(nil), Resolv::LOC::Size) + @vprecision = T.let(T.unsafe(nil), Resolv::LOC::Size) + @latitude = T.let(T.unsafe(nil), Resolv::LOC::Coord) + @longitude = T.let(T.unsafe(nil), Resolv::LOC::Coord) + @altitude = T.let(T.unsafe(nil), Resolv::LOC::Alt) + end + + sig { returns(String) } + attr_reader :version + + sig { returns(Resolv::LOC::Size) } + attr_reader :ssize + + sig { returns(Resolv::LOC::Size) } + attr_reader :hprecision + + sig { returns(Resolv::LOC::Size) } + attr_reader :vprecision + + sig { returns(Resolv::LOC::Coord) } + attr_reader :latitude + + sig { returns(Resolv::LOC::Coord) } + attr_reader :longitude + + sig { returns(Resolv::LOC::Alt) } + attr_reader :altitude + end + + class ANY < Query; end + + module IN + class A < Resource + sig { params(address: String).void } + def initialize(address) + @address = T.let(T.unsafe(nil), Resolv::IPv4) + end + + sig { returns(Resolv::IPv4) } + attr_reader :address + end + + class WKS < Resource + sig { params(address: String, protocol: Integer, bitmap: String).void } + def initialize(address, protocol, bitmap) + @address = T.let(T.unsafe(nil), Resolv::IPv4) + @protocol = T.let(T.unsafe(nil), Integer) + @bitmap = T.let(T.unsafe(nil), String) + end + + sig { returns(Resolv::IPv4) } + attr_reader :address + + sig { returns(Integer) } + attr_reader :protocol + + sig { returns(String) } + attr_reader :bitmap + end + + class AAAA < Resource + sig { params(address: String).void } + def initialize(address) + @address = T.let(T.unsafe(nil), Resolv::IPv6) + end + + sig { returns(Resolv::IPv6) } + attr_reader :address + end + + class SRV < Resource + # Create a SRV resource record. + # + # See the documentation for #priority, #weight, #port and #target + # for +priority+, +weight+, +port and +target+ respectively. + + sig do + params( + priority: T.any(Integer, String), + weight: T.any(Integer, String), + port: T.any(Integer, String), + target: T.any(String, Resolv::DNS::Name) + ).void + end + def initialize(priority, weight, port, target) + @priority = T.let(T.unsafe(nil), Integer) + @weight = T.let(T.unsafe(nil), Integer) + @port = T.let(T.unsafe(nil), Integer) + @target = T.let(T.unsafe(nil), Resolv::DNS::Name) + end + + sig { returns(Integer) } + attr_reader :priority + + sig { returns(Integer) } + attr_reader :weight + + sig { returns(Integer) } + attr_reader :port + + sig { returns(Resolv::DNS::Name) } + attr_reader :target + end + end + end + end + + class IPv4 + Regex256 = T.let(T.unsafe(nil), Regexp) + Regex = T.let(T.unsafe(nil), Regexp) + + sig { params(arg: T.any(String, Resolv::IPv4)).returns(Resolv::IPv4) } + def self.create(arg); end + + sig { params(address: String).void } + def initialize(address) + @address = T.let(T.unsafe(nil), String) + end + + sig { returns(String) } + attr_reader :address + + sig { returns(DNS::Name) } + def to_name; end + end + + class IPv6 + Regex_8Hex = T.let(T.unsafe(nil), Regexp) + Regex_CompressedHex = T.let(T.unsafe(nil), Regexp) + Regex_6Hex4Dec = T.let(T.unsafe(nil), Regexp) + Regex_CompressedHex4Dec = T.let(T.unsafe(nil), Regexp) + Regex = T.let(T.unsafe(nil), Regexp) + + sig { params(arg: T.any(String, Resolv::IPv6)).returns(Resolv::IPv6) } + def self.create(arg); end + + sig { params(address: String).void } + def initialize(address) + @address = T.let(T.unsafe(nil), String) + end + + sig { returns(String) } + attr_reader :address + + sig { returns(DNS::Name) } + def to_name; end + end + + class MDNS < DNS + Port = T.let(T.unsafe(nil), Integer) + AddressV4 = T.let(T.unsafe(nil), String) + AddressV6 = T.let(T.unsafe(nil), String) + Addresses = T.let(T.unsafe(nil), [[String, Integer], [String, Integer]]) + + sig do + params( + config_info: T.any( + NilClass, + { nameserver: T.any(String, T::Array[String]), search: T::Array[String], ndots: Integer }, + { nameserver_port: T::Array[[String, Integer]], search: T::Array[String], ndots: Integer } + ) + ).void + end + def initialize(config_info = nil); end + end + + module LOC + class Size + Regex = T.let(T.unsafe(nil), Regexp) + + sig { params(arg: T.any(String, Resolv::LOC::Size)).returns(Resolv::LOC::Size) } + def self.create(arg); end + + sig { params(scalar: String).void } + def initialize(scalar) + @scalar = T.let(T.unsafe(nil), String) + end + + sig { returns(String) } + attr_reader :scalar + end + + class Coord + Regex = T.let(T.unsafe(nil), Regexp) + + sig { params(arg: T.any(String, Resolv::LOC::Coord)).returns(Resolv::LOC::Coord) } + def self.create(arg); end + + sig { params(coordinates: String, orientation: T.enum(%w[lat lon])).void } + def initialize(coordinates, orientation) + @coordinates = T.let(T.unsafe(nil), String) + @orientation = T.let(T.unsafe(nil), T.enum(%w[lat lon])) + end + + sig { returns(String) } + attr_reader :coordinates + + sig { returns(T.enum(%w[lat lon])) } + attr_reader :orientation + end + + class Alt + Regex = T.let(T.unsafe(nil), Regexp) + + sig { params(arg: T.any(String, Resolv::LOC::Alt)).returns(Resolv::LOC::Alt) } + def self.create(arg); end + + sig { params(altitude: String).void } + def initialize(altitude) + @altitude = T.let(T.unsafe(nil), String) + end + + sig { returns(String) } + attr_reader :altitude + end + end + + DefaultResolver = T.let(T.unsafe(nil), Resolv) + AddressRegex = T.let(T.unsafe(nil), Regexp) +end diff --git a/spec/daemon_spec.rb b/spec/daemon_spec.rb index fb3ff5d..9b6c8a4 100644 --- a/spec/daemon_spec.rb +++ b/spec/daemon_spec.rb @@ -1,3 +1,4 @@ +# typed: false require 'spec_helper' describe Dyndnsd::Daemon do diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb index e766e4f..d5da226 100644 --- a/spec/spec_helper.rb +++ b/spec/spec_helper.rb @@ -1,3 +1,4 @@ +# typed: strong require 'rubygems' require 'bundler/setup' diff --git a/spec/support/dummy_database.rb b/spec/support/dummy_database.rb index b67a96d..45fb0da 100644 --- a/spec/support/dummy_database.rb +++ b/spec/support/dummy_database.rb @@ -1,3 +1,4 @@ +# typed: true require 'forwardable' diff --git a/spec/support/dummy_updater.rb b/spec/support/dummy_updater.rb index ca33cc4..926a6c8 100644 --- a/spec/support/dummy_updater.rb +++ b/spec/support/dummy_updater.rb @@ -1,3 +1,4 @@ +# typed: true module Dyndnsd module Updater