From 09f5a46218ca60db91ec68ec7586825d5c63b13e Mon Sep 17 00:00:00 2001 From: Douglas Eichelberger Date: Sun, 4 Feb 2024 05:44:33 -0800 Subject: [PATCH] rm hidden.rbi --- .../sorbet/rbi/hidden-definitions/hidden.rbi | 9623 ----------------- 1 file changed, 9623 deletions(-) delete mode 100644 Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi diff --git a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi b/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi deleted file mode 100644 index ca3d0b349b..0000000000 --- a/Library/Homebrew/sorbet/rbi/hidden-definitions/hidden.rbi +++ /dev/null @@ -1,9623 +0,0 @@ -# This file is autogenerated. Do not edit it by hand. Regenerate it with: -# srb rbi hidden-definitions - -# typed: autogenerated - -class AbstractCoreTap - extend ::T::Private::Abstract::Hooks -end - -class Addrinfo - def connect_internal(local_addrinfo, timeout=T.unsafe(nil)); end -end - -class Array - include ::JSON::Ext::Generator::GeneratorMethods::Array - def abbrev(pattern=T.unsafe(nil)); end - - def deconstruct(); end - - def to_h(); end -end - -class Array - def self.try_convert(arg); end -end - -module Attrable - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class BasicObject - def as_null_object(); end - - def null_object?(); end - - def received_message?(message, *args, &block); end - - def should(matcher=T.unsafe(nil), message=T.unsafe(nil), &block); end - - def should_not(matcher=T.unsafe(nil), message=T.unsafe(nil), &block); end - - def should_not_receive(message, &block); end - - def should_receive(message, opts=T.unsafe(nil), &block); end - - def stub(message_or_hash, opts=T.unsafe(nil), &block); end - - def stub_chain(*chain, &blk); end - - def unstub(message); end -end - -BasicObject::BasicObject = BasicObject - -class Benchmark::Job - def initialize(width); end -end - -class Benchmark::Report - def initialize(width=T.unsafe(nil), format=T.unsafe(nil)); end -end - -class Benchmark::Tms - def to_a(); end - - def to_h(); end -end - -class BigDecimal - def clone(); end - - def n_significant_digits(); end - - def precision(); end - - def precision_scale(); end - - def scale(); end - VERSION = ::T.let(nil, ::T.untyped) -end - -class BigDecimal - def self.interpret_loosely(arg); end -end - -class BinData::Int32be -end - -class BinData::Int32be -end - -class BinData::Int32le -end - -class BinData::Int32le -end - -class BinData::Int64be -end - -class BinData::Int64be -end - -class BinData::Int64le -end - -class BinData::Int64le -end - -class BinData::Uint16be -end - -class BinData::Uint16be -end - -class BinData::Uint16le -end - -class BinData::Uint16le -end - -class BinData::Uint32be -end - -class BinData::Uint32be -end - -class BinData::Uint32le -end - -class BinData::Uint32le -end - -class BinData::Uint64be -end - -class BinData::Uint64be -end - -class BinData::Uint64le -end - -class BinData::Uint64le -end - -class Binding - def clone(); end - - def irb(); end -end - -module BuildEnvironment::DSL - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Bundler::APIResponseInvalidDependenciesError - def status_code(); end -end - -class Bundler::APIResponseInvalidDependenciesError -end - -class Bundler::CurrentRuby - def jruby_30?(); end - - def jruby_31?(); end - - def jruby_32?(); end - - def jruby_33?(); end - - def jruby_3?(); end - - def maglev_30?(); end - - def maglev_31?(); end - - def maglev_32?(); end - - def maglev_33?(); end - - def maglev_3?(); end - - def mingw_30?(); end - - def mingw_31?(); end - - def mingw_32?(); end - - def mingw_33?(); end - - def mingw_3?(); end - - def mri_30?(); end - - def mri_31?(); end - - def mri_32?(); end - - def mri_33?(); end - - def mri_3?(); end - - def mswin64_30?(); end - - def mswin64_31?(); end - - def mswin64_32?(); end - - def mswin64_33?(); end - - def mswin64_3?(); end - - def mswin_30?(); end - - def mswin_31?(); end - - def mswin_32?(); end - - def mswin_33?(); end - - def mswin_3?(); end - - def on_30?(); end - - def on_31?(); end - - def on_32?(); end - - def on_33?(); end - - def on_3?(); end - - def rbx_30?(); end - - def rbx_31?(); end - - def rbx_32?(); end - - def rbx_33?(); end - - def rbx_3?(); end - - def ruby_30?(); end - - def ruby_31?(); end - - def ruby_32?(); end - - def ruby_33?(); end - - def ruby_3?(); end - - def truffleruby_30?(); end - - def truffleruby_31?(); end - - def truffleruby_32?(); end - - def truffleruby_33?(); end - - def truffleruby_3?(); end - - def windows?(); end - - def windows_18?(); end - - def windows_19?(); end - - def windows_1?(); end - - def windows_20?(); end - - def windows_21?(); end - - def windows_22?(); end - - def windows_23?(); end - - def windows_24?(); end - - def windows_25?(); end - - def windows_26?(); end - - def windows_27?(); end - - def windows_2?(); end - - def windows_30?(); end - - def windows_31?(); end - - def windows_32?(); end - - def windows_33?(); end - - def windows_3?(); end - - def x64_mingw_30?(); end - - def x64_mingw_31?(); end - - def x64_mingw_32?(); end - - def x64_mingw_33?(); end - - def x64_mingw_3?(); end -end - -class Bundler::Definition - def bundler_version_to_lock(); end - - def current_locked_dependencies(); end - - def deleted_deps(); end - - def dependencies_for(groups); end - - def filter_relevant(dependencies); end - - def locked_dependencies(); end - - def most_specific_locked_platform(); end - - def new_deps(); end - - def no_resolve_needed?(); end - - def requested_dependencies(); end - - def resolution_mode=(options); end - - def resolve_only_locally!(); end - - def setup_sources_for_resolve(); end -end - -class Bundler::Definition - def self.no_lock(); end - - def self.no_lock=(no_lock); end -end - -class Bundler::Dependency - def branch(); end - - def expanded_platforms(); end - - def git(); end - - def github(); end - - def path(); end - - def ref(); end - ALL_RUBY_VERSIONS = ::T.let(nil, ::T.untyped) -end - -Bundler::Deprecate = Gem::Deprecate - -module Bundler::Digest - SHA1_MASK = ::T.let(nil, ::T.untyped) - SHA1_WORDS = ::T.let(nil, ::T.untyped) -end - -module Bundler::Digest - def self.sha1(string); end -end - -class Bundler::DirectoryRemovalError - def initialize(orig_exception, msg); end - - def status_code(); end -end - -class Bundler::DirectoryRemovalError -end - -class Bundler::Dsl - def check_primary_source_safety(); end - GITHUB_PULL_REQUEST_URL = ::T.let(nil, ::T.untyped) -end - -class Bundler::EndpointSpecification - include ::Bundler::MatchRemoteMetadata - include ::Bundler::FetchMetadata -end - -class Bundler::Env -end - -class Bundler::Env - def self.environment(); end - - def self.report(options=T.unsafe(nil)); end - - def self.write(io); end -end - -class Bundler::EnvironmentPreserver - def replace_with_backup(); end -end - -class Bundler::EnvironmentPreserver - def self.env_to_hash(env); end - - def self.from_env(); end -end - -module Bundler::FetchMetadata - def matches_current_ruby?(); end - - def matches_current_rubygems?(); end -end - -module Bundler::FetchMetadata -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 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.[](*arg); end - - def self.keyword_init?(); 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 specs(_gem_names); end -end - -class Bundler::Fetcher::Index -end - -class Bundler::Fetcher::SSLError - def initialize(msg=T.unsafe(nil)); end -end - -class Bundler::Fetcher::TooManyRequestsError -end - -class Bundler::Fetcher::TooManyRequestsError -end - -class Bundler::Fetcher - def self.api_timeout(); end - - def self.api_timeout=(api_timeout); end - - def self.disable_endpoint(); end - - def self.disable_endpoint=(disable_endpoint); end - - def self.max_retries(); end - - def self.max_retries=(max_retries); end - - def self.redirect_limit(); end - - def self.redirect_limit=(redirect_limit); end -end - -module Bundler::FileUtils - VERSION = ::T.let(nil, ::T.untyped) -end - -class Bundler::FileUtils::Entry_ - def link(dest); end -end - -module Bundler::FileUtils - def self.cp_lr(src, dest, noop: T.unsafe(nil), verbose: T.unsafe(nil), dereference_root: T.unsafe(nil), remove_destination: T.unsafe(nil)); end - - def self.link_entry(src, dest, dereference_root=T.unsafe(nil), remove_destination=T.unsafe(nil)); end - - def self.ln_sr(src, dest, target_directory: T.unsafe(nil), force: T.unsafe(nil), noop: T.unsafe(nil), verbose: T.unsafe(nil)); end -end - -module Bundler::ForcePlatform -end - -module Bundler::ForcePlatform -end - -class Bundler::GemHelper - def allowed_push_host(); end - - def already_tagged?(); end - - def base(); end - - def build_checksum(built_gem_path=T.unsafe(nil)); end - - def build_gem(); end - - def built_gem_path(); end - - def clean?(); end - - def committed?(); end - - def current_branch(); end - - def default_remote(); end - - def gem_command(); end - - def gem_key(); end - - def gem_push?(); end - - def gem_push_host(); end - - def gemspec(); end - - def git_push(remote=T.unsafe(nil)); end - - def guard_clean(); end - - def initialize(base=T.unsafe(nil), name=T.unsafe(nil)); end - - def install(); end - - def install_gem(built_gem_path=T.unsafe(nil), local=T.unsafe(nil)); end - - def name(); end - - def rubygem_push(path); end - - def sh(cmd, &block); end - - def sh_with_input(cmd); end - - def sh_with_status(cmd, &block); end - - def spec_path(); end - - def tag_prefix=(tag_prefix); end - - def tag_version(); end - - def version(); end - - def version_tag(); end -end - -class Bundler::GemHelper - def self.gemspec(&block); end - - def self.install_tasks(opts=T.unsafe(nil)); end - - def self.instance(); end - - def self.instance=(instance); end - - def self.tag_prefix=(prefix); end -end - -class Bundler::GemHelpers::PlatformMatch - def self.specificity_score(spec_platform, user_platform); end -end - -module Bundler::GemHelpers - def self.local_platform(); end - - def self.same_deps(spec, exemplary_spec); end - - def self.same_specificity(platform, spec, exemplary_spec); end - - def self.sort_best_platform_match(matching, platform); end -end - -class Bundler::GemVersionPromoter - def level(); end - - def level=(value); end - - def major?(); end - - def minor?(); end - - def pre(); end - - def pre=(pre); end - - def pre?(); end - - def sort_versions(package, specs); end - - def strict(); end - - def strict=(strict); end -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 definition(); end -end - -class Bundler::LazySpecification - include ::Bundler::ForcePlatform - def eql?(other); end - - def force_ruby_platform(); end - - def force_ruby_platform=(force_ruby_platform); end - - def materialize_for_installation(); end -end - -class Bundler::LockfileParser - def may_include_redundant_platform_specific_gems?(); end -end - -class Bundler::LockfileParser - def self.bundled_with(); end -end - -module Bundler::MatchMetadata - def matches_current_ruby?(); end - - def matches_current_rubygems?(); end -end - -module Bundler::MatchMetadata -end - -module Bundler::MatchRemoteMetadata - include ::Bundler::MatchMetadata - include ::Bundler::FetchMetadata -end - -module Bundler::MatchRemoteMetadata -end - -class Bundler::PermissionError - def parent_folder(); end - - def permission_type(); end -end - -module Bundler::Plugin::API::Source - def ==(other); end - - def add_dependency_names(names); end - - def app_cache_dirname(); end - - def app_cache_path(custom_path=T.unsafe(nil)); 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(*arg); end - - def eql?(other); end - - def fetch_gemspec_files(); end - - def gem_install_dir(); end - - def hash(); end - - def identifier(); end - - def include?(other); end - - def initialize(opts); end - - def install(spec, opts); end - - def install_path(); end - - def installed?(); end - - def local!(); 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 spec_names(); end - - def specs(); end - - def to_lock(); end - - def to_s(); end - - def unlock!(); end - - def unmet_deps(); end - - def uri(); end - - def uri_hash(); end -end - -module Bundler::Plugin::API::Source -end - -module Bundler::Plugin::Events - GEM_AFTER_INSTALL = ::T.let(nil, ::T.untyped) - GEM_AFTER_INSTALL_ALL = ::T.let(nil, ::T.untyped) - GEM_BEFORE_INSTALL = ::T.let(nil, ::T.untyped) - GEM_BEFORE_INSTALL_ALL = ::T.let(nil, ::T.untyped) -end - -class Bundler::Plugin::Index - def installed_plugins(); end - - def plugin_commands(plugin); end - - def unregister_plugin(name); end -end - -class Bundler::Plugin::Index::CommandConflict - def initialize(plugin, commands); end -end - -class Bundler::Plugin::Index::CommandConflict -end - -class Bundler::Plugin::Index::SourceConflict - def initialize(plugin, sources); end -end - -class Bundler::Plugin::Index::SourceConflict -end - -class Bundler::Plugin::Installer - def install(names, options); end - - def install_definition(definition); end -end - -class Bundler::Plugin::Installer::Git - def generate_bin(spec, disable_extensions=T.unsafe(nil)); end -end - -class Bundler::Plugin::Installer::Git -end - -class Bundler::Plugin::Installer::Rubygems -end - -class Bundler::Plugin::Installer::Rubygems -end - -class Bundler::Plugin::Installer -end - -class Bundler::Plugin::PluginInstallError -end - -class Bundler::Plugin::PluginInstallError -end - -class Bundler::Plugin::SourceList -end - -class Bundler::Plugin::SourceList -end - -module Bundler::Plugin - def self.list(); end - - def self.save_plugin(name, spec, optional_plugin=T.unsafe(nil)); end - - def self.uninstall(names, options); end -end - -class Bundler::ProcessLock -end - -class Bundler::ProcessLock - def self.lock(bundle_path=T.unsafe(nil)); end -end - -class Bundler::PubGrub::Incompatibility - def cause(); end - - def conflict?(); end - - def eql?(other); end - - def external_incompatibilities(); end - - def failure?(); end - - def initialize(terms, cause:, custom_explanation: T.unsafe(nil)); end - - def terms(); end -end - -class Bundler::PubGrub::Incompatibility -end - -class Bundler::RemoteSpecification - include ::Bundler::MatchRemoteMetadata - include ::Bundler::MatchMetadata - include ::Bundler::FetchMetadata -end - -class Bundler::Resolver - include ::Bundler::GemHelpers - def all_versions_for(package); end - - def bundler_pinned_to_current_version?(); end - - def default_bundler_source(); end - - def find_names_to_relax(incompatibility); end - - def incompatibilities_for(package, version); end - - def no_versions_incompatibility_for(package, unsatisfied_term); end - - def parse_dependency(package, dependency); end - - def raise_not_found!(package); end - - def setup_solver(); end - - def solve_versions(root:, logger:); end - - def source_for(name); end - - def versions_for(package, range=T.unsafe(nil)); end -end - -class Bundler::Resolver::Base - def [](name); end - - def base_requirements(); end - - def delete(specs); end - - def get_package(name); end - - def include_prereleases(names); end - - def initialize(source_requirements, dependencies, base, platforms, options); end - - def packages(); end - - def requirements(); end - - def source_requirements(); end - - def unlock_names(names); end -end - -class Bundler::Resolver::Base -end - -class Bundler::Resolver::Candidate - include ::Comparable - def ==(other); end - - def dependencies(); end - - def eql?(other); end - - def generic!(); end - - def initialize(version, specs: T.unsafe(nil)); end - - def platform_specific!(); end - - def prerelease?(); end - - def segments(); end - - def sort_obj(); end - - def to_specs(package); end - - def version(); end -end - -class Bundler::Resolver::Candidate -end - -class Bundler::Resolver::Incompatibility - def extended_explanation(); end - - def initialize(terms, cause:, custom_explanation: T.unsafe(nil), extended_explanation: T.unsafe(nil)); end -end - -class Bundler::Resolver::Incompatibility -end - -class Bundler::Resolver::Package - def ==(other); end - - def consider_prereleases!(); end - - def current_platform?(); end - - def dependency(); end - - def force_ruby_platform?(); end - - def ignores_prereleases?(); end - - def initialize(name, platforms, locked_specs:, unlock:, prerelease: T.unsafe(nil), dependency: T.unsafe(nil)); end - - def locked_version(); end - - def meta?(); end - - def name(); end - - def platforms(); end - - def prerelease_specified?(); end - - def root?(); end - - def unlock?(); end -end - -class Bundler::Resolver::Package -end - -class Bundler::Resolver::Root - def initialize(name); end -end - -class Bundler::Resolver::Root -end - -class Bundler::Resolver::SpecGroup - def dependencies(); end - - def empty?(); end - - def sorted_spec_names(); end -end - -class Bundler::Retry - def attempt(&block); end - - def attempts(&block); end - - def current_run(); end - - def current_run=(current_run); end - - def initialize(name, exceptions=T.unsafe(nil), retries=T.unsafe(nil)); end - - def name(); end - - def name=(name); end - - def total_runs(); end - - def total_runs=(total_runs); end -end - -class Bundler::Retry - def self.attempts(); end - - def self.default_attempts(); end - - def self.default_retries(); end -end - -class Bundler::RubygemsIntegration - def add_default_gems_to(specs); end - - def add_to_load_path(paths); end - - def all_specs(); end - - def backport_ext_builder_monitor(); end - - def correct_for_windows_path(path); end - - def default_stubs(); end - - def find_bundler(version); end - - def find_name(name); end - - def gem_remote_fetcher(); end - - def load_env_plugins(); end - - def plain_specs(); end - - def plain_specs=(specs); end - - def stub_rubygems(specs); end - - def supports_bundler_trampolining?(); end -end - -module Bundler::SafeMarshal - ALLOWED_CLASSES = ::T.let(nil, ::T.untyped) - ERROR = ::T.let(nil, ::T.untyped) - PROC = ::T.let(nil, ::T.untyped) -end - -module Bundler::SafeMarshal -end - -class Bundler::SelfManager - def install_locked_bundler_and_restart_with_it_if_needed(); end - - def restart_with_locked_bundler_if_needed(); end - - def update_bundler_and_restart_with_it_if_needed(target); end -end - -class Bundler::SelfManager -end - -class Bundler::Settings - def processor_count(); end - STRING_KEYS = ::T.let(nil, ::T.untyped) -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::Path - def self.keyword_init?(); end -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::Settings - def self.key_for(key); end -end - -class Bundler::SolveFailure - def status_code(); end -end - -class Bundler::SolveFailure -end - -class Bundler::Source - def add_dependency_names(names); end - - def cached!(); end - - def identifier(); end - - def local!(); end - - def local_only!(); end - - def remote!(); end - - def spec_names(); end -end - -class Bundler::Source::Git - def current_branch(); end - - def glob(); end - - def local?(); end - - def to_gemfile(); end - - def uri_with_specifiers(specifiers); end -end - -class Bundler::Source::Rubygems - def default_cache_path_for(dir); end - - def dependency_api_available?(); end - - def fetch_gem_if_possible(spec, previous_spec=T.unsafe(nil)); end - - def multiple_remotes?(); end - - def no_remotes?(); end - - def package_path(cache_path, spec); end - - def remote_names(); end - - def to_gemfile(); end -end - -class Bundler::Source::RubygemsAggregate - def identifier(); end - - def initialize(sources, source_map); end - - def source_map(); end - - def sources(); end - - def specs(); end -end - -class Bundler::Source::RubygemsAggregate -end - -class Bundler::SourceList - def add_global_rubygems_remote(uri); end - - def aggregate_global_source?(); end - - def expired_sources?(replacement_sources); end - - def get_with_fallback(source); end - - def global_path_source(); end - - def implicit_global_source?(); end - - def local_only!(); end - - def lock_other_sources(); end - - def lock_rubygems_sources(); end - - def merged_gem_lockfile_sections!(replacement_source); end - - def merged_gem_lockfile_sections?(); end - - def non_default_explicit_sources(); end - - def non_global_rubygems_sources(); end -end - -class Bundler::SourceMap - def all_requirements(); end - - def dependencies(); end - - def direct_requirements(); end - - def initialize(sources, dependencies, locked_specs); end - - def locked_requirements(); end - - def locked_specs(); end - - def pinned_spec_names(skip=T.unsafe(nil)); end - - def sources(); end -end - -class Bundler::SourceMap -end - -class Bundler::SpecSet - include ::Enumerable - include ::Bundler::TSort - def -(other); end - - def delete(specs); end - - def delete_by_name(name); end - - def incomplete_ruby_specs?(deps); end - - def incomplete_specs(); end - - def missing_specs(); end -end - -class Bundler::StubSpecification - def extensions(); end - - def full_gem_path=(path); end - - def gem_build_complete_path(); end - - def manually_installed?(); end -end - -module Bundler::TSort - def each_strongly_connected_component(&block); end - - def each_strongly_connected_component_from(node, id_map=T.unsafe(nil), stack=T.unsafe(nil), &block); end - - def strongly_connected_components(); end - - def tsort(); end - - def tsort_each(&block); end - - def tsort_each_child(node); end - - def tsort_each_node(); end -end - -class Bundler::TSort::Cyclic -end - -class Bundler::TSort::Cyclic -end - -module Bundler::TSort - def self.each_strongly_connected_component(each_node, each_child); end - - def self.each_strongly_connected_component_from(node, each_child, id_map=T.unsafe(nil), stack=T.unsafe(nil)); end - - def self.strongly_connected_components(each_node, each_child); end - - def self.tsort(each_node, each_child); end - - def self.tsort_each(each_node, each_child); end -end - -class Bundler::Thor - include ::Bundler::Thor::Base - include ::Bundler::Thor::Invocation - include ::Bundler::Thor::Shell - def help(command=T.unsafe(nil), subcommand=T.unsafe(nil)); end - HELP_MAPPINGS = ::T.let(nil, ::T.untyped) - TEMPLATE_EXTNAME = ::T.let(nil, ::T.untyped) - THOR_RESERVED_WORDS = ::T.let(nil, ::T.untyped) -end - -module Bundler::Thor::Actions - def _cleanup_options_and_set(options, key); end - - def _shared_configuration(); end - - def action(instance); end - - def add_file(destination, *args, &block); end - - def add_link(destination, *args); end - - def append_file(path, *args, &block); end - - def append_to_file(path, *args, &block); end - - def apply(path, config=T.unsafe(nil)); end - - def behavior(); end - - def behavior=(behavior); end - - def chmod(path, mode, config=T.unsafe(nil)); end - - def comment_lines(path, flag, *args); end - - def copy_file(source, *args, &block); end - - def create_file(destination, *args, &block); end - - def create_link(destination, *args); end - - def destination_root(); end - - def destination_root=(root); end - - def directory(source, *args, &block); end - - def empty_directory(destination, config=T.unsafe(nil)); end - - def find_in_source_paths(file); end - - def get(source, *args, &block); end - - def gsub_file(path, flag, *args, &block); end - - def in_root(); end - - def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil)); end - - def inject_into_class(path, klass, *args, &block); end - - def inject_into_file(destination, *args, &block); end - - def inject_into_module(path, module_name, *args, &block); end - - def insert_into_file(destination, *args, &block); end - - def inside(dir=T.unsafe(nil), config=T.unsafe(nil), &block); end - - def link_file(source, *args); end - - def prepend_file(path, *args, &block); end - - def prepend_to_file(path, *args, &block); end - - def relative_to_original_destination_root(path, remove_dot=T.unsafe(nil)); end - - def remove_dir(path, config=T.unsafe(nil)); end - - def remove_file(path, config=T.unsafe(nil)); end - - def run(command, config=T.unsafe(nil)); end - - def run_ruby_script(command, config=T.unsafe(nil)); end - - def source_paths(); end - - def template(source, *args, &block); end - - def thor(command, *args); end - - def uncomment_lines(path, flag, *args); end - WARNINGS = ::T.let(nil, ::T.untyped) -end - -class Bundler::Thor::Actions::CapturableERB -end - -class Bundler::Thor::Actions::CapturableERB -end - -module Bundler::Thor::Actions::ClassMethods - def add_runtime_options!(); end - - def source_paths(); end - - def source_paths_for_search(); end - - def source_root(path=T.unsafe(nil)); end -end - -module Bundler::Thor::Actions::ClassMethods -end - -class Bundler::Thor::Actions::CreateFile - def data(); end - - def force_on_collision?(); end - - def force_or_skip_or_conflict(force, skip, &block); end - - def identical?(); end - - def initialize(base, destination, data, config=T.unsafe(nil)); end - - def on_conflict_behavior(&block); end - - def render(); end -end - -class Bundler::Thor::Actions::CreateFile -end - -class Bundler::Thor::Actions::CreateLink -end - -class Bundler::Thor::Actions::CreateLink -end - -class Bundler::Thor::Actions::Directory - def execute!(); end - - def file_level_lookup(previous_lookup); end - - def files(lookup); end - - def initialize(base, source, destination=T.unsafe(nil), config=T.unsafe(nil), &block); end - - def source(); end -end - -class Bundler::Thor::Actions::Directory -end - -class Bundler::Thor::Actions::EmptyDirectory - def base(); end - - def config(); end - - def convert_encoded_instructions(filename); end - - def destination(); end - - def destination=(destination); end - - def exists?(); end - - def given_destination(); end - - def initialize(base, destination, config=T.unsafe(nil)); end - - def invoke!(); end - - def invoke_with_conflict_check(&block); end - - def on_conflict_behavior(); end - - def on_file_clash_behavior(); end - - def pretend?(); end - - def relative_destination(); end - - def revoke!(); end - - def say_status(status, color); end -end - -class Bundler::Thor::Actions::EmptyDirectory -end - -class Bundler::Thor::Actions::InjectIntoFile - def behavior(); end - - def flag(); end - - def initialize(base, destination, data, config); end - - def replace!(regexp, string, force); end - - def replacement(); end - - def say_status(behavior, warning: T.unsafe(nil), color: T.unsafe(nil)); end -end - -class Bundler::Thor::Actions::InjectIntoFile -end - -module Bundler::Thor::Actions - def self.included(base); end -end - -class Bundler::Thor::AmbiguousCommandError -end - -class Bundler::Thor::AmbiguousCommandError -end - -Bundler::Thor::AmbiguousTaskError = Bundler::Thor::AmbiguousCommandError - -class Bundler::Thor::Argument - def banner(); end - - def default(); end - - def default_banner(); end - - def description(); end - - def enum(); end - - def human_name(); end - - def initialize(name, options=T.unsafe(nil)); end - - def name(); end - - def required(); end - - def required?(); end - - def show_default?(); end - - def type(); end - - def usage(); end - - def valid_type?(type); end - - def validate!(); end - VALID_TYPES = ::T.let(nil, ::T.untyped) -end - -class Bundler::Thor::Argument -end - -class Bundler::Thor::Arguments - def initialize(arguments=T.unsafe(nil)); end - - def parse(args); end - - def remaining(); end - NUMERIC = ::T.let(nil, ::T.untyped) -end - -class Bundler::Thor::Arguments - def self.parse(*args); end - - def self.split(args); end -end - -module Bundler::Thor::Base - def args(); end - - def args=(args); end - - def initialize(args=T.unsafe(nil), local_options=T.unsafe(nil), config=T.unsafe(nil)); end - - def options(); end - - def options=(options); end - - def parent_options(); end - - def parent_options=(parent_options); end -end - -module Bundler::Thor::Base::ClassMethods - def all_commands(); end - - def all_tasks(); end - - def allow_incompatible_default_type!(); end - - def argument(name, options=T.unsafe(nil)); end - - def arguments(); end - - def attr_accessor(*arg); end - - def attr_reader(*arg); end - - def attr_writer(*arg); end - - def baseclass(); end - - def basename(); end - - def build_option(name, options, scope); end - - def build_options(options, scope); end - - def check_default_type(); end - - def check_default_type!(); end - - def check_unknown_options(); end - - def check_unknown_options!(); end - - def check_unknown_options?(config); end - - def class_option(name, options=T.unsafe(nil)); end - - def class_options(options=T.unsafe(nil)); end - - def class_options_help(shell, groups=T.unsafe(nil)); end - - def commands(); end - - def create_command(meth); end - - def create_task(meth); end - - def disable_required_check?(command_name); end - - def dispatch(command, given_args, given_opts, config); end - - def exit_on_failure?(); end - - def find_and_refresh_command(name); end - - def find_and_refresh_task(name); end - - def from_superclass(method, default=T.unsafe(nil)); end - - def group(name=T.unsafe(nil)); end - - def handle_argument_error(command, error, args, arity); end - - def handle_no_command_error(command, has_namespace=T.unsafe(nil)); end - - def handle_no_task_error(command, has_namespace=T.unsafe(nil)); end - - def inherited(klass); end - - def initialize_added(); end - - def is_thor_reserved_word?(word, type); end - - def method_added(meth); end - - def namespace(name=T.unsafe(nil)); end - - def no_commands(&block); end - - def no_commands?(); end - - def no_commands_context(); end - - def no_tasks(&block); end - - def print_options(shell, options, group_name=T.unsafe(nil)); end - - def public_command(*names); end - - def public_task(*names); end - - def remove_argument(*names); end - - def remove_class_option(*names); end - - def remove_command(*names); end - - def remove_task(*names); end - - def start(given_args=T.unsafe(nil), config=T.unsafe(nil)); end - - def stop_on_unknown_option?(command_name); end - - def strict_args_position(); end - - def strict_args_position!(); end - - def strict_args_position?(config); end - - def tasks(); end -end - -module Bundler::Thor::Base::ClassMethods -end - -module Bundler::Thor::Base - def self.included(base); end - - def self.register_klass_file(klass); end - - def self.shell(); end - - def self.shell=(shell); end - - def self.subclass_files(); end - - def self.subclasses(); end -end - -class Bundler::Thor::Command - def formatted_usage(klass, namespace=T.unsafe(nil), subcommand=T.unsafe(nil)); end - - def handle_argument_error?(instance, error, caller); end - - def handle_no_method_error?(instance, error, caller); end - - def hidden?(); end - - def initialize(name, description, long_description, usage, options=T.unsafe(nil)); end - - def local_method?(instance, name); end - - def not_debugging?(instance); end - - def private_method?(instance); end - - def public_method?(instance); end - - def required_arguments_for(klass, usage); end - - def required_options(); end - - def run(instance, args=T.unsafe(nil)); end - - def sans_backtrace(backtrace, caller); end - FILE_REGEXP = ::T.let(nil, ::T.untyped) -end - -class Bundler::Thor::Command -end - -module Bundler::Thor::CoreExt -end - -class Bundler::Thor::CoreExt::HashWithIndifferentAccess - def [](key); end - - def []=(key, value); end - - def convert_key(key); end - - def delete(key); end - - def except(*keys); end - - def fetch(key, *args); end - - def initialize(hash=T.unsafe(nil)); end - - def key?(key); end - - def merge(other); end - - def merge!(other); end - - def method_missing(method, *args); end - - def replace(other_hash); end - - def reverse_merge(other); end - - def reverse_merge!(other_hash); end - - def values_at(*indices); end -end - -class Bundler::Thor::CoreExt::HashWithIndifferentAccess -end - -module Bundler::Thor::CoreExt -end - -Bundler::Thor::Correctable = DidYouMean::Correctable - -class Bundler::Thor::DynamicCommand - def initialize(name, options=T.unsafe(nil)); end -end - -class Bundler::Thor::DynamicCommand -end - -Bundler::Thor::DynamicTask = Bundler::Thor::DynamicCommand - -class Bundler::Thor::Error -end - -class Bundler::Thor::Error -end - -class Bundler::Thor::Group - include ::Bundler::Thor::Base - include ::Bundler::Thor::Invocation - include ::Bundler::Thor::Shell - def _invoke_for_class_method(klass, command=T.unsafe(nil), *args, &block); end -end - -class Bundler::Thor::Group - extend ::Bundler::Thor::Base::ClassMethods - extend ::Bundler::Thor::Invocation::ClassMethods - def self.banner(); end - - def self.desc(description=T.unsafe(nil)); end - - def self.get_options_from_invocations(group_options, base_options); end - - def self.handle_argument_error(command, error, _args, arity); end - - def self.help(shell); end - - def self.invocation_blocks(); end - - def self.invocations(); end - - def self.invoke(*names, &block); end - - def self.invoke_from_option(*names, &block); end - - def self.printable_commands(*arg); end - - def self.printable_tasks(*arg); end - - def self.remove_invocation(*names); end - - def self.self_command(); end - - def self.self_task(); end -end - -class Bundler::Thor::HiddenCommand -end - -class Bundler::Thor::HiddenCommand -end - -Bundler::Thor::HiddenTask = Bundler::Thor::HiddenCommand - -module Bundler::Thor::Invocation - def _parse_initialization_options(args, opts, config); end - - def _retrieve_class_and_command(name, sent_command=T.unsafe(nil)); end - - def _retrieve_class_and_task(name, sent_command=T.unsafe(nil)); end - - def _shared_configuration(); end - - def current_command_chain(); end - - def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil), &block); end - - def invoke(name=T.unsafe(nil), *args); end - - def invoke_all(); end - - def invoke_command(command, *args); end - - def invoke_task(command, *args); end - - def invoke_with_padding(*args); end -end - -module Bundler::Thor::Invocation::ClassMethods - def prepare_for_invocation(key, name); end -end - -module Bundler::Thor::Invocation::ClassMethods -end - -module Bundler::Thor::Invocation - def self.included(base); end -end - -class Bundler::Thor::InvocationError -end - -class Bundler::Thor::InvocationError -end - -module Bundler::Thor::LineEditor -end - -class Bundler::Thor::LineEditor::Basic - def initialize(prompt, options); end - - def options(); end - - def prompt(); end - - def readline(); end -end - -class Bundler::Thor::LineEditor::Basic - def self.available?(); end -end - -class Bundler::Thor::LineEditor::Readline -end - -class Bundler::Thor::LineEditor::Readline::PathCompletion - def initialize(text); end - - def matches(); end -end - -class Bundler::Thor::LineEditor::Readline::PathCompletion -end - -class Bundler::Thor::LineEditor::Readline -end - -module Bundler::Thor::LineEditor - def self.best_available(); end - - def self.readline(prompt, options=T.unsafe(nil)); end -end - -class Bundler::Thor::MalformattedArgumentError -end - -class Bundler::Thor::MalformattedArgumentError -end - -class Bundler::Thor::NestedContext - def enter(); end - - def entered?(); end -end - -class Bundler::Thor::NestedContext -end - -class Bundler::Thor::NoKwargSpellChecker - def initialize(dictionary); end -end - -class Bundler::Thor::NoKwargSpellChecker -end - -class Bundler::Thor::Option - def aliases(); end - - def array?(); end - - def boolean?(); end - - def dasherize(str); end - - def dasherized?(); end - - def group(); end - - def hash?(); end - - def hide(); end - - def lazy_default(); end - - def numeric?(); end - - def repeatable(); end - - def string?(); end - - def switch_name(); end - - def undasherize(str); end - - def usage(padding=T.unsafe(nil)); end - - def validate_default_type!(); end - VALID_TYPES = ::T.let(nil, ::T.untyped) -end - -class Bundler::Thor::Option - def self.parse(key, value); end -end - -class Bundler::Thor::Options - def assign_result!(option, result); end - - def check_unknown!(); end - - def current_is_switch?(); end - - def current_is_switch_formatted?(); end - - def initialize(hash_options=T.unsafe(nil), defaults=T.unsafe(nil), stop_on_unknown=T.unsafe(nil), disable_required_check=T.unsafe(nil)); end - - def normalize_switch(arg); end - - def parse_boolean(switch); end - - def parse_peek(switch, option); end - - def parsing_options?(); end - - def switch?(arg); end - - def switch_option(arg); end - - def unshift(arg, is_value: T.unsafe(nil)); end - EQ_RE = ::T.let(nil, ::T.untyped) - LONG_RE = ::T.let(nil, ::T.untyped) - OPTS_END = ::T.let(nil, ::T.untyped) - SHORT_NUM = ::T.let(nil, ::T.untyped) - SHORT_RE = ::T.let(nil, ::T.untyped) - SHORT_SQ_RE = ::T.let(nil, ::T.untyped) -end - -class Bundler::Thor::Options - def self.to_switches(options); end -end - -class Bundler::Thor::RequiredArgumentMissingError -end - -class Bundler::Thor::RequiredArgumentMissingError -end - -module Bundler::Thor::Sandbox -end - -module Bundler::Thor::Sandbox -end - -module Bundler::Thor::Shell - def _shared_configuration(); end - - def ask(*args, &block); end - - def error(*args, &block); end - - def file_collision(*args, &block); end - - def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil)); end - - def no?(*args, &block); end - - def print_in_columns(*args, &block); end - - def print_table(*args, &block); end - - def print_wrapped(*args, &block); end - - def say(*args, &block); end - - def say_error(*args, &block); end - - def say_status(*args, &block); end - - def set_color(*args, &block); end - - def shell(); end - - def shell=(shell); end - - def terminal_width(*args, &block); end - - def with_padding(); end - - def yes?(*args, &block); end - SHELL_DELEGATED_METHODS = ::T.let(nil, ::T.untyped) -end - -class Bundler::Thor::Shell::Basic - def answer_match(possibilities, answer, case_insensitive); end - - def as_unicode(); end - - def ask(statement, *args); end - - def ask_filtered(statement, color, options); end - - def ask_simply(statement, color, options); end - - def base(); end - - def base=(base); end - - def can_display_colors?(); end - - def dynamic_width(); end - - def dynamic_width_stty(); end - - def dynamic_width_tput(); end - - def error(statement); end - - def file_collision(destination); end - - def file_collision_help(); end - - def git_merge_tool(); end - - def indent(count=T.unsafe(nil)); end - - def is?(value); end - - def lookup_color(color); end - - def merge(destination, content); end - - def merge_tool(); end - - def mute(); end - - def mute?(); end - - def no?(statement, color=T.unsafe(nil)); end - - def padding(); end - - def padding=(value); end - - def prepare_message(message, *color); end - - def print_in_columns(array); end - - def print_table(array, options=T.unsafe(nil)); end - - def print_wrapped(message, options=T.unsafe(nil)); end - - def quiet?(); end - - def say(message=T.unsafe(nil), color=T.unsafe(nil), force_new_line=T.unsafe(nil)); end - - def say_error(message=T.unsafe(nil), color=T.unsafe(nil), force_new_line=T.unsafe(nil)); end - - def say_status(status, message, log_status=T.unsafe(nil)); end - - def set_color(string, *arg); end - - def show_diff(destination, content); end - - def stderr(); end - - def stdout(); end - - def terminal_width(); end - - def truncate(string, width); end - - def unix?(); end - - def yes?(statement, color=T.unsafe(nil)); end - DEFAULT_TERMINAL_WIDTH = ::T.let(nil, ::T.untyped) -end - -class Bundler::Thor::Shell::Basic -end - -class Bundler::Thor::Shell::Color - def are_colors_disabled?(); end - - def are_colors_supported?(); end - - def diff_lcs_loaded?(); end - - def output_diff_line(diff); end - - def set_color(string, *colors); end - BLACK = ::T.let(nil, ::T.untyped) - BLUE = ::T.let(nil, ::T.untyped) - BOLD = ::T.let(nil, ::T.untyped) - CLEAR = ::T.let(nil, ::T.untyped) - CYAN = ::T.let(nil, ::T.untyped) - GREEN = ::T.let(nil, ::T.untyped) - MAGENTA = ::T.let(nil, ::T.untyped) - ON_BLACK = ::T.let(nil, ::T.untyped) - ON_BLUE = ::T.let(nil, ::T.untyped) - ON_CYAN = ::T.let(nil, ::T.untyped) - ON_GREEN = ::T.let(nil, ::T.untyped) - ON_MAGENTA = ::T.let(nil, ::T.untyped) - ON_RED = ::T.let(nil, ::T.untyped) - ON_WHITE = ::T.let(nil, ::T.untyped) - ON_YELLOW = ::T.let(nil, ::T.untyped) - RED = ::T.let(nil, ::T.untyped) - WHITE = ::T.let(nil, ::T.untyped) - YELLOW = ::T.let(nil, ::T.untyped) -end - -class Bundler::Thor::Shell::Color -end - -class Bundler::Thor::Shell::HTML - def ask(statement, color=T.unsafe(nil)); end - - def diff_lcs_loaded?(); end - - def output_diff_line(diff); end - - def set_color(string, *colors); end - BLACK = ::T.let(nil, ::T.untyped) - BLUE = ::T.let(nil, ::T.untyped) - BOLD = ::T.let(nil, ::T.untyped) - CYAN = ::T.let(nil, ::T.untyped) - GREEN = ::T.let(nil, ::T.untyped) - MAGENTA = ::T.let(nil, ::T.untyped) - ON_BLACK = ::T.let(nil, ::T.untyped) - ON_BLUE = ::T.let(nil, ::T.untyped) - ON_CYAN = ::T.let(nil, ::T.untyped) - ON_GREEN = ::T.let(nil, ::T.untyped) - ON_MAGENTA = ::T.let(nil, ::T.untyped) - ON_RED = ::T.let(nil, ::T.untyped) - ON_WHITE = ::T.let(nil, ::T.untyped) - ON_YELLOW = ::T.let(nil, ::T.untyped) - RED = ::T.let(nil, ::T.untyped) - WHITE = ::T.let(nil, ::T.untyped) - YELLOW = ::T.let(nil, ::T.untyped) -end - -class Bundler::Thor::Shell::HTML -end - -module Bundler::Thor::Shell -end - -Bundler::Thor::Task = Bundler::Thor::Command - -class Bundler::Thor::UndefinedCommandError - include ::DidYouMean::Correctable - def all_commands(); end - - def command(); end - - def initialize(command, all_commands, namespace); end -end - -class Bundler::Thor::UndefinedCommandError::SpellChecker - def corrections(); end - - def error(); end - - def initialize(error); end - - def spell_checker(); end -end - -class Bundler::Thor::UndefinedCommandError::SpellChecker -end - -class Bundler::Thor::UndefinedCommandError -end - -Bundler::Thor::UndefinedTaskError = Bundler::Thor::UndefinedCommandError - -class Bundler::Thor::UnknownArgumentError - include ::DidYouMean::Correctable - def initialize(switches, unknown); end - - def switches(); end - - def unknown(); end -end - -class Bundler::Thor::UnknownArgumentError::SpellChecker - def corrections(); end - - def error(); end - - def initialize(error); end - - def spell_checker(); end -end - -class Bundler::Thor::UnknownArgumentError::SpellChecker -end - -class Bundler::Thor::UnknownArgumentError -end - -module Bundler::Thor::Util -end - -module Bundler::Thor::Util - def self.camel_case(str); end - - def self.escape_globs(path); end - - def self.escape_html(string); end - - def self.find_by_namespace(namespace); end - - def self.find_class_and_command_by_namespace(namespace, fallback=T.unsafe(nil)); end - - def self.find_class_and_task_by_namespace(namespace, fallback=T.unsafe(nil)); end - - def self.globs_for(path); end - - def self.load_thorfile(path, content=T.unsafe(nil), debug=T.unsafe(nil)); end - - def self.namespace_from_thor_class(constant); end - - def self.namespaces_in_content(contents, file=T.unsafe(nil)); end - - def self.ruby_command(); end - - def self.snake_case(str); end - - def self.thor_classes_in(klass); end - - def self.thor_root(); end - - def self.thor_root_glob(); end - - def self.user_home(); end -end - -class Bundler::Thor - extend ::Bundler::Thor::Base::ClassMethods - extend ::Bundler::Thor::Invocation::ClassMethods - def self.banner(command, namespace=T.unsafe(nil), subcommand=T.unsafe(nil)); end - - def self.check_unknown_options!(options=T.unsafe(nil)); end - - def self.command_help(shell, command_name); end - - def self.default_command(meth=T.unsafe(nil)); end - - def self.default_task(meth=T.unsafe(nil)); end - - def self.deprecation_warning(message); end - - def self.desc(usage, description, options=T.unsafe(nil)); end - - def self.disable_required_check(); end - - def self.disable_required_check!(*command_names); end - - def self.disable_required_check?(command); end - - def self.dispatch(meth, given_args, given_opts, config); end - - def self.dynamic_command_class(); end - - def self.find_command_possibilities(meth); end - - def self.find_task_possibilities(meth); end - - def self.help(shell, subcommand=T.unsafe(nil)); end - - def self.long_desc(long_description, options=T.unsafe(nil)); end - - def self.map(mappings=T.unsafe(nil), **kw); end - - def self.method_option(name, options=T.unsafe(nil)); end - - def self.method_options(options=T.unsafe(nil)); end - - def self.normalize_command_name(meth); end - - def self.normalize_task_name(meth); end - - def self.option(name, options=T.unsafe(nil)); end - - def self.options(options=T.unsafe(nil)); end - - def self.package_name(name, _=T.unsafe(nil)); end - - def self.printable_commands(all=T.unsafe(nil), subcommand=T.unsafe(nil)); end - - def self.printable_tasks(all=T.unsafe(nil), subcommand=T.unsafe(nil)); end - - def self.register(klass, subcommand_name, usage, description, options=T.unsafe(nil)); end - - def self.retrieve_command_name(args); end - - def self.retrieve_task_name(args); end - - def self.stop_on_unknown_option(); end - - def self.stop_on_unknown_option!(*command_names); end - - def self.stop_on_unknown_option?(command); end - - def self.subcommand(subcommand, subcommand_class); end - - def self.subcommand_classes(); end - - def self.subcommand_help(cmd); end - - def self.subcommands(); end - - def self.subtask(subcommand, subcommand_class); end - - def self.subtask_help(cmd); end - - def self.subtasks(); end - - def self.task_help(shell, command_name); end -end - -class Bundler::UI::Shell - def add_color(string, *color); end - - def ask(msg); end - - def confirm(msg=T.unsafe(nil), newline=T.unsafe(nil)); end - - def confirm?(); end - - def debug(msg=T.unsafe(nil), newline=T.unsafe(nil)); end - - def debug?(); end - - def error(msg=T.unsafe(nil), newline=T.unsafe(nil), color=T.unsafe(nil)); end - - def error?(); end - - def info(msg=T.unsafe(nil), newline=T.unsafe(nil)); end - - def info?(); 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=T.unsafe(nil), newline=T.unsafe(nil), color=T.unsafe(nil)); end - - def warn?(); end - - def yes?(msg); end - LEVELS = ::T.let(nil, ::T.untyped) -end - -class Bundler::UI::Shell -end - -class Bundler::UI::Silent - def confirm?(); end - - def error?(); end - - def info?(); end - - def warn?(); end -end - -module Bundler::URI - include ::Bundler::URI::RFC2396_REGEXP - ABS_PATH = ::T.let(nil, ::T.untyped) - ABS_URI = ::T.let(nil, ::T.untyped) - ABS_URI_REF = ::T.let(nil, ::T.untyped) - DEFAULT_PARSER = ::T.let(nil, ::T.untyped) - ESCAPED = ::T.let(nil, ::T.untyped) - FRAGMENT = ::T.let(nil, ::T.untyped) - HOST = ::T.let(nil, ::T.untyped) - OPAQUE = ::T.let(nil, ::T.untyped) - PORT = ::T.let(nil, ::T.untyped) - QUERY = ::T.let(nil, ::T.untyped) - REGISTRY = ::T.let(nil, ::T.untyped) - REL_PATH = ::T.let(nil, ::T.untyped) - REL_URI = ::T.let(nil, ::T.untyped) - REL_URI_REF = ::T.let(nil, ::T.untyped) - RFC3986_PARSER = ::T.let(nil, ::T.untyped) - SCHEME = ::T.let(nil, ::T.untyped) - TBLDECWWWCOMP_ = ::T.let(nil, ::T.untyped) - TBLENCURICOMP_ = ::T.let(nil, ::T.untyped) - TBLENCWWWCOMP_ = ::T.let(nil, ::T.untyped) - UNSAFE = ::T.let(nil, ::T.untyped) - URI_REF = ::T.let(nil, ::T.untyped) - USERINFO = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) - VERSION_CODE = ::T.let(nil, ::T.untyped) - WEB_ENCODINGS_ = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::BadURIError -end - -class Bundler::URI::BadURIError -end - -class Bundler::URI::Error -end - -class Bundler::URI::Error -end - -class Bundler::URI::FTP - def set_typecode(v); end - - def typecode(); end - - def typecode=(typecode); end - COMPONENT = ::T.let(nil, ::T.untyped) - DEFAULT_PORT = ::T.let(nil, ::T.untyped) - TYPECODE = ::T.let(nil, ::T.untyped) - TYPECODE_PREFIX = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::FTP - def self.new2(user, password, host, port, path, typecode=T.unsafe(nil), arg_check=T.unsafe(nil)); end -end - -class Bundler::URI::File - def check_password(user); end - - def check_user(user); end - - def check_userinfo(user); end - - def set_userinfo(v); end - COMPONENT = ::T.let(nil, ::T.untyped) - DEFAULT_PORT = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::File -end - -class Bundler::URI::Generic - include ::Bundler::URI - include ::Bundler::URI::RFC2396_REGEXP - def +(oth); end - - def -(oth); end - - def ==(oth); end - - def absolute(); end - - def absolute?(); end - - def coerce(oth); end - - def component(); end - - def component_ary(); end - - def decoded_password(); end - - def decoded_user(); end - - def default_port(); end - - def eql?(oth); end - - def find_proxy(env=T.unsafe(nil)); end - - def fragment(); end - - def fragment=(v); end - - def hierarchical?(); end - - def host(); end - - def host=(v); end - - def hostname(); end - - def hostname=(v); end - - def initialize(scheme, userinfo, host, port, registry, path, opaque, query, fragment, parser=T.unsafe(nil), arg_check=T.unsafe(nil)); end - - def merge(oth); end - - def merge!(oth); end - - def normalize(); end - - def normalize!(); end - - def opaque(); end - - def opaque=(v); end - - def parser(); end - - def password(); end - - def password=(password); end - - def path(); end - - def path=(v); end - - def port(); end - - def port=(v); end - - def query(); end - - def query=(v); end - - def registry(); end - - def registry=(v); end - - def relative?(); end - - def route_from(oth); end - - def route_to(oth); end - - def scheme(); end - - def scheme=(v); end - - def select(*components); end - - def set_host(v); end - - def set_opaque(v); end - - def set_password(v); end - - def set_path(v); end - - def set_port(v); end - - def set_registry(v); end - - def set_scheme(v); end - - def set_user(v); end - - def set_userinfo(user, password=T.unsafe(nil)); end - - def user(); end - - def user=(user); end - - def userinfo(); end - - def userinfo=(userinfo); end - COMPONENT = ::T.let(nil, ::T.untyped) - DEFAULT_PORT = ::T.let(nil, ::T.untyped) - USE_REGISTRY = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::Generic - def self.build(args); end - - def self.build2(args); end - - def self.component(); end - - def self.default_port(); end - - def self.use_proxy?(hostname, addr, port, no_proxy); end - - def self.use_registry(); end -end - -class Bundler::URI::HTTP - def authority(); end - - def origin(); end - - def request_uri(); end - COMPONENT = ::T.let(nil, ::T.untyped) - DEFAULT_PORT = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::HTTP -end - -class Bundler::URI::HTTPS - DEFAULT_PORT = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::HTTPS -end - -class Bundler::URI::InvalidComponentError -end - -class Bundler::URI::InvalidComponentError -end - -class Bundler::URI::InvalidURIError -end - -class Bundler::URI::InvalidURIError -end - -class Bundler::URI::LDAP - def attributes(); end - - def attributes=(val); end - - def dn(); end - - def dn=(val); end - - def extensions(); end - - def extensions=(val); end - - def filter(); end - - def filter=(val); end - - def initialize(*arg); end - - def scope(); end - - def scope=(val); end - - def set_attributes(val); end - - def set_dn(val); end - - def set_extensions(val); end - - def set_filter(val); end - - def set_scope(val); end - COMPONENT = ::T.let(nil, ::T.untyped) - DEFAULT_PORT = ::T.let(nil, ::T.untyped) - SCOPE = ::T.let(nil, ::T.untyped) - SCOPE_BASE = ::T.let(nil, ::T.untyped) - SCOPE_ONE = ::T.let(nil, ::T.untyped) - SCOPE_SUB = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::LDAP -end - -class Bundler::URI::LDAPS - DEFAULT_PORT = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::LDAPS -end - -class Bundler::URI::MailTo - def headers(); end - - def headers=(v); end - - def initialize(*arg); end - - def set_headers(v); end - - def set_to(v); end - - def to(); end - - def to=(v); end - - def to_mailtext(); end - - def to_rfc822text(); end - COMPONENT = ::T.let(nil, ::T.untyped) - DEFAULT_PORT = ::T.let(nil, ::T.untyped) - EMAIL_REGEXP = ::T.let(nil, ::T.untyped) - HEADER_REGEXP = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::MailTo -end - -Bundler::URI::Parser = Bundler::URI::RFC2396_Parser - -Bundler::URI::REGEXP = Bundler::URI::RFC2396_REGEXP - -class Bundler::URI::RFC2396_Parser - include ::Bundler::URI::RFC2396_REGEXP - def escape(str, unsafe=T.unsafe(nil)); end - - def extract(str, schemes=T.unsafe(nil)); end - - def initialize(opts=T.unsafe(nil)); end - - def join(*uris); end - - def make_regexp(schemes=T.unsafe(nil)); end - - def parse(uri); end - - def pattern(); end - - def regexp(); end - - def split(uri); end - - def unescape(str, escaped=T.unsafe(nil)); end -end - -class Bundler::URI::RFC2396_Parser -end - -module Bundler::URI::RFC2396_REGEXP -end - -module Bundler::URI::RFC2396_REGEXP::PATTERN - ABS_PATH = ::T.let(nil, ::T.untyped) - ABS_URI = ::T.let(nil, ::T.untyped) - ALNUM = ::T.let(nil, ::T.untyped) - ALPHA = ::T.let(nil, ::T.untyped) - DOMLABEL = ::T.let(nil, ::T.untyped) - ESCAPED = ::T.let(nil, ::T.untyped) - FRAGMENT = ::T.let(nil, ::T.untyped) - HEX = ::T.let(nil, ::T.untyped) - HIER_PART = ::T.let(nil, ::T.untyped) - HOST = ::T.let(nil, ::T.untyped) - HOSTNAME = ::T.let(nil, ::T.untyped) - HOSTPORT = ::T.let(nil, ::T.untyped) - IPV4ADDR = ::T.let(nil, ::T.untyped) - IPV6ADDR = ::T.let(nil, ::T.untyped) - IPV6REF = ::T.let(nil, ::T.untyped) - NET_PATH = ::T.let(nil, ::T.untyped) - OPAQUE_PART = ::T.let(nil, ::T.untyped) - PATH_SEGMENTS = ::T.let(nil, ::T.untyped) - PORT = ::T.let(nil, ::T.untyped) - QUERY = ::T.let(nil, ::T.untyped) - REG_NAME = ::T.let(nil, ::T.untyped) - REL_PATH = ::T.let(nil, ::T.untyped) - REL_SEGMENT = ::T.let(nil, ::T.untyped) - REL_URI = ::T.let(nil, ::T.untyped) - RESERVED = ::T.let(nil, ::T.untyped) - SCHEME = ::T.let(nil, ::T.untyped) - TOPLABEL = ::T.let(nil, ::T.untyped) - UNRESERVED = ::T.let(nil, ::T.untyped) - URIC = ::T.let(nil, ::T.untyped) - URIC_NO_SLASH = ::T.let(nil, ::T.untyped) - URI_REF = ::T.let(nil, ::T.untyped) - USERINFO = ::T.let(nil, ::T.untyped) - X_ABS_URI = ::T.let(nil, ::T.untyped) - X_REL_URI = ::T.let(nil, ::T.untyped) -end - -module Bundler::URI::RFC2396_REGEXP::PATTERN -end - -module Bundler::URI::RFC2396_REGEXP -end - -class Bundler::URI::RFC3986_Parser - def join(*uris); end - - def parse(uri); end - - def regexp(); end - - def split(uri); end - RFC3986_URI = ::T.let(nil, ::T.untyped) - RFC3986_relative_ref = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::RFC3986_Parser -end - -module Bundler::URI::Util -end - -module Bundler::URI::Util - def self.make_components_hash(klass, array_hash); end -end - -class Bundler::URI::WS - def request_uri(); end - COMPONENT = ::T.let(nil, ::T.untyped) - DEFAULT_PORT = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::WS -end - -class Bundler::URI::WSS - DEFAULT_PORT = ::T.let(nil, ::T.untyped) -end - -class Bundler::URI::WSS -end - -module Bundler::URI - def self.decode_uri_component(str, enc=T.unsafe(nil)); end - - def self.decode_www_form(str, enc=T.unsafe(nil), separator: T.unsafe(nil), use__charset_: T.unsafe(nil), isindex: T.unsafe(nil)); end - - def self.decode_www_form_component(str, enc=T.unsafe(nil)); end - - def self.encode_uri_component(str, enc=T.unsafe(nil)); end - - def self.encode_www_form(enum, enc=T.unsafe(nil)); end - - def self.encode_www_form_component(str, enc=T.unsafe(nil)); end - - def self.extract(str, schemes=T.unsafe(nil), &block); end - - def self.for(scheme, *arguments, default: T.unsafe(nil)); end - - def self.get_encoding(label); end - - def self.join(*str); end - - def self.parse(uri); end - - def self.regexp(schemes=T.unsafe(nil)); end - - def self.register_scheme(scheme, klass); end - - def self.scheme_list(); end - - def self.split(uri); end -end - -module Bundler::URINormalizer -end - -module Bundler::URINormalizer - def self.normalize_suffix(uri, trailing_slash: T.unsafe(nil)); end -end - -module Bundler - def self.configure_gem_home_and_path(path=T.unsafe(nil)); end - - def self.create_bundle_path(); end - - def self.gem_version(); end - - def self.most_specific_locked_platform?(platform); end - - def self.original_exec(*args); end - - def self.original_system(*args); end - - def self.preferred_gemfile_name(); end - - def self.reset_settings_and_root!(); end - - def self.safe_load_marshal(data); end - - def self.self_manager(); end - - def self.unbundled_env(); end - - def self.unbundled_exec(*args); end - - def self.unbundled_system(*args); end -end - -class CGI - VERSION = ::T.let(nil, ::T.untyped) -end - -class CGI::Cookie - DOMAIN_VALUE_RE = ::T.let(nil, ::T.untyped) - PATH_VALUE_RE = ::T.let(nil, ::T.untyped) - TOKEN_RE = ::T.let(nil, ::T.untyped) -end - -module CGI::Escape - def escapeURIComponent(arg); end - - def unescapeURIComponent(*arg); 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 - -module CGI::Util - def escapeURIComponent(arg); end - - def unescapeURIComponent(*arg); end -end - -module Cachable - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Cask::Artifact::AbstractArtifact - extend ::T::Private::Abstract::Hooks -end - -module Cask::Cache - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Cask::Config - def appdir(); end - - def appdir=(path); end - - def audio_unit_plugindir(); end - - def audio_unit_plugindir=(path); end - - def colorpickerdir(); end - - def colorpickerdir=(path); end - - def dictionarydir(); end - - def dictionarydir=(path); end - - def fontdir(); end - - def fontdir=(path); end - - def input_methoddir(); end - - def input_methoddir=(path); end - - def internet_plugindir(); end - - def internet_plugindir=(path); end - - def keyboard_layoutdir(); end - - def keyboard_layoutdir=(path); end - - def mdimporterdir(); end - - def mdimporterdir=(path); end - - def prefpanedir(); end - - def prefpanedir=(path); end - - def qlplugindir(); end - - def qlplugindir=(path); end - - def screen_saverdir(); end - - def screen_saverdir=(path); end - - def servicedir(); end - - def servicedir=(path); end - - def vst3_plugindir(); end - - def vst3_plugindir=(path); end - - def vst_plugindir(); end - - def vst_plugindir=(path); end -end - -class Cask::DSL::Version - def dots_to_hyphens(); end - - def dots_to_underscores(); end - - def hyphens_to_dots(); end - - def hyphens_to_underscores(); end - - def no_dots(); end - - def no_hyphens(); end - - def no_underscores(); end - - def underscores_to_dots(); end - - def underscores_to_hyphens(); end -end - -module Cask::Denylist - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Class - def any_instance(); end - - def json_creatable?(); end -end - -class Date - def infinite?(); end - VERSION = ::T.let(nil, ::T.untyped) -end - -class Date::Infinity - def initialize(d=T.unsafe(nil)); end -end - -class DateTime - def self.new(*arg); end -end - -class Delegator - RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -class Dependencies - RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) -end - -class Dependencies - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -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 - -class DidYouMean::Formatter - def message_for(corrections); end -end - -class DidYouMean::Formatter - def self.message_for(corrections); end -end - -module DidYouMean::Jaro - def self.distance(str1, str2); end -end - -module DidYouMean::JaroWinkler - def self.distance(str1, str2); end -end - -class DidYouMean::KeyErrorChecker - def corrections(); end - - def initialize(key_error); end -end - -class DidYouMean::KeyErrorChecker -end - -module DidYouMean::Levenshtein - def self.distance(str1, str2); end - - def self.min3(a, b, c); end -end - -class DidYouMean::MethodNameChecker - def corrections(); end - - def initialize(exception); end - - def method_name(); end - - def method_names(); end - - def names_to_exclude(); end - - def receiver(); end - RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped) -end - -class DidYouMean::NullChecker - def corrections(); end - - def initialize(*arg); end -end - -class DidYouMean::PatternKeyNameChecker - def corrections(); end - - def initialize(no_matching_pattern_key_error); end -end - -class DidYouMean::PatternKeyNameChecker -end - -DidYouMean::PlainFormatter = DidYouMean::Formatter - -class DidYouMean::RequirePathChecker - def corrections(); end - - def initialize(exception); end - - def path(); end -end - -class DidYouMean::RequirePathChecker - def self.requireables(); end -end - -class DidYouMean::TreeSpellChecker - def augment(); end - - def correct(input); end - - def dictionary(); end - - def dictionary_without_leaves(); end - - def dimensions(); end - - def find_leaves(path); end - - def initialize(dictionary:, separator: T.unsafe(nil), augment: T.unsafe(nil)); end - - def plausible_dimensions(input); end - - def possible_paths(states); end - - def separator(); end - - def tree_depth(); end -end - -class DidYouMean::TreeSpellChecker -end - -class DidYouMean::VariableNameChecker - def corrections(); end - - def cvar_names(); end - - def initialize(exception); end - - def ivar_names(); end - - def lvar_names(); end - - def method_names(); end - - def name(); end - RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped) -end - -module DidYouMean - def self.correct_error(error_class, spell_checker); end - - def self.formatter(); end - - def self.formatter=(formatter); end - - def self.spell_checkers(); end -end - -module Digest - VERSION = ::T.let(nil, ::T.untyped) -end - -class Dir - def children(); end - - def each_child(); end -end - -module Dir::Tmpname - UNUSABLE_CHARS = ::T.let(nil, ::T.untyped) -end - -class Dir - def self.exists?(arg); end -end - -class ELFTools::LazyArray - RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) -end - -class ELFTools::Structs::ELF32_PhdrBe -end - -class ELFTools::Structs::ELF32_PhdrBe -end - -class ELFTools::Structs::ELF32_PhdrLe -end - -class ELFTools::Structs::ELF32_PhdrLe -end - -class ELFTools::Structs::ELF32_symBe -end - -class ELFTools::Structs::ELF32_symBe -end - -class ELFTools::Structs::ELF32_symLe -end - -class ELFTools::Structs::ELF32_symLe -end - -class ELFTools::Structs::ELF64_PhdrBe -end - -class ELFTools::Structs::ELF64_PhdrBe -end - -class ELFTools::Structs::ELF64_PhdrLe -end - -class ELFTools::Structs::ELF64_PhdrLe -end - -class ELFTools::Structs::ELF64_symBe -end - -class ELFTools::Structs::ELF64_symBe -end - -class ELFTools::Structs::ELF64_symLe -end - -class ELFTools::Structs::ELF64_symLe -end - -class ELFTools::Structs::ELF_DynBe -end - -class ELFTools::Structs::ELF_DynBe -end - -class ELFTools::Structs::ELF_DynLe -end - -class ELFTools::Structs::ELF_DynLe -end - -class ELFTools::Structs::ELF_EhdrBe -end - -class ELFTools::Structs::ELF_EhdrBe -end - -class ELFTools::Structs::ELF_EhdrLe -end - -class ELFTools::Structs::ELF_EhdrLe -end - -class ELFTools::Structs::ELF_NhdrBe -end - -class ELFTools::Structs::ELF_NhdrBe -end - -class ELFTools::Structs::ELF_NhdrLe -end - -class ELFTools::Structs::ELF_NhdrLe -end - -class ELFTools::Structs::ELF_RelBe -end - -class ELFTools::Structs::ELF_RelBe -end - -class ELFTools::Structs::ELF_RelLe -end - -class ELFTools::Structs::ELF_RelLe -end - -class ELFTools::Structs::ELF_RelaBe -end - -class ELFTools::Structs::ELF_RelaBe -end - -class ELFTools::Structs::ELF_RelaLe -end - -class ELFTools::Structs::ELF_RelaLe -end - -class ELFTools::Structs::ELF_ShdrBe -end - -class ELFTools::Structs::ELF_ShdrBe -end - -class ELFTools::Structs::ELF_ShdrLe -end - -class ELFTools::Structs::ELF_ShdrLe -end - -class ERB - def def_method(mod, methodname, fname=T.unsafe(nil)); end - - def def_module(methodname=T.unsafe(nil)); end -end - -class ERB::Compiler::Scanner - DEFAULT_ETAGS = ::T.let(nil, ::T.untyped) - DEFAULT_STAGS = ::T.let(nil, ::T.untyped) -end - -class Encoding - def _dump(*arg); end - CESU_8 = ::T.let(nil, ::T.untyped) - CP720 = ::T.let(nil, ::T.untyped) - IBM720 = ::T.let(nil, ::T.untyped) -end - -class Encoding::Converter - def initialize(*arg); end -end - -class Encoding - def self._load(arg); end -end - -module Enumerable - def compact(); end -end - -module Enumerable - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Enumerator - def +(arg); 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(*arg); end - - def step(); end -end - -class Enumerator::ArithmeticSequence -end - -class Enumerator::Generator - def each(*arg, &blk); end - - def initialize(*arg); end -end - -class Enumerator::Producer - def each(&blk); end -end - -class Enumerator::Producer -end - -class Errno::EAUTH - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EAUTH -end - -class Errno::EBADARCH - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EBADARCH -end - -class Errno::EBADEXEC - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EBADEXEC -end - -class Errno::EBADMACHO - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EBADMACHO -end - -class Errno::EBADRPC - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EBADRPC -end - -Errno::ECAPMODE = Errno::NOERROR - -Errno::EDEADLOCK = Errno::NOERROR - -class Errno::EDEVERR - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EDEVERR -end - -Errno::EDOOFUS = Errno::NOERROR - -class Errno::EFTYPE - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EFTYPE -end - -Errno::EIPSEC = Errno::NOERROR - -class Errno::ELAST - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::ELAST -end - -class Errno::ENEEDAUTH - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::ENEEDAUTH -end - -class Errno::ENOATTR - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::ENOATTR -end - -class Errno::ENOPOLICY - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::ENOPOLICY -end - -Errno::ENOTCAPABLE = Errno::NOERROR - -class Errno::ENOTSUP - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::ENOTSUP -end - -class Errno::EPROCLIM - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EPROCLIM -end - -class Errno::EPROCUNAVAIL - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EPROCUNAVAIL -end - -class Errno::EPROGMISMATCH - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EPROGMISMATCH -end - -class Errno::EPROGUNAVAIL - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EPROGUNAVAIL -end - -class Errno::EPWROFF - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::EPWROFF -end - -Errno::EQFULL = Errno::ELAST - -class Errno::ERPCMISMATCH - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::ERPCMISMATCH -end - -class Errno::ESHLIBVERS - Errno = ::T.let(nil, ::T.untyped) -end - -class Errno::ESHLIBVERS -end - -module Etc - VERSION = ::T.let(nil, ::T.untyped) -end - -class Etc::Group - def gid(); end - - def gid=(_); end - - def mem(); end - - def mem=(_); end - - def name(); end - - def name=(_); end - - def passwd(); end - - def passwd=(_); end -end - -class Etc::Group - extend ::Enumerable - def self.[](*arg); end - - def self.each(&blk); end - - def self.keyword_init?(); end - - def self.members(); end -end - -class Etc::Passwd - def change(); end - - def change=(_); end - - def dir=(_); end - - def expire(); end - - def expire=(_); end - - def gecos(); end - - def gecos=(_); end - - def gid=(_); end - - def name=(_); end - - def passwd=(_); end - - def shell=(_); end - - def uclass(); end - - def uclass=(_); end - - def uid=(_); end -end - -class Etc::Passwd - extend ::Enumerable - def self.[](*arg); end - - def self.each(&blk); end - - def self.keyword_init?(); end - - def self.members(); end -end - -class ExitCalledError -end - -class ExitCalledError -end - -class FalseClass - include ::JSON::Ext::Generator::GeneratorMethods::FalseClass -end - -class Fiber - def backtrace(*arg); end - - def backtrace_locations(*arg); end - - def blocking?(); end - - def initialize(*arg); end - - def transfer(*arg); end -end - -class Fiber - def self.blocking?(); end - - def self.current(); end - - def self.current_scheduler(); end - - def self.schedule(*arg); end - - def self.scheduler(); end - - def self.set_scheduler(arg); end -end - -module Fiddle - ALIGN_INT16_T = ::T.let(nil, ::T.untyped) - ALIGN_INT32_T = ::T.let(nil, ::T.untyped) - ALIGN_INT64_T = ::T.let(nil, ::T.untyped) - ALIGN_INT8_T = ::T.let(nil, ::T.untyped) - NULL = ::T.let(nil, ::T.untyped) - RTLD_GLOBAL = ::T.let(nil, ::T.untyped) - RTLD_LAZY = ::T.let(nil, ::T.untyped) - RTLD_NOW = ::T.let(nil, ::T.untyped) - SIZEOF_CONST_STRING = ::T.let(nil, ::T.untyped) - SIZEOF_INT16_T = ::T.let(nil, ::T.untyped) - SIZEOF_INT32_T = ::T.let(nil, ::T.untyped) - SIZEOF_INT64_T = ::T.let(nil, ::T.untyped) - SIZEOF_INT8_T = ::T.let(nil, ::T.untyped) - TYPE_CONST_STRING = ::T.let(nil, ::T.untyped) - TYPE_INT16_T = ::T.let(nil, ::T.untyped) - TYPE_INT32_T = ::T.let(nil, ::T.untyped) - TYPE_INT64_T = ::T.let(nil, ::T.untyped) - TYPE_INT8_T = ::T.let(nil, ::T.untyped) - TYPE_VARIADIC = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) - WINDOWS = ::T.let(nil, ::T.untyped) -end - -class Fiddle::CStruct - include ::Enumerable - def each(&blk); end - - def each_pair(); end - - def replace(another); end - - def to_h(); end -end - -class Fiddle::CStruct - def self.entity_class(); end - - def self.offsetof(name, members, types); end -end - -module Fiddle::CStructBuilder -end - -module Fiddle::CStructBuilder - def self.create(klass, types, members); end -end - -class Fiddle::CStructEntity - include ::Fiddle::PackInfo - include ::Fiddle::ValueUtil - def [](*args); end - - def []=(*args); end - - def assign_names(members); end - - def initialize(addr, types, func=T.unsafe(nil)); end - - def set_ctypes(types); end - - def to_s(); end -end - -class Fiddle::CStructEntity - def self.alignment(types); end - - def self.malloc(types, func=T.unsafe(nil), size=T.unsafe(nil), &block); end - - def self.size(types); end -end - -class Fiddle::CUnion -end - -class Fiddle::CUnion - def self.entity_class(); end - - def self.offsetof(name, members, types); end -end - -class Fiddle::CUnionEntity -end - -class Fiddle::CUnionEntity -end - -class Fiddle::ClearedReferenceError -end - -class Fiddle::ClearedReferenceError -end - -class Fiddle::CompositeHandler - def [](symbol); end - - def handlers(); end - - def initialize(handlers); end - - def sym(symbol); end -end - -class Fiddle::CompositeHandler -end - -class Fiddle::Error -end - -class Fiddle::Error -end - -class Fiddle::Function - def need_gvl?(); end - - def to_proc(); end -end - -class Fiddle::Handle - def file_name(); end - - def to_ptr(); end -end - -module Fiddle::Importer - include ::Fiddle - include ::Fiddle::CParser -end - -module Fiddle::Importer - extend ::Fiddle::Importer - extend ::Fiddle - extend ::Fiddle::CParser -end - -class Fiddle::MemoryView - def [](*arg); end - - def byte_size(); end - - def format(); end - - def initialize(arg); end - - def item_size(); end - - def ndim(); end - - def obj(); end - - def readonly?(); end - - def release(); end - - def shape(); end - - def strides(); end - - def sub_offsets(); end -end - -class Fiddle::MemoryView - def self.export(arg); end -end - -module Fiddle::PackInfo - ALIGN_MAP = ::T.let(nil, ::T.untyped) - PACK_MAP = ::T.let(nil, ::T.untyped) - SIZE_MAP = ::T.let(nil, ::T.untyped) -end - -module Fiddle::PackInfo - def self.align(addr, align); end -end - -class Fiddle::Packer - include ::Fiddle::PackInfo - def initialize(types); end - - def pack(ary); end - - def size(); end - - def unpack(ary); end -end - -class Fiddle::Packer - def self.[](*types); end -end - -class Fiddle::Pinned - def clear(); end - - def cleared?(); end - - def initialize(arg); end - - def ref(); end -end - -class Fiddle::Pinned -end - -class Fiddle::Pointer - def call_free(); end - - def freed?(); end -end - -class Fiddle::StructArray - include ::Fiddle::ValueUtil - def []=(index, value); end - - def initialize(ptr, type, initial_values); end - - def to_ptr(); end -end - -class Fiddle::StructArray -end - -module Fiddle::ValueUtil - def signed_value(val, ty); end - - def unsigned_value(val, ty); end - - def wrap_arg(arg, ty, funcs=T.unsafe(nil), &block); end - - def wrap_args(args, tys, funcs, &block); end -end - -module Fiddle::ValueUtil -end - -class File - def self.absolute_path?(arg); end - - def self.exists?(arg); end -end - -module FileUtils - include ::FileUtils::StreamUtils_ -end - -module FileUtils::DryRun - include ::FileUtils - include ::FileUtils::StreamUtils_ - include ::FileUtils::LowMethods -end - -module FileUtils::DryRun - extend ::FileUtils::DryRun - extend ::FileUtils - extend ::FileUtils::StreamUtils_ - extend ::FileUtils::LowMethods -end - -module FileUtils::NoWrite - include ::FileUtils - include ::FileUtils::StreamUtils_ - include ::FileUtils::LowMethods -end - -module FileUtils::NoWrite - extend ::FileUtils::NoWrite - extend ::FileUtils - extend ::FileUtils::StreamUtils_ - extend ::FileUtils::LowMethods -end - -module FileUtils::Verbose - include ::FileUtils - include ::FileUtils::StreamUtils_ -end - -module FileUtils::Verbose - extend ::FileUtils::Verbose - extend ::FileUtils - extend ::FileUtils::StreamUtils_ -end - -module FileUtils - extend ::FileUtils::StreamUtils_ -end - -class Float - include ::JSON::Ext::Generator::GeneratorMethods::Float -end - -module FormulaCellarChecks - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class FormulaConflict - def name(); end - - def name=(_); end - - def reason(); end - - def reason=(_); end -end - -class FormulaConflict - def self.[](*arg); end - - def self.keyword_init?(); end - - def self.members(); end -end - -module Forwardable - VERSION = ::T.let(nil, ::T.untyped) -end - -module Forwardable - def self._compile_method(src, file, line); end - - def self._delegator_method(obj, accessor, method, ali); end - - def self._valid_method?(method); end - - def self.debug(); end - - def self.debug=(debug); end -end - -module GC - def garbage_collect(full_mark: T.unsafe(nil), immediate_mark: T.unsafe(nil), immediate_sweep: T.unsafe(nil)); end -end - -module GC - def self.latest_compact_info(); end - - def self.using_rvargc?(); end - - def self.verify_transient_heap_internal_consistency(); end -end - -module Gem - ConfigMap = ::T.let(nil, ::T.untyped) - HAVE_OPENSSL = ::T.let(nil, ::T.untyped) - KERNEL_WARN_IGNORES_INTERNAL_ENTRIES = ::T.let(nil, ::T.untyped) - RbConfigPriorities = ::T.let(nil, ::T.untyped) - RubyGemsVersion = ::T.let(nil, ::T.untyped) - UNTAINT = ::T.let(nil, ::T.untyped) -end - -class Gem::BasicSpecification - def plugins(); end -end - -module Gem::BundlerVersionFinder - def self.prioritize!(specs); end -end - -class Gem::ConfigFile - def ipv4_fallback_enabled(); end - - def ipv4_fallback_enabled=(ipv4_fallback_enabled); end - DEFAULT_IPV4_FALLBACK_ENABLED = ::T.let(nil, ::T.untyped) -end - -class Gem::Dependency - include ::Bundler::ForcePlatform - def force_ruby_platform(); end - - def prioritizes_bundler?(); end -end - -class Gem::DependencyList - include ::Gem::TSort -end - -module Gem::Deprecate - def deprecate(name, repl, year, month); end -end - -module Gem::Deprecate - def self.next_rubygems_major_version(); end - - def self.rubygems_deprecate(name, replacement=T.unsafe(nil)); end - - def self.rubygems_deprecate_command(); end -end - -class Gem::Ext::BuildError -end - -class Gem::Ext::BuildError -end - -class Gem::Ext::CargoBuilder - def build(_extension, dest_path, results, args=T.unsafe(nil), lib_dir=T.unsafe(nil), cargo_dir=T.unsafe(nil)); end - - def build_crate(dest_path, results, args, cargo_dir); end - - def build_env(); end - - def cargo_command(cargo_dir, dest_path, args=T.unsafe(nil)); end - - def initialize(spec); end - - def profile(); end - - def profile=(profile); end - - def runner(); end - - def runner=(runner); end - - def spec(); end - - def spec=(spec); end -end - -class Gem::Ext::CargoBuilder::DylibNotFoundError - def initialize(dir); end -end - -class Gem::Ext::CargoBuilder::DylibNotFoundError -end - -class Gem::Ext::CargoBuilder -end - -class Gem::Ext::ExtConfBuilder -end - -class Gem::Ext::ExtConfBuilder - def self.build(extension, dest_path, results, args=T.unsafe(nil), lib_dir=T.unsafe(nil), extension_dir=T.unsafe(nil)); end - - def self.get_relative_path(path, base); end -end - -class Gem::Installer - include ::Gem::InstallerUninstallerUtils - def ensure_writable_dir(dir); end - - def explicit_version_requirement(name); end - - def gemdeps_load(name); end - - def generate_plugins(); end -end - -Gem::Installer::ExtensionBuildError = Gem::Ext::BuildError - -class Gem::Installer::FakePackage - def copy_to(path); end - - def data_mode(); end - - def data_mode=(data_mode); end - - def dir_mode(); end - - def dir_mode=(dir_mode); end - - def extract_files(destination_dir, pattern=T.unsafe(nil)); end - - def initialize(spec); end - - def prog_mode(); end - - def prog_mode=(prog_mode); end - - def spec(); end - - def spec=(spec); end -end - -class Gem::Installer::FakePackage -end - -class Gem::Installer - def self.inherited(klass); end -end - -module Gem::InstallerUninstallerUtils - def regenerate_plugins_for(spec, plugins_dir); end - - def remove_plugins_for(spec, plugins_dir); end -end - -module Gem::InstallerUninstallerUtils -end - -class Gem::Licenses - LICENSE_REF = ::T.let(nil, ::T.untyped) -end - -class Gem::PathSupport - def home(); end - - def initialize(env); end - - def path(); end - - def spec_cache_dir(); end -end - -class Gem::Platform - def normalized_linux_version(); end - - def normalized_linux_version_ext(); end - WINDOWS = ::T.let(nil, ::T.untyped) - X64_LINUX = ::T.let(nil, ::T.untyped) - X64_LINUX_MUSL = ::T.let(nil, ::T.untyped) -end - -class Gem::Platform - def self.match_gem?(platform, gem_name); end - - def self.match_spec?(spec); end - - def self.sort_priority(platform); end -end - -class Gem::Request - extend ::Gem::UserInteraction - extend ::Gem::DefaultUserInteraction - extend ::Gem::Text -end - -class Gem::RequestSet - include ::Gem::TSort -end - -class Gem::RequestSet::Lockfile::Tokenizer::Token - def self.keyword_init?(); end -end - -class Gem::Requirement - def _sorted_requirements(); end -end - -class Gem::Resolver::APISet::GemParser - def parse(line); end -end - -class Gem::Resolver::APISet::GemParser -end - -class Gem::Resolver::APISpecification - def self.new(set, api_data); end -end - -class Gem::Resolver::ActivationRequest - def eql?(other); end -end - -class Gem::Resolver::CurrentSet -end - -class Gem::Resolver::CurrentSet -end - -class Gem::Resolver::IndexSpecification - def ==(other); end -end - -class Gem::Resolver::InstallerSet - def force(); end - - def force=(force); end -end - -class Gem::Resolver::LocalSpecification -end - -class Gem::Resolver::LocalSpecification -end - -module Gem::Resolver::Molinillo::Delegates::ResolutionState - def unused_unwind_options(); end -end - -module Gem::Resolver::Molinillo::Delegates::SpecificationProvider - def dependencies_equal?(dependencies, other_dependencies); end -end - -class Gem::Resolver::Molinillo::DependencyGraph - include ::Gem::TSort -end - -class Gem::Resolver::Molinillo::DependencyGraph::Edge - def self.keyword_init?(); end -end - -class Gem::Resolver::Molinillo::DependencyGraph::Log - def add_edge_no_circular(graph, origin, destination, requirement); end - - def add_vertex(graph, name, payload, root); end - - def delete_edge(graph, origin_name, destination_name, requirement); end - - def detach_vertex_named(graph, name); end - - def each(&blk); end - - def pop!(graph); end - - def reverse_each(); end - - def rewind_to(graph, tag); end - - def set_payload(graph, name, payload); end - - def tag(graph, tag); end -end - -class Gem::Resolver::Molinillo::DependencyGraph::Log - extend ::Enumerable -end - -class Gem::Resolver::Molinillo::DependencyGraph::Vertex - def _path_to?(other, visited=T.unsafe(nil)); end - - def _recursive_predecessors(vertices=T.unsafe(nil)); end - - def _recursive_successors(vertices=T.unsafe(nil)); end -end - -class Gem::Resolver::Molinillo::ResolutionState - def unused_unwind_options(); end - - def unused_unwind_options=(_); end -end - -class Gem::Resolver::Molinillo::ResolutionState - def self.keyword_init?(); end -end - -class Gem::Resolver::Molinillo::Resolver::Resolution::Conflict - def possibility_set(); end - - def possibility_set=(_); end - - def underlying_error(); end - - def underlying_error=(_); end -end - -class Gem::Resolver::Molinillo::Resolver::Resolution::Conflict - def self.keyword_init?(); end -end - -class Gem::Resolver::Molinillo::Resolver::Resolution::PossibilitySet - def dependencies(); end - - def dependencies=(_); end - - def latest_version(); end - - def possibilities(); end - - def possibilities=(_); end -end - -class Gem::Resolver::Molinillo::Resolver::Resolution::PossibilitySet - def self.[](*arg); end - - def self.keyword_init?(); end - - def self.members(); end -end - -class Gem::Resolver::Molinillo::Resolver::Resolution::UnwindDetails - include ::Comparable - def all_requirements(); end - - def conflicting_requirements(); end - - def conflicting_requirements=(_); end - - def requirement_tree(); end - - def requirement_tree=(_); end - - def requirement_trees(); end - - def requirement_trees=(_); end - - def requirements_unwound_to_instead(); end - - def requirements_unwound_to_instead=(_); end - - def reversed_requirement_tree_index(); end - - def state_index(); end - - def state_index=(_); end - - def state_requirement(); end - - def state_requirement=(_); end - - def sub_dependencies_to_avoid(); end - - def unwinding_to_primary_requirement?(); end -end - -class Gem::Resolver::Molinillo::Resolver::Resolution::UnwindDetails - def self.[](*arg); end - - def self.keyword_init?(); end - - def self.members(); end -end - -module Gem::Resolver::Molinillo::SpecificationProvider - def dependencies_equal?(dependencies, other_dependencies); end -end - -class Gem::Resolver::Molinillo::VersionConflict - include ::Gem::Resolver::Molinillo::Delegates::SpecificationProvider - def message_with_trees(opts=T.unsafe(nil)); end - - def specification_provider(); end -end - -class Gem::Resolver::Specification - def required_ruby_version(); end - - def required_rubygems_version(); end -end - -class Gem::RuntimeRequirementNotMetError - def suggestion(); end - - def suggestion=(suggestion); end -end - -class Gem::RuntimeRequirementNotMetError -end - -class Gem::SpecFetcher - include ::Gem::UserInteraction - include ::Gem::DefaultUserInteraction - include ::Gem::Text - def available_specs(type); end - - def detect(type=T.unsafe(nil)); end - - def initialize(sources=T.unsafe(nil)); end - - def latest_specs(); end - - def prerelease_specs(); end - - def search_for_dependency(dependency, matching_platform=T.unsafe(nil)); end - - def sources(); end - - def spec_for_dependency(dependency, matching_platform=T.unsafe(nil)); end - - def specs(); end - - def suggest_gems_from_name(gem_name, type=T.unsafe(nil), num_results=T.unsafe(nil)); end - - def tuples_for(source, type, gracefully_ignore=T.unsafe(nil)); end -end - -class Gem::SpecFetcher - def self.fetcher(); end - - def self.fetcher=(fetcher); end -end - -class Gem::Specification - include ::Bundler::MatchMetadata - include ::Bundler::MatchPlatform - include ::Bundler::GemHelpers - include ::Gem::Specification::YamlBackfiller - def _deprecated_validate_dependencies(); end - - def _deprecated_validate_metadata(); end - - def _deprecated_validate_permissions(); end - - def deleted_gem?(); end - - def flatten_require_paths(); end - - def removed_method_calls(); end - - def to_ruby(); end - LATEST_RUBY_WITHOUT_PATCH_VERSIONS = ::T.let(nil, ::T.untyped) - REMOVED_METHODS = ::T.let(nil, ::T.untyped) -end - -module Gem::Specification::YamlBackfiller - def to_yaml(opts=T.unsafe(nil)); end -end - -module Gem::Specification::YamlBackfiller -end - -class Gem::Specification - extend ::Gem::Deprecate - extend ::Enumerable - def self.add_spec(spec); end - - def self.latest_spec_for(name); end - - def self.remove_spec(spec); end - - def self.stubs_for_pattern(pattern, match_platform=T.unsafe(nil)); end -end - -class Gem::SpecificationPolicy - include ::Gem::UserInteraction - include ::Gem::DefaultUserInteraction - include ::Gem::Text - def initialize(specification); end - - def packaging(); end - - def packaging=(packaging); end - - def validate(strict=T.unsafe(nil)); end - - def validate_dependencies(); end - - def validate_duplicate_dependencies(); end - - def validate_metadata(); end - - def validate_optional(strict); end - - def validate_permissions(); end - - def validate_required!(); end - HOMEPAGE_URI_PATTERN = ::T.let(nil, ::T.untyped) - LAZY = ::T.let(nil, ::T.untyped) - LAZY_PATTERN = ::T.let(nil, ::T.untyped) - METADATA_LINK_KEYS = ::T.let(nil, ::T.untyped) - SPECIAL_CHARACTERS = ::T.let(nil, ::T.untyped) - VALID_NAME_PATTERN = ::T.let(nil, ::T.untyped) - VALID_URI_PATTERN = ::T.let(nil, ::T.untyped) -end - -class Gem::SpecificationPolicy -end - -class Gem::StubSpecification - def build_extensions(); end - - def extensions(); end - - def initialize(filename, base_dir, gems_dir, default_gem); end - - def missing_extensions?(); end - - def valid?(); end -end - -class Gem::StubSpecification::StubLine - def extensions(); end - - def full_name(); end - - def initialize(data, extensions); end - - def name(); end - - def platform(); end - - def require_paths(); end - - def version(); end -end - -class Gem::StubSpecification - def self.default_gemspec_stub(filename, base_dir, gems_dir); end - - def self.gemspec_stub(filename, base_dir, gems_dir); end -end - -module Gem::TSort - def each_strongly_connected_component(&block); end - - def each_strongly_connected_component_from(node, id_map=T.unsafe(nil), stack=T.unsafe(nil), &block); end - - def strongly_connected_components(); end - - def tsort(); end - - def tsort_each(&block); end - - def tsort_each_child(node); end - - def tsort_each_node(); end -end - -module Gem::TSort - def self.each_strongly_connected_component(each_node, each_child); end - - def self.each_strongly_connected_component_from(node, each_child, id_map=T.unsafe(nil), stack=T.unsafe(nil)); end - - def self.strongly_connected_components(each_node, each_child); end - - def self.tsort(each_node, each_child); end - - def self.tsort_each(each_node, each_child); end -end - -class Gem::UninstallError - def spec(); end - - def spec=(spec); end -end - -class Gem::UninstallError -end - -class Gem::UnknownCommandError - def initialize(unknown_command); end - - def unknown_command(); end -end - -class Gem::UnknownCommandError - def self.attach_correctable(); end -end - -class Gem::UnknownCommandSpellChecker - def corrections(); end - - def error(); end - - def initialize(error); end -end - -class Gem::UnknownCommandSpellChecker -end - -Gem::UnsatisfiableDepedencyError = Gem::UnsatisfiableDependencyError - -module Gem::Util - def self._deprecated_silent_system(*command); end -end - -Gem::Version::Requirement = Gem::Requirement - -module Gem - def self.activated_gem_paths(); end - - def self.cache_home(); end - - def self.config_home(); end - - def self.data_home(); end - - def self.disable_system_update_message(); end - - def self.disable_system_update_message=(disable_system_update_message); end - - def self.find_config_file(); end - - def self.open_file(path, flags, &block); end - - def self.plugin_suffix_pattern(); end - - def self.plugin_suffix_regexp(); end - - def self.plugindir(install_dir=T.unsafe(nil)); end - - def self.solaris_platform?(); end -end - -module GitHub::Actions - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class GitHubRunner - def self.inherited(s); end -end - -class Hardware::CPU - def self.lm?(); end -end - -module Hardware - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Hash - include ::JSON::Ext::Generator::GeneratorMethods::Hash - def deconstruct_keys(arg); end -end - -class Hash - def self.ruby2_keywords_hash(arg); end - - def self.ruby2_keywords_hash?(arg); end -end - -module Homebrew::API::Analytics - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Homebrew::Completions::Variables - def aliases(); end - - def aliases=(_); end - - def builtin_command_descriptions(); end - - def builtin_command_descriptions=(_); end - - def completion_functions(); end - - def completion_functions=(_); end - - def function_mappings(); end - - def function_mappings=(_); end -end - -class Homebrew::Completions::Variables - def self.[](*arg); end - - def self.keyword_init?(); end - - def self.members(); end -end - -module Homebrew::Completions - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Homebrew::EnvConfig - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Homebrew::Fetch - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Homebrew::FreePort - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Homebrew::Livecheck::SkipConditions - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Homebrew::Parlour - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Homebrew::Service - def on_arch_conditional(arm: T.unsafe(nil), intel: T.unsafe(nil)); end - - def on_arm(&block); end - - def on_big_sur(or_condition=T.unsafe(nil), &block); end - - def on_catalina(or_condition=T.unsafe(nil), &block); end - - def on_el_capitan(or_condition=T.unsafe(nil), &block); end - - def on_high_sierra(or_condition=T.unsafe(nil), &block); end - - def on_intel(&block); end - - def on_linux(&block); end - - def on_macos(&block); end - - def on_mojave(or_condition=T.unsafe(nil), &block); end - - def on_monterey(or_condition=T.unsafe(nil), &block); end - - def on_sierra(or_condition=T.unsafe(nil), &block); end - - def on_sonoma(or_condition=T.unsafe(nil), &block); end - - def on_system(linux, macos:, &block); end - - def on_ventura(or_condition=T.unsafe(nil), &block); end -end - -module Homebrew - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks - extend ::FileUtils::StreamUtils_ -end - -module HostEnvironmentSimulatorHelper - def in_its_own_process_with(*files); end -end - -module HostEnvironmentSimulatorHelper -end - -class IO - def beep(); end - - def check_winsize_changed(); end - - def clear_screen(); end - - def console_mode(); end - - def console_mode=(console_mode); end - - def cooked(); end - - def cooked!(); end - - def cursor(); end - - def cursor=(cursor); end - - def cursor_down(arg); end - - def cursor_left(arg); end - - def cursor_right(arg); end - - def cursor_up(arg); end - - def echo=(echo); end - - def echo?(); end - - def erase_line(arg); end - - def erase_screen(arg); end - - def getch(*arg); end - - def getpass(*arg); end - - def goto(arg, arg1); end - - def goto_column(arg); end - - def iflush(); end - - def ioflush(); end - - def noecho(); end - - def nonblock(*arg); end - - def nonblock=(nonblock); end - - def nonblock?(); end - - def nread(); end - - def oflush(); end - - def pathconf(arg); end - - def pressed?(); end - - def raw(*arg); end - - def raw!(*arg); end - - def ready?(); end - - def scroll_backward(arg); end - - def scroll_forward(arg); end - - def wait(*arg); end - - def wait_priority(*arg); end - - def wait_readable(*arg); end - - def wait_writable(*arg); end - - def winsize(); end - - def winsize=(winsize); end - PRIORITY = ::T.let(nil, ::T.untyped) - READABLE = ::T.let(nil, ::T.untyped) - WRITABLE = ::T.let(nil, ::T.untyped) -end - -class IO::Buffer - include ::Comparable - def clear(*arg); end - - def copy(*arg); end - - def empty?(); end - - def external?(); end - - def free(); end - - def get_string(*arg); end - - def get_value(arg, arg1); end - - def hexdump(); end - - def initialize(*arg); end - - def internal?(); end - - def locked(); end - - def locked?(); end - - def mapped?(); end - - def null?(); end - - def pread(arg, arg1, arg2); end - - def pwrite(arg, arg1, arg2); end - - def read(arg, arg1); end - - def readonly?(); end - - def resize(arg); end - - def set_string(*arg); end - - def set_value(arg, arg1, arg2); end - - def size(); end - - def slice(arg, arg1); end - - def transfer(); end - - def valid?(); end - - def write(arg, arg1); end - BIG_ENDIAN = ::T.let(nil, ::T.untyped) - DEFAULT_SIZE = ::T.let(nil, ::T.untyped) - EXTERNAL = ::T.let(nil, ::T.untyped) - HOST_ENDIAN = ::T.let(nil, ::T.untyped) - INTERNAL = ::T.let(nil, ::T.untyped) - LITTLE_ENDIAN = ::T.let(nil, ::T.untyped) - LOCKED = ::T.let(nil, ::T.untyped) - MAPPED = ::T.let(nil, ::T.untyped) - NETWORK_ENDIAN = ::T.let(nil, ::T.untyped) - PAGE_SIZE = ::T.let(nil, ::T.untyped) - PRIVATE = ::T.let(nil, ::T.untyped) - READONLY = ::T.let(nil, ::T.untyped) -end - -class IO::Buffer::AccessError -end - -class IO::Buffer::AccessError -end - -class IO::Buffer::AllocationError -end - -class IO::Buffer::AllocationError -end - -class IO::Buffer::InvalidatedError -end - -class IO::Buffer::InvalidatedError -end - -class IO::Buffer::LockedError -end - -class IO::Buffer::LockedError -end - -class IO::Buffer - def self.for(arg); end - - def self.map(*arg); end -end - -class IO::ConsoleMode - def echo=(echo); end - - def raw(*arg); end - - def raw!(*arg); end -end - -class IO::ConsoleMode -end - -IO::EWOULDBLOCKWaitReadable = IO::EAGAINWaitReadable - -IO::EWOULDBLOCKWaitWritable = IO::EAGAINWaitWritable - -class IO - def self.console(*arg); end - - def self.console_size(); end - - def self.default_console_size(); end - - def self.new(*arg); end -end - -class IPAddr - def ==(other); end - - def initialize(addr=T.unsafe(nil), family=T.unsafe(nil)); end - - def netmask(); end - - def zone_id(); end - - def zone_id=(zid); end - VERSION = ::T.let(nil, ::T.untyped) -end - -module IRB - IRBRC_EXT = ::T.let(nil, ::T.untyped) - MagicFile = ::T.let(nil, ::T.untyped) - STDIN_FILE_NAME = ::T.let(nil, ::T.untyped) - TOPLEVEL_BINDING = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -module IRB::Color - BLUE = ::T.let(nil, ::T.untyped) - BOLD = ::T.let(nil, ::T.untyped) - CLEAR = ::T.let(nil, ::T.untyped) - CYAN = ::T.let(nil, ::T.untyped) - GREEN = ::T.let(nil, ::T.untyped) - MAGENTA = ::T.let(nil, ::T.untyped) - RED = ::T.let(nil, ::T.untyped) - REVERSE = ::T.let(nil, ::T.untyped) - UNDERLINE = ::T.let(nil, ::T.untyped) - YELLOW = ::T.let(nil, ::T.untyped) -end - -module IRB::Color - def self.clear(colorable: T.unsafe(nil)); end - - def self.colorable?(); end - - def self.colorize(text, seq, colorable: T.unsafe(nil)); end - - def self.colorize_code(code, complete: T.unsafe(nil), ignore_error: T.unsafe(nil), colorable: T.unsafe(nil)); end - - def self.inspect_colorable?(obj, seen: T.unsafe(nil)); end -end - -class IRB::Context - def __exit__(*arg); end - - def __inspect__(); end - - def __to_s__(); end - - def echo_on_assignment(); end - - def echo_on_assignment=(echo_on_assignment); end - - def echo_on_assignment?(); end - - def evaluate(line, line_no, exception: T.unsafe(nil)); end - - def extra_doc_dirs(); end - - def extra_doc_dirs=(extra_doc_dirs); end - - def initialize(irb, workspace=T.unsafe(nil), input_method=T.unsafe(nil)); end - - def inspect_last_value(); end - - def newline_before_multiline_output(); end - - def newline_before_multiline_output=(newline_before_multiline_output); end - - def newline_before_multiline_output?(); end - - def use_autocomplete(); end - - def use_autocomplete?(); end - - def use_colorize(); end - - def use_colorize?(); end - - def use_multiline(); end - - def use_multiline?(); end - - def use_reidline(); end - - def use_reidline?(); end - - def use_singleline(); end - - def use_singleline?(); end - IDNAME_IVARS = ::T.let(nil, ::T.untyped) - NOPRINTING_IVARS = ::T.let(nil, ::T.untyped) - NO_INSPECTING_IVARS = ::T.let(nil, ::T.untyped) -end - -class IRB::DefaultEncodings - def external(); end - - def external=(_); end - - def internal=(_); end -end - -class IRB::DefaultEncodings - def self.[](*arg); end - - def self.keyword_init?(); end - - def self.members(); end -end - -module IRB::ExtendCommandBundle - def irb(*opts, **kwargs, &b); end - - def irb_change_workspace(*opts, **kwargs, &b); end - - def irb_current_working_workspace(*opts, **kwargs, &b); end - - def irb_fg(*opts, **kwargs, &b); end - - def irb_help(*opts, **kwargs, &b); end - - def irb_info(*opts, **kwargs, &b); end - - def irb_jobs(*opts, **kwargs, &b); end - - def irb_kill(*opts, **kwargs, &b); end - - def irb_ls(*opts, **kwargs, &b); end - - def irb_measure(*opts, **kwargs, &b); end - - def irb_pop_workspace(*opts, **kwargs, &b); end - - def irb_push_workspace(*opts, **kwargs, &b); end - - def irb_show_source(*opts, **kwargs, &b); end - - def irb_source(*opts, **kwargs, &b); end - - def irb_whereami(*opts, **kwargs, &b); end - - def irb_workspaces(*opts, **kwargs, &b); end -end - -IRB::ExtendCommandBundle::EXCB = IRB::ExtendCommandBundle - -module IRB::ExtendCommandBundle - def self.irb_original_method_name(method_name); end -end - -class IRB::FileInputMethod - def close(); end - - def initialize(file); end -end - -class IRB::FileInputMethod - def self.open(file, &block); end -end - -module IRB::InputCompletor - BASIC_WORD_BREAK_CHARACTERS = ::T.let(nil, ::T.untyped) - CompletionProc = ::T.let(nil, ::T.untyped) - CompletionRequireProc = ::T.let(nil, ::T.untyped) - Operators = ::T.let(nil, ::T.untyped) - PerfectMatchedProc = ::T.let(nil, ::T.untyped) - ReservedWords = ::T.let(nil, ::T.untyped) -end - -module IRB::InputCompletor - def self.absolute_path?(p); end - - def self.ignored_modules(); end - - def self.retrieve_completion_data(input, bind: T.unsafe(nil), doc_namespace: T.unsafe(nil)); end - - def self.retrieve_files_to_require_from_load_path(); end - - def self.retrieve_files_to_require_relative_from_current_dir(); end - - def self.retrieve_gem_and_system_load_path(); end - - def self.select_message(receiver, message, candidates, sep=T.unsafe(nil)); end -end - -class IRB::InputMethod - def initialize(file=T.unsafe(nil)); end - - def winsize(); end -end - -class IRB::Inspector - def initialize(inspect_proc, init_proc=T.unsafe(nil)); end -end - -class IRB::Irb - def assignment_expression?(line); end - - def convert_invalid_byte_sequence(str, enc); end - - def encode_with_invalid_byte_sequence(str, enc); end - - def handle_exception(exc); end - - def initialize(workspace=T.unsafe(nil), input_method=T.unsafe(nil)); end - - def output_value(omit=T.unsafe(nil)); end - - def prompt(prompt, ltype, indent, line_no); end - ASSIGNMENT_NODE_TYPES = ::T.let(nil, ::T.untyped) -end - -class IRB::Locale - def String(mes); end - - def encoding(); end - - def find(file, paths=T.unsafe(nil)); end - - def format(*opts); end - - def gets(*rs); end - - def initialize(locale=T.unsafe(nil)); end - - def lang(); end - - def load(file, priv=T.unsafe(nil)); end - - def modifier(); end - - def print(*opts); end - - def printf(*opts); end - - def puts(*opts); end - - def readline(*rs); end - - def require(file, priv=T.unsafe(nil)); end - - def territory(); end - LOCALE_DIR = ::T.let(nil, ::T.untyped) - LOCALE_NAME_RE = ::T.let(nil, ::T.untyped) -end - -class IRB::Locale -end - -class IRB::OutputMethod::NotImplementedError - def initialize(val); end -end - -class IRB::ReadlineInputMethod - def initialize(); end -end - -class IRB::ReadlineInputMethod - def self.initialize_readline(); end -end - -class IRB::ReidlineInputMethod - include ::Reline - def auto_indent(&block); end - - def check_termination(&block); end - - def dynamic_prompt(&block); end - - def encoding(); end - - def eof?(); end - - def initialize(); end - - def line(line_no); end - SHOW_DOC_DIALOG = ::T.let(nil, ::T.untyped) -end - -class IRB::StdioInputMethod - def initialize(); end -end - -class IRB::WorkSpace - def initialize(*main); end - - def local_variable_get(name); end - - def local_variable_set(name, value); end -end - -module IRB - def self.Inspector(inspect, init=T.unsafe(nil)); end - - def self.delete_caller(); end - - def self.init_config(ap_path); end - - def self.init_error(); end - - def self.load_modules(); end - - def self.parse_opts(argv: T.unsafe(nil)); end - - def self.rc_file(ext=T.unsafe(nil)); end - - def self.rc_file_generators(); end - - def self.run_config(); end - - def self.set_measure_callback(type=T.unsafe(nil), arg=T.unsafe(nil), &block); end - - def self.setup(ap_path, argv: T.unsafe(nil)); end - - def self.unset_measure_callback(type=T.unsafe(nil)); end -end - -class Integer - include ::JSON::Ext::Generator::GeneratorMethods::Integer - def to_bn(); end -end - -class Integer - def self.try_convert(arg); end -end - -class JSON::Ext::Generator::State - def escape_slash(); end - - def escape_slash=(escape_slash); end - - def escape_slash?(); end - - def script_safe(); end - - def script_safe=(script_safe); end - - def script_safe?(); end - - def strict(); end - - def strict=(strict); end - - def strict?(); end -end - -class JSON::Ext::Generator::State - def self.from_state(arg); end -end - -class JSON::Ext::Parser - def initialize(*arg); end -end - -JSON::Parser = JSON::Ext::Parser - -JSON::State = JSON::Ext::Generator::State - -JSON::UnparserError = JSON::GeneratorError - -module JSON - def self.create_fast_state(); end - - def self.create_pretty_state(); end -end - -module Kernel - def agree(*args, **arg, &block); end - - def ask(*args, **arg, &block); end - - def choose(*args, **arg, &block); end - - def pretty_inspect(); end - - def say(*args, **arg, &block); end -end - -module Kernel - extend ::Forwardable - def self.at_exit(); end -end - -class KeyError - include ::DidYouMean::Correctable -end - -module Language::Java - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Language::Node::Shebang - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Language::Node - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Language::Perl::Shebang - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Language::Python::Shebang - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Language::Python::Virtualenv - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class LazyObject - RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) -end - -class LinuxRunnerSpec - def self.inherited(s); end -end - -class LoadError - include ::DidYouMean::Correctable -end - -class Logger - def debug!(); end - - def error!(); end - - def fatal!(); end - - def info!(); end - - def warn!(); end - SEV_LABEL = ::T.let(nil, ::T.untyped) -end - -class Logger::Formatter - DatetimeFormat = ::T.let(nil, ::T.untyped) - Format = ::T.let(nil, ::T.untyped) -end - -class Logger::LogDevice - include ::MonitorMixin -end - -module Logger::Period - SiD = ::T.let(nil, ::T.untyped) -end - -class MacOSRunnerSpec - def self.inherited(s); end -end - -class MatchData - def match(arg); end - - def match_length(arg); end -end - -class MessagePack::ExtensionValue - def self.keyword_init?(); end -end - -class MessagePack::Packer - def register_type_internal(arg, arg1, arg2); end - - def reset(); end - - def write_bin(arg); end - - def write_bin_header(arg); end -end - -class MessagePack::Unpacker - def feed_reference(arg); end - - def freeze?(); end -end - -class Method - def private?(); end - - def protected?(); end - - def public?(); end -end - -class Mktemp - include ::FileUtils::StreamUtils_ -end - -class Module - def context(*a, &b); end - - def describe(*a, &b); end - - def example_group(*a, &b); end - - def fcontext(*a, &b); end - - def fdescribe(*a, &b); end - - def shared_context(name, *args, &block); end - - def shared_examples(name, *args, &block); end - - def shared_examples_for(name, *args, &block); end - - def xcontext(*a, &b); end - - def xdescribe(*a, &b); end -end - -class Monitor - def enter(); end - - def exit(); end - - def mon_check_owner(); end - - def mon_enter(); end - - def mon_exit(); end - - def mon_locked?(); end - - def mon_owned?(); end - - def mon_synchronize(); end - - def mon_try_enter(); end - - def new_cond(); end - - def synchronize(); end - - def try_enter(); end - - def try_mon_enter(); end - - def wait_for_cond(arg, arg1); end -end - -module MonitorMixin - def initialize(*arg, **arg1, &arg2); end -end - -class MonitorMixin::ConditionVariable - def initialize(monitor); end -end - -class NameError - include ::ErrorHighlight::CoreExt - include ::DidYouMean::Correctable -end - -class Net::BufferedIO - def write_timeout(); end - - def write_timeout=(write_timeout); end -end - -class Net::HTTP - def extra_chain_cert(); end - - def extra_chain_cert=(extra_chain_cert); end - - def ignore_eof(); end - - def ignore_eof=(ignore_eof); end - - def ipaddr(); end - - def ipaddr=(addr); end - - def max_version(); end - - def max_version=(max_version); end - - def min_version(); end - - def min_version=(min_version); end - - def response_body_encoding(); end - - def response_body_encoding=(value); end - - def verify_hostname(); end - - def verify_hostname=(verify_hostname); end - - def write_timeout(); end - - def write_timeout=(sec); end - VERSION = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPAlreadyReported - HAS_BODY = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPAlreadyReported -end - -Net::HTTPClientErrorCode = Net::HTTPClientError - -class Net::HTTPEarlyHints - HAS_BODY = ::T.let(nil, ::T.untyped) -end - -class Net::HTTPEarlyHints -end - -Net::HTTPFatalErrorCode = Net::HTTPClientError - -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::HTTPRedirectionCode = Net::HTTPRedirection - -Net::HTTPRequestURITooLarge = Net::HTTPURITooLong - -Net::HTTPResponceReceiver = Net::HTTPResponse - -class Net::HTTPResponse - def body_encoding(); end - - def body_encoding=(value); end - - def ignore_eof(); end - - def ignore_eof=(ignore_eof); end -end - -class Net::HTTPResponse::Inflater - def bytes_inflated(); end -end - -Net::HTTPResponseReceiver = Net::HTTPResponse - -Net::HTTPRetriableCode = Net::HTTPRedirection - -Net::HTTPServerErrorCode = Net::HTTPServerError - -Net::HTTPSession = Net::HTTP - -class Net::HTTPSuccess -end - -Net::HTTPSuccessCode::EXCEPTION_TYPE = Net::HTTPError - -class Net::HTTPSuccess -end - -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::Protocol - VERSION = ::T.let(nil, ::T.untyped) -end - -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 NilClass - include ::JSON::Ext::Generator::GeneratorMethods::NilClass -end - -class NoMatchingPatternKeyError - include ::DidYouMean::Correctable - def key(); end - - def matchee(); end -end - -class NoMatchingPatternKeyError -end - -module OS::Linux::Glibc - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module OS::Linux::Kernel - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module OS::Mac::CLT - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module OS::Mac::Xcode - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module OS - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Object - include ::JSON::Ext::Generator::GeneratorMethods::Object - def __send(*arg); end - - def __send!(*arg); 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) - DEPRECATED_OFFICIAL_TAPS = ::T.let(nil, ::T.untyped) - ENV = ::T.let(nil, ::T.untyped) - FORMULA_COMPONENT_PRECEDENCE_LIST = ::T.let(nil, ::T.untyped) - GZIP_BUFFER_SIZE = ::T.let(nil, ::T.untyped) - HOMEBREW_API_DEFAULT_DOMAIN = ::T.let(nil, ::T.untyped) - HOMEBREW_API_WWW = ::T.let(nil, ::T.untyped) - HOMEBREW_BOTTLES_EXTNAME_REGEX = ::T.let(nil, ::T.untyped) - HOMEBREW_BOTTLE_DEFAULT_DOMAIN = ::T.let(nil, ::T.untyped) - HOMEBREW_BREWED_CURL_PATH = ::T.let(nil, ::T.untyped) - HOMEBREW_BREW_DEFAULT_GIT_REMOTE = ::T.let(nil, ::T.untyped) - HOMEBREW_BREW_FILE = ::T.let(nil, ::T.untyped) - HOMEBREW_CACHE = ::T.let(nil, ::T.untyped) - HOMEBREW_CACHE_FORMULA = ::T.let(nil, ::T.untyped) - HOMEBREW_CASK_APPDIR_PLACEHOLDER = ::T.let(nil, ::T.untyped) - HOMEBREW_CASK_TAP_CASK_REGEX = ::T.let(nil, ::T.untyped) - HOMEBREW_CELLAR = ::T.let(nil, ::T.untyped) - HOMEBREW_CELLAR_PLACEHOLDER = ::T.let(nil, ::T.untyped) - HOMEBREW_CORE_DEFAULT_GIT_REMOTE = ::T.let(nil, ::T.untyped) - HOMEBREW_DATA_PATH = ::T.let(nil, ::T.untyped) - HOMEBREW_DEFAULT_CACHE = ::T.let(nil, ::T.untyped) - HOMEBREW_DEFAULT_LOGS = ::T.let(nil, ::T.untyped) - HOMEBREW_DEFAULT_PREFIX = ::T.let(nil, ::T.untyped) - HOMEBREW_DEFAULT_REPOSITORY = ::T.let(nil, ::T.untyped) - HOMEBREW_DEFAULT_TAP_CASK_REGEX = ::T.let(nil, ::T.untyped) - HOMEBREW_DEFAULT_TEMP = ::T.let(nil, ::T.untyped) - HOMEBREW_DOCS_WWW = ::T.let(nil, ::T.untyped) - HOMEBREW_GITHUB_PACKAGES_AUTH = ::T.let(nil, ::T.untyped) - HOMEBREW_HOME_PLACEHOLDER = ::T.let(nil, ::T.untyped) - HOMEBREW_LIBRARY = ::T.let(nil, ::T.untyped) - HOMEBREW_LIBRARY_PATH = ::T.let(nil, ::T.untyped) - HOMEBREW_LINKED_KEGS = ::T.let(nil, ::T.untyped) - HOMEBREW_LINUX_DEFAULT_PREFIX = ::T.let(nil, ::T.untyped) - HOMEBREW_LINUX_DEFAULT_REPOSITORY = ::T.let(nil, ::T.untyped) - HOMEBREW_LOCKS = ::T.let(nil, ::T.untyped) - HOMEBREW_LOGS = ::T.let(nil, ::T.untyped) - HOMEBREW_MACOS_ARM_DEFAULT_PREFIX = ::T.let(nil, ::T.untyped) - HOMEBREW_MACOS_ARM_DEFAULT_REPOSITORY = ::T.let(nil, ::T.untyped) - HOMEBREW_MACOS_NEWEST_UNSUPPORTED = ::T.let(nil, ::T.untyped) - HOMEBREW_MACOS_OLDEST_ALLOWED = ::T.let(nil, ::T.untyped) - HOMEBREW_MACOS_OLDEST_SUPPORTED = ::T.let(nil, ::T.untyped) - HOMEBREW_MAINTAINER_JSON = ::T.let(nil, ::T.untyped) - HOMEBREW_OFFICIAL_REPO_PREFIXES_REGEX = ::T.let(nil, ::T.untyped) - HOMEBREW_PHYSICAL_PROCESSOR = ::T.let(nil, ::T.untyped) - HOMEBREW_PINNED_KEGS = ::T.let(nil, ::T.untyped) - HOMEBREW_PREFIX = ::T.let(nil, ::T.untyped) - HOMEBREW_PREFIX_PLACEHOLDER = ::T.let(nil, ::T.untyped) - HOMEBREW_PROCESSOR = ::T.let(nil, ::T.untyped) - HOMEBREW_PRODUCT = ::T.let(nil, ::T.untyped) - HOMEBREW_PULL_API_REGEX = ::T.let(nil, ::T.untyped) - HOMEBREW_PULL_OR_COMMIT_URL_REGEX = ::T.let(nil, ::T.untyped) - HOMEBREW_REPOSITORY = ::T.let(nil, ::T.untyped) - HOMEBREW_REQUIRED_RUBY_VERSION = ::T.let(nil, ::T.untyped) - HOMEBREW_RUBY_EXEC_ARGS = ::T.let(nil, ::T.untyped) - HOMEBREW_SHIMS_PATH = ::T.let(nil, ::T.untyped) - HOMEBREW_SYSTEM = ::T.let(nil, ::T.untyped) - HOMEBREW_TAP_CASK_REGEX = ::T.let(nil, ::T.untyped) - HOMEBREW_TAP_DIR_REGEX = ::T.let(nil, ::T.untyped) - HOMEBREW_TAP_FORMULA_REGEX = ::T.let(nil, ::T.untyped) - HOMEBREW_TAP_PATH_REGEX = ::T.let(nil, ::T.untyped) - HOMEBREW_TEMP = ::T.let(nil, ::T.untyped) - HOMEBREW_USER_AGENT_CURL = ::T.let(nil, ::T.untyped) - HOMEBREW_USER_AGENT_FAKE_SAFARI = ::T.let(nil, ::T.untyped) - HOMEBREW_USER_AGENT_RUBY = ::T.let(nil, ::T.untyped) - HOMEBREW_VERSION = ::T.let(nil, ::T.untyped) - HOMEBREW_WWW = ::T.let(nil, ::T.untyped) - LINUXBREW_CORE_MIGRATION_LIST = ::T.let(nil, ::T.untyped) - OFFICIAL_CASK_TAPS = ::T.let(nil, ::T.untyped) - OFFICIAL_CMD_TAPS = ::T.let(nil, ::T.untyped) - OS_VERSION = ::T.let(nil, ::T.untyped) - PATCH_A_SHA256 = ::T.let(nil, ::T.untyped) - PATCH_B_SHA256 = ::T.let(nil, ::T.untyped) - RUBY18 = ::T.let(nil, ::T.untyped) - RUBY19 = ::T.let(nil, ::T.untyped) - RUBY_BIN = ::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_PATH = ::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) - TESTBALL_PATCHES_SHA256 = ::T.let(nil, ::T.untyped) - TESTBALL_SHA256 = ::T.let(nil, ::T.untyped) - TEST_FIXTURE_DIR = ::T.let(nil, ::T.untyped) - TEST_SHA256 = ::T.let(nil, ::T.untyped) - TEST_TMPDIR = ::T.let(nil, ::T.untyped) - TOPLEVEL_BINDING = ::T.let(nil, ::T.untyped) -end - -class Object - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks - extend ::MacOSVersionErrorCompat - def self.hpricot_slate_method_added(name); end - - def self.yaml_tag(url); end -end - -module OnSystem::MacOSAndLinux - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module OnSystem::MacOSOnly - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module OnSystem - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Open3 - VERSION = ::T.let(nil, ::T.untyped) -end - -class OpenSSL::ASN1::ASN1Data - def indefinite_length(); end - - def indefinite_length=(indefinite_length); end -end - -class OpenSSL::BN - def +@(); end - - def -@(); end - - def /(arg); end - - def abs(); end - - def get_flags(arg); end - - def negative?(); end - - def set_flags(arg); end - CONSTTIME = ::T.let(nil, ::T.untyped) -end - -module OpenSSL::Buffering - def getbyte(); end -end - -class OpenSSL::Buffering::Buffer - def <<(string); end - - def concat(string); end - - def initialize(); end - BINARY = ::T.let(nil, ::T.untyped) -end - -class OpenSSL::Buffering::Buffer -end - -class OpenSSL::Cipher - def ccm_data_len=(ccm_data_len); end -end - -class OpenSSL::HMAC - def ==(other); end - - def base64digest(); end -end - -class OpenSSL::HMAC - def self.base64digest(digest, key, data); end -end - -module OpenSSL::Marshal - def _dump(_level); end -end - -module OpenSSL::Marshal::ClassMethods - def _load(string); end -end - -module OpenSSL::Marshal::ClassMethods -end - -module OpenSSL::Marshal - def self.included(base); end -end - -class OpenSSL::OCSP::Request - def signed?(); end -end - -OpenSSL::PKCS7::Signer = OpenSSL::PKCS7::SignerInfo - -class OpenSSL::PKey::DH - include ::OpenSSL::Marshal -end - -class OpenSSL::PKey::DH - extend ::OpenSSL::Marshal::ClassMethods - def self.new(*args, &blk); end -end - -class OpenSSL::PKey::DSA - include ::OpenSSL::Marshal -end - -class OpenSSL::PKey::DSA - extend ::OpenSSL::Marshal::ClassMethods - def self.new(*args, &blk); end -end - -class OpenSSL::PKey::EC - include ::OpenSSL::Marshal - EXPLICIT_CURVE = ::T.let(nil, ::T.untyped) -end - -class OpenSSL::PKey::EC::Point - def add(arg); end - - def to_octet_string(arg); end -end - -class OpenSSL::PKey::EC - extend ::OpenSSL::Marshal::ClassMethods -end - -class OpenSSL::PKey::PKey - def compare?(arg); end - - def decrypt(*arg); end - - def derive(*arg); end - - def encrypt(*arg); end - - def oid(); end - - def private_to_der(*arg); end - - def private_to_pem(*arg); end - - def public_to_der(); end - - def public_to_pem(); end - - def sign_raw(*arg); end - - def to_text(); end - - def verify_raw(*arg); end - - def verify_recover(*arg); end -end - -class OpenSSL::PKey::RSA - include ::OpenSSL::Marshal -end - -class OpenSSL::PKey::RSA - extend ::OpenSSL::Marshal::ClassMethods - def self.new(*args, &blk); end -end - -module OpenSSL::PKey - def self.generate_key(*arg); end - - def self.generate_parameters(*arg); end -end - -module OpenSSL::SSL - OP_ALLOW_CLIENT_RENEGOTIATION = ::T.let(nil, ::T.untyped) - OP_ALLOW_NO_DHE_KEX = ::T.let(nil, ::T.untyped) - OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION = ::T.let(nil, ::T.untyped) - OP_CLEANSE_PLAINTEXT = ::T.let(nil, ::T.untyped) - OP_CRYPTOPRO_TLSEXT_BUG = ::T.let(nil, ::T.untyped) - OP_DISABLE_TLSEXT_CA_NAMES = ::T.let(nil, ::T.untyped) - OP_ENABLE_KTLS = ::T.let(nil, ::T.untyped) - OP_ENABLE_MIDDLEBOX_COMPAT = ::T.let(nil, ::T.untyped) - OP_IGNORE_UNEXPECTED_EOF = ::T.let(nil, ::T.untyped) - OP_LEGACY_SERVER_CONNECT = ::T.let(nil, ::T.untyped) - OP_NO_ANTI_REPLAY = ::T.let(nil, ::T.untyped) - OP_NO_ENCRYPT_THEN_MAC = ::T.let(nil, ::T.untyped) - OP_NO_RENEGOTIATION = ::T.let(nil, ::T.untyped) - OP_NO_TLSv1_3 = ::T.let(nil, ::T.untyped) - OP_PRIORITIZE_CHACHA = ::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_3_VERSION = ::T.let(nil, ::T.untyped) - TLS1_VERSION = ::T.let(nil, ::T.untyped) -end - -class OpenSSL::SSL::SSLContext - 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 - - def tmp_dh=(tmp_dh); end - DEFAULT_TMP_DH_CALLBACK = ::T.let(nil, ::T.untyped) -end - -class OpenSSL::SSL::SSLSocket - def alpn_protocol(); end - - def finished_message(); end - - def peer_finished_message(); end - - def tmp_key(); end -end - -class OpenSSL::SSL::SSLSocket - def self.open(remote_host, remote_port, local_host=T.unsafe(nil), local_port=T.unsafe(nil), context: T.unsafe(nil)); end -end - -module OpenSSL::SSL::SocketForwarder - def fileno(); end -end - -module OpenSSL::Timestamp -end - -class OpenSSL::Timestamp::Factory - def additional_certs(); end - - def additional_certs=(additional_certs); end - - def allowed_digests(); end - - def allowed_digests=(allowed_digests); end - - def create_timestamp(arg, arg1, arg2); end - - def default_policy_id(); end - - def default_policy_id=(default_policy_id); end - - def gen_time(); end - - def gen_time=(gen_time); end - - def serial_number(); end - - def serial_number=(serial_number); end -end - -class OpenSSL::Timestamp::Factory -end - -class OpenSSL::Timestamp::Request - def algorithm(); end - - def algorithm=(algorithm); end - - def cert_requested=(cert_requested); end - - def cert_requested?(); end - - def initialize(*arg); end - - def message_imprint(); end - - def message_imprint=(message_imprint); end - - def nonce(); end - - def nonce=(nonce); end - - def policy_id(); end - - def policy_id=(policy_id); end - - def to_der(); end - - def version(); end - - def version=(version); end -end - -class OpenSSL::Timestamp::Request -end - -class OpenSSL::Timestamp::Response - def failure_info(); end - - def initialize(arg); end - - def status(); end - - def status_text(); end - - def to_der(); end - - def token(); end - - def token_info(); end - - def tsa_certificate(); end - - def verify(*arg); end - GRANTED = ::T.let(nil, ::T.untyped) - GRANTED_WITH_MODS = ::T.let(nil, ::T.untyped) - REJECTION = ::T.let(nil, ::T.untyped) - REVOCATION_NOTIFICATION = ::T.let(nil, ::T.untyped) - REVOCATION_WARNING = ::T.let(nil, ::T.untyped) - WAITING = ::T.let(nil, ::T.untyped) -end - -class OpenSSL::Timestamp::Response -end - -class OpenSSL::Timestamp::TimestampError -end - -class OpenSSL::Timestamp::TimestampError -end - -class OpenSSL::Timestamp::TokenInfo - def algorithm(); end - - def gen_time(); end - - def initialize(arg); end - - def message_imprint(); end - - def nonce(); end - - def ordering(); end - - def policy_id(); end - - def serial_number(); end - - def to_der(); end - - def version(); end -end - -class OpenSSL::Timestamp::TokenInfo -end - -module OpenSSL::Timestamp -end - -module OpenSSL::X509 - V_ERR_CA_KEY_TOO_SMALL = ::T.let(nil, ::T.untyped) - V_ERR_CA_MD_TOO_WEAK = ::T.let(nil, ::T.untyped) - V_ERR_CRL_PATH_VALIDATION_ERROR = ::T.let(nil, ::T.untyped) - V_ERR_DANE_NO_MATCH = ::T.let(nil, ::T.untyped) - V_ERR_DIFFERENT_CRL_SCOPE = ::T.let(nil, ::T.untyped) - V_ERR_EE_KEY_TOO_SMALL = ::T.let(nil, ::T.untyped) - V_ERR_EMAIL_MISMATCH = ::T.let(nil, ::T.untyped) - V_ERR_EXCLUDED_VIOLATION = ::T.let(nil, ::T.untyped) - V_ERR_HOSTNAME_MISMATCH = ::T.let(nil, ::T.untyped) - V_ERR_INVALID_CALL = ::T.let(nil, ::T.untyped) - V_ERR_INVALID_EXTENSION = ::T.let(nil, ::T.untyped) - V_ERR_INVALID_NON_CA = ::T.let(nil, ::T.untyped) - V_ERR_INVALID_POLICY_EXTENSION = ::T.let(nil, ::T.untyped) - V_ERR_IP_ADDRESS_MISMATCH = ::T.let(nil, ::T.untyped) - V_ERR_KEYUSAGE_NO_CRL_SIGN = ::T.let(nil, ::T.untyped) - V_ERR_KEYUSAGE_NO_DIGITAL_SIGNATURE = ::T.let(nil, ::T.untyped) - V_ERR_NO_EXPLICIT_POLICY = ::T.let(nil, ::T.untyped) - V_ERR_NO_VALID_SCTS = ::T.let(nil, ::T.untyped) - V_ERR_OCSP_CERT_UNKNOWN = ::T.let(nil, ::T.untyped) - V_ERR_OCSP_VERIFY_FAILED = ::T.let(nil, ::T.untyped) - V_ERR_OCSP_VERIFY_NEEDED = ::T.let(nil, ::T.untyped) - V_ERR_PATH_LOOP = ::T.let(nil, ::T.untyped) - V_ERR_PERMITTED_VIOLATION = ::T.let(nil, ::T.untyped) - V_ERR_PROXY_CERTIFICATES_NOT_ALLOWED = ::T.let(nil, ::T.untyped) - V_ERR_PROXY_PATH_LENGTH_EXCEEDED = ::T.let(nil, ::T.untyped) - V_ERR_PROXY_SUBJECT_NAME_VIOLATION = ::T.let(nil, ::T.untyped) - V_ERR_STORE_LOOKUP = ::T.let(nil, ::T.untyped) - V_ERR_SUBTREE_MINMAX = ::T.let(nil, ::T.untyped) - V_ERR_SUITE_B_CANNOT_SIGN_P_384_WITH_P_256 = ::T.let(nil, ::T.untyped) - V_ERR_SUITE_B_INVALID_ALGORITHM = ::T.let(nil, ::T.untyped) - V_ERR_SUITE_B_INVALID_CURVE = ::T.let(nil, ::T.untyped) - V_ERR_SUITE_B_INVALID_SIGNATURE_ALGORITHM = ::T.let(nil, ::T.untyped) - V_ERR_SUITE_B_INVALID_VERSION = ::T.let(nil, ::T.untyped) - V_ERR_SUITE_B_LOS_NOT_ALLOWED = ::T.let(nil, ::T.untyped) - V_ERR_UNABLE_TO_GET_CRL_ISSUER = ::T.let(nil, ::T.untyped) - V_ERR_UNHANDLED_CRITICAL_CRL_EXTENSION = ::T.let(nil, ::T.untyped) - V_ERR_UNHANDLED_CRITICAL_EXTENSION = ::T.let(nil, ::T.untyped) - V_ERR_UNNESTED_RESOURCE = ::T.let(nil, ::T.untyped) - V_ERR_UNSPECIFIED = ::T.let(nil, ::T.untyped) - V_ERR_UNSUPPORTED_CONSTRAINT_SYNTAX = ::T.let(nil, ::T.untyped) - V_ERR_UNSUPPORTED_CONSTRAINT_TYPE = ::T.let(nil, ::T.untyped) - V_ERR_UNSUPPORTED_EXTENSION_FEATURE = ::T.let(nil, ::T.untyped) - V_ERR_UNSUPPORTED_NAME_SYNTAX = ::T.let(nil, ::T.untyped) - V_FLAG_NO_CHECK_TIME = ::T.let(nil, ::T.untyped) - V_FLAG_PARTIAL_CHAIN = ::T.let(nil, ::T.untyped) - V_FLAG_SUITEB_128_LOS = ::T.let(nil, ::T.untyped) - V_FLAG_SUITEB_128_LOS_ONLY = ::T.let(nil, ::T.untyped) - V_FLAG_SUITEB_192_LOS = ::T.let(nil, ::T.untyped) - V_FLAG_TRUSTED_FIRST = ::T.let(nil, ::T.untyped) - V_FLAG_USE_CHECK_TIME = ::T.let(nil, ::T.untyped) -end - -class OpenSSL::X509::Attribute - include ::OpenSSL::Marshal - def ==(other); end -end - -class OpenSSL::X509::Attribute - extend ::OpenSSL::Marshal::ClassMethods -end - -class OpenSSL::X509::CRL - include ::OpenSSL::Marshal - include ::OpenSSL::X509::Extension::AuthorityKeyIdentifier - include ::OpenSSL::X509::Extension::Helpers - def ==(other); end -end - -class OpenSSL::X509::CRL - extend ::OpenSSL::Marshal::ClassMethods -end - -class OpenSSL::X509::Certificate - include ::OpenSSL::Marshal - include ::OpenSSL::X509::Extension::SubjectKeyIdentifier - include ::OpenSSL::X509::Extension::AuthorityKeyIdentifier - include ::OpenSSL::X509::Extension::CRLDistributionPoints - include ::OpenSSL::X509::Extension::AuthorityInfoAccess - include ::OpenSSL::X509::Extension::Helpers -end - -class OpenSSL::X509::Certificate - extend ::OpenSSL::Marshal::ClassMethods - def self.load(arg); end - - def self.load_file(path); end -end - -class OpenSSL::X509::Extension - include ::OpenSSL::Marshal - def ==(other); end - - def value_der(); end -end - -module OpenSSL::X509::Extension::AuthorityInfoAccess - include ::OpenSSL::X509::Extension::Helpers - def ca_issuer_uris(); end - - def ocsp_uris(); end -end - -module OpenSSL::X509::Extension::AuthorityInfoAccess -end - -module OpenSSL::X509::Extension::AuthorityKeyIdentifier - include ::OpenSSL::X509::Extension::Helpers - def authority_key_identifier(); end -end - -module OpenSSL::X509::Extension::AuthorityKeyIdentifier -end - -module OpenSSL::X509::Extension::CRLDistributionPoints - include ::OpenSSL::X509::Extension::Helpers - def crl_uris(); end -end - -module OpenSSL::X509::Extension::CRLDistributionPoints -end - -module OpenSSL::X509::Extension::Helpers - def find_extension(oid); end -end - -module OpenSSL::X509::Extension::Helpers -end - -module OpenSSL::X509::Extension::SubjectKeyIdentifier - include ::OpenSSL::X509::Extension::Helpers - def subject_key_identifier(); end -end - -module OpenSSL::X509::Extension::SubjectKeyIdentifier -end - -class OpenSSL::X509::Extension - extend ::OpenSSL::Marshal::ClassMethods -end - -class OpenSSL::X509::Name - include ::OpenSSL::Marshal - def to_utf8(); end -end - -class OpenSSL::X509::Name - extend ::OpenSSL::Marshal::ClassMethods -end - -class OpenSSL::X509::Request - include ::OpenSSL::Marshal - def ==(other); end -end - -class OpenSSL::X509::Request - extend ::OpenSSL::Marshal::ClassMethods -end - -class OpenSSL::X509::Revoked - def ==(other); end - - def to_der(); end -end - -module OpenSSL - def self.fips_mode(); end -end - -class OpenStruct - def __id__!(); end - - def __send__!(*arg); end - - def class!(); end - - def clone!(freeze: T.unsafe(nil)); end - - def define_singleton_method!(*arg); end - - def delete_field!(name); end - - def dig!(name, *names); end - - def display!(*arg); end - - def dup!(); end - - def each_pair!(); end - - def encode_with(coder); end - - def encode_with!(coder); end - - def enum_for!(*arg); end - - def extend!(mod, *args); end - - def freeze!(); end - - def gem!(dep, *reqs); end - - def hash!(); end - - def init_with(coder); end - - def init_with!(coder); end - - def inspect!(); end - - def instance_eval!(*arg); end - - def instance_exec!(*arg); end - - def instance_variable_get!(arg); end - - def instance_variable_set!(arg, arg1); end - - def instance_variables!(); end - - def itself!(); end - - def marshal_dump!(); end - - def method!(arg); end - - def methods!(*arg); end - - def object_id!(); end - - def private_methods!(*arg); end - - def protected_methods!(*arg); end - - def public_method!(arg); end - - def public_methods!(*arg); end - - def public_send!(*arg); end - - def remove_instance_variable!(arg); end - - def send!(*arg); end - - def singleton_class!(); end - - def singleton_method!(arg); end - - def singleton_methods!(*arg); end - - def taint!(); end - - def tap!(); end - - def then!(); end - - def to_enum!(*arg); end - - def to_h!(&block); end - - def to_s!(); end - - def trust!(); end - - def untaint!(); end - - def untrust!(); end - - def yield_self!(); end - VERSION = ::T.let(nil, ::T.untyped) -end - -class OptionParser - def additional_message(typ, opt); end - - def require_exact(); end - - def require_exact=(require_exact); end - Version = ::T.let(nil, ::T.untyped) -end - -class OptionParser::List - def get_candidates(id); end -end - -class OptionParser::ParseError - def additional(); end - - def additional=(additional); end -end - -class PP - def self.width_for(out); end -end - -class Parlour::Conversion::Converter - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks -end - -module Parlour::Debugging - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Parlour::Mixin::Searchable - extend ::T::Private::Abstract::Hooks - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Parlour::Plugin - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks -end - -module Parlour::TypeLoader - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Parlour::TypedObject - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks -end - -class Parlour::Types::Type - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks -end - -class Proc - def <<(arg); end - - def >>(arg); end - - def clone(); end -end - -class Process::Status - def self.wait(*arg); end -end - -class Process::Tms - def self.keyword_init?(); end -end - -module Process - def self._fork(); end -end - -module Psych - VERSION = ::T.let(nil, ::T.untyped) -end - -class Psych::ScalarScanner - INTEGER_LEGACY = ::T.let(nil, ::T.untyped) - INTEGER_STRICT = ::T.let(nil, ::T.untyped) -end - -class Psych::Visitors::RestrictedYAMLTree - def visit_Symbol(sym); end - DEFAULT_PERMITTED_CLASSES = ::T.let(nil, ::T.untyped) -end - -class Psych::Visitors::RestrictedYAMLTree -end - -class Psych::Visitors::Visitor - def self.dispatch_cache(); end -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.config(); end - - def self.domain_types(*args, **arg, &block); end - - def self.domain_types=(*args, **arg, &block); end - - def self.dump_tags(*args, **arg, &block); end - - def self.dump_tags=(*args, **arg, &block); end - - def self.libyaml_version(); end - - def self.load_tags(*args, **arg, &block); end - - def self.load_tags=(*args, **arg, &block); end - - def self.remove_type(type_tag); end - - def self.safe_dump(o, io=T.unsafe(nil), options=T.unsafe(nil)); end - - def self.unsafe_load(yaml, filename: T.unsafe(nil), fallback: T.unsafe(nil), symbolize_names: T.unsafe(nil), freeze: T.unsafe(nil), strict_integer: T.unsafe(nil)); end - - def self.unsafe_load_file(filename, **kwargs); end -end - -module PyPI - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class RBI::Index - include ::T::Enumerable -end - -module RBI::Indexable - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class RBI::Node - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks -end - -class RBI::Visitor - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks -end - -class RDoc::Alias - def initialize(text, old_name, new_name, comment, singleton=T.unsafe(nil)); end -end - -class RDoc::AnyMethod - def _call_seq(); end - - def section_title(); end - - def section_title=(section_title); end -end - -class RDoc::Attr - def initialize(text, name, rw, comment, singleton=T.unsafe(nil)); end -end - -class RDoc::ClassModule - def initialize(name, superclass=T.unsafe(nil)); end -end - -class RDoc::CodeObject - def initialize_visibility(); end -end - -class RDoc::Comment - def initialize(text=T.unsafe(nil), location=T.unsafe(nil), language=T.unsafe(nil)); end - - def line(); end - - def line=(line); end -end - -class RDoc::Constant - def initialize(name, value, comment); end -end - -class RDoc::Context - def add_module_by_normal_module(mod); end - - def initialize_methods_etc(); end - - def instance_methods(); end -end - -class RDoc::Context::Section - def initialize(parent, title, comment); end -end - -class RDoc::CrossReference - def initialize(context); end - - def resolve_method(name); end -end - -module RDoc::Encoding - HEADER_REGEXP = ::T.let(nil, ::T.untyped) -end - -module RDoc::Encoding - def self.detect_encoding(string); end - - def self.remove_magic_comment(string); end -end - -class RDoc::Generator::Darkfish - def initialize(store, options); end -end - -class RDoc::Generator::JsonIndex - def initialize(parent_generator, options); end -end - -class RDoc::Generator::POT - def initialize(store, options); end -end - -class RDoc::Generator::POT::MessageExtractor - def initialize(store); end -end - -class RDoc::Generator::POT::POEntry - def initialize(msgid, options=T.unsafe(nil)); end -end - -class RDoc::Generator::RI - def initialize(store, options); end -end - -class RDoc::I18n::Locale - def initialize(name); end -end - -class RDoc::I18n::Text - def initialize(raw); end -end - -class RDoc::Markdown - def _Table(); end - - def _TableColumn(); end - - def _TableItem(); end - - def _TableLine(); end - - def _TableRow(); end - - def initialize(extensions=T.unsafe(nil), debug=T.unsafe(nil)); end -end - -class RDoc::Markdown::Literals - def initialize(str, debug=T.unsafe(nil)); end -end - -class RDoc::Markdown::Literals::MemoEntry - def initialize(ans, pos); end -end - -class RDoc::Markdown::Literals::RuleInfo - def initialize(name, rendered); end -end - -class RDoc::Markdown::MemoEntry - def initialize(ans, pos); end -end - -class RDoc::Markdown::RuleInfo - def initialize(name, rendered); end -end - -class RDoc::Markup - def add_regexp_handling(pattern, name); end - - def initialize(attribute_manager=T.unsafe(nil)); end -end - -class RDoc::Markup::AttrChanger - def self.keyword_init?(); end -end - -class RDoc::Markup::AttrSpan - def initialize(length, exclusive); end -end - -class RDoc::Markup::AttributeManager - def add_regexp_handling(pattern, name, exclusive=T.unsafe(nil)); end - - def convert_attrs_matching_word_pairs(str, attrs, exclusive); end - - def convert_attrs_word_pair_map(str, attrs, exclusive); end - - def convert_regexp_handlings(str, attrs, exclusive=T.unsafe(nil)); end - - def exclusive?(attr); end - - def exclusive_bitmap(); end - - def regexp_handlings(); end - NON_PRINTING_END = ::T.let(nil, ::T.untyped) - NON_PRINTING_START = ::T.let(nil, ::T.untyped) -end - -class RDoc::Markup::Attributes - def regexp_handling(); end -end - -class RDoc::Markup::Document - def initialize(*parts); end -end - -class RDoc::Markup::Formatter - def add_regexp_handling_RDOCLINK(); end - - def add_regexp_handling_TIDYLINK(); end - - def convert_regexp_handling(target); end - - def initialize(options, markup=T.unsafe(nil)); end -end - -class RDoc::Markup::Formatter::InlineTag - def self.keyword_init?(); end -end - -class RDoc::Markup::Heading - def self.keyword_init?(); end -end - -class RDoc::Markup::Include - def initialize(file, include_path); end -end - -class RDoc::Markup::IndentedParagraph - def initialize(indent, *parts); end -end - -class RDoc::Markup::List - def initialize(type=T.unsafe(nil), *items); end -end - -class RDoc::Markup::ListItem - def initialize(label=T.unsafe(nil), *parts); end -end - -class RDoc::Markup::Parser::MyStringScanner - def [](i); end - - def eos?(); end - - def initialize(input); end - - def matched(); end - - def newline!(); end - - def pos(); end - - def scan(re); end - - def unscan(s); end -end - -class RDoc::Markup::Parser::MyStringScanner -end - -class RDoc::Markup::PreProcess - def initialize(input_file_name, include_path); end -end - -class RDoc::Markup::Raw - def initialize(*parts); end -end - -class RDoc::Markup::RegexpHandling - def ==(o); end - - def initialize(type, text); end - - def text(); end - - def text=(text); end - - def type(); end -end - -class RDoc::Markup::RegexpHandling -end - -class RDoc::Markup::Table - def ==(other); end - - def accept(visitor); end - - def align(); end - - def align=(align); end - - def body(); end - - def body=(body); end - - def header(); end - - def header=(header); end - - def initialize(header, align, body); end -end - -class RDoc::Markup::Table -end - -class RDoc::Markup::ToHtml - def accept_table(header, body, aligns); end - - def handle_regexp_HARD_BREAK(target); end - - def handle_regexp_HYPERLINK(target); end - - def handle_regexp_RDOCLINK(target); end - - def handle_regexp_TIDYLINK(target); end - - def init_link_notation_regexp_handlings(); end - - def init_regexp_handlings(); end -end - -class RDoc::Markup::ToHtmlCrossref - def handle_regexp_CROSSREF(target); end - - def initialize(options, from_path, context, markup=T.unsafe(nil)); end -end - -class RDoc::Markup::ToHtmlSnippet - def handle_regexp_CROSSREF(target); end - - def initialize(options, characters=T.unsafe(nil), paragraphs=T.unsafe(nil), markup=T.unsafe(nil)); end -end - -class RDoc::Markup::ToJoinedParagraph - def accept_table(*node); end - - def initialize(); end -end - -class RDoc::Markup::ToLabel - def handle_regexp_CROSSREF(target); end - - def handle_regexp_HARD_BREAK(*node); end - - def handle_regexp_TIDYLINK(target); end - - def initialize(markup=T.unsafe(nil)); end -end - -class RDoc::Markup::ToMarkdown - def handle_regexp_RDOCLINK(target); end - - def handle_regexp_TIDYLINK(target); end -end - -class RDoc::Markup::ToRdoc - def accept_table(header, body, aligns); end - - def handle_regexp_HARD_BREAK(target); end - - def handle_regexp_SUPPRESSED_CROSSREF(target); end - - def initialize(markup=T.unsafe(nil)); end -end - -class RDoc::Markup::ToTableOfContents - def accept_table(*node); end - - def initialize(); end -end - -class RDoc::Markup::ToTtOnly - def initialize(markup=T.unsafe(nil)); end -end - -class RDoc::MethodAttr - def initialize(text, name); end -end - -class RDoc::Mixin - def initialize(name, comment); end -end - -class RDoc::Options - def initialize(loaded_options=T.unsafe(nil)); end - - def override(map); end -end - -class RDoc::Options - def self.load_options(); end -end - -class RDoc::Parser - def initialize(top_level, file_name, content, options, stats); end -end - -class RDoc::Parser::C - def add_alias(var_name, class_obj, old_name, new_name, comment); end - - def do_classes_and_modules(); end - - def new_comment(text=T.unsafe(nil), location=T.unsafe(nil), language=T.unsafe(nil)); end -end - -class RDoc::Parser::ChangeLog - def parse_date(date); end -end - -module RDoc::Parser::ChangeLog::Git - def create_entries(entries); end - - def parse_entries(); end - - def parse_info(info); end - HEADING_LEVEL = ::T.let(nil, ::T.untyped) -end - -class RDoc::Parser::ChangeLog::Git::LogEntry - def accept(visitor); end - - def aref(); end - - def author(); end - - def author=(_); end - - def base(); end - - def base=(_); end - - def commit(); end - - def commit=(_); end - - def contents(); end - - def contents=(_); end - - def date(); end - - def date=(_); end - - def email(); end - - def email=(_); end - - def initialize(base, commit, author, email, date, contents); end - - def label(context=T.unsafe(nil)); end - - def level(); end - - def text(); end -end - -class RDoc::Parser::ChangeLog::Git::LogEntry - def self.[](*arg); end - - def self.keyword_init?(); end - - def self.members(); end -end - -module RDoc::Parser::ChangeLog::Git -end - -class RDoc::Parser::RipperStateLex - def get_squashed_tk(); end - - def initialize(code); end - EXPR_ARG = ::T.let(nil, ::T.untyped) - EXPR_ARG_ANY = ::T.let(nil, ::T.untyped) - EXPR_BEG = ::T.let(nil, ::T.untyped) - EXPR_BEG_ANY = ::T.let(nil, ::T.untyped) - EXPR_CLASS = ::T.let(nil, ::T.untyped) - EXPR_CMDARG = ::T.let(nil, ::T.untyped) - EXPR_DOT = ::T.let(nil, ::T.untyped) - EXPR_END = ::T.let(nil, ::T.untyped) - EXPR_ENDARG = ::T.let(nil, ::T.untyped) - EXPR_ENDFN = ::T.let(nil, ::T.untyped) - EXPR_END_ANY = ::T.let(nil, ::T.untyped) - EXPR_FITEM = ::T.let(nil, ::T.untyped) - EXPR_FNAME = ::T.let(nil, ::T.untyped) - EXPR_LABEL = ::T.let(nil, ::T.untyped) - EXPR_LABELED = ::T.let(nil, ::T.untyped) - EXPR_MID = ::T.let(nil, ::T.untyped) - EXPR_NONE = ::T.let(nil, ::T.untyped) - EXPR_VALUE = ::T.let(nil, ::T.untyped) - RIPPER_HAS_LEX_STATE = ::T.let(nil, ::T.untyped) -end - -class RDoc::Parser::RipperStateLex::InnerStateLex - def initialize(code); end - - def on_default(event, tok, data); end -end - -class RDoc::Parser::RipperStateLex::InnerStateLex -end - -class RDoc::Parser::RipperStateLex::Token - def char_no(); end - - def char_no=(_); end - - def kind(); end - - def kind=(_); end - - def line_no(); end - - def line_no=(_); end - - def state(); end - - def state=(_); end - - def text(); end - - def text=(_); end -end - -class RDoc::Parser::RipperStateLex::Token - def self.[](*arg); end - - def self.keyword_init?(); end - - def self.members(); end -end - -class RDoc::Parser::RipperStateLex - def self.end?(token); end - - def self.parse(code); end -end - -class RDoc::Parser::Ruby - def get_included_module_with_optional_parens(); end - - def parse_included_with_activesupport_concern(container, comment); end - - def retrieve_comment_body(tk); end -end - -module RDoc::Parser::RubyTools - def skip_tkspace_without_nl(); end -end - -class RDoc::RD::BlockParser - Racc_debug_parser = ::T.let(nil, ::T.untyped) -end - -class RDoc::RD::Inline - def initialize(rdoc, reference); end -end - -class RDoc::RD::InlineParser - def initialize(block_parser); end - Racc_debug_parser = ::T.let(nil, ::T.untyped) -end - -class RDoc::RI::Driver - def initialize(initial_options=T.unsafe(nil)); end -end - -class RDoc::RI::Driver::NotFoundError - def initialize(klass, suggestions=T.unsafe(nil)); end -end - -RDoc::RI::Store = RDoc::Store - -class RDoc::Require - def initialize(name, comment); end -end - -class RDoc::Stats - def initialize(store, num_files, verbosity=T.unsafe(nil)); end -end - -class RDoc::Stats::Quiet - def initialize(num_files); end -end - -class RDoc::Store - def initialize(path=T.unsafe(nil), type=T.unsafe(nil)); end - - def unmatched_constant_alias(); end - - def update_parser_of_file(absolute_name, parser); end -end - -class RDoc::Store::MissingFileError - def initialize(store, file, name); end -end - -module RDoc::Text - def language(); end - - def language=(language); end -end - -class RDoc::TopLevel - def initialize(absolute_name, relative_name=T.unsafe(nil)); end -end - -module RDoc - def self.home(); end -end - -class RSpec::Core::ExampleGroup - include ::RSpec::Core::MockingAdapters::RSpec - include ::RSpec::Mocks::ExampleMethods - include ::RSpec::Mocks::ArgumentMatchers - include ::RSpec::Mocks::ExampleMethods::ExpectHost - include ::RSpec::Matchers -end - -module RSpec::Core::HashImitatable - def assert_valid_keys(*args, &block); end - - def compact_blank(*args, &block); end - - def deep_merge(*args, &block); end - - def deep_merge!(*args, &block); end - - def deep_stringify_keys(*args, &block); end - - def deep_stringify_keys!(*args, &block); end - - def deep_symbolize_keys(*args, &block); end - - def deep_symbolize_keys!(*args, &block); end - - def deep_transform_keys(*args, &block); end - - def deep_transform_keys!(*args, &block); end - - def deep_transform_values(*args, &block); end - - def deep_transform_values!(*args, &block); end - - def exclude?(*args, &block); end - - def save_plist(*args, &block); end - - def to_plist(*args, &block); end -end - -module RSpec::Core::MockingAdapters -end - -module RSpec::Core::MockingAdapters::RSpec - include ::RSpec::Mocks::ExampleMethods - include ::RSpec::Mocks::ArgumentMatchers - include ::RSpec::Mocks::ExampleMethods::ExpectHost - def setup_mocks_for_rspec(); end - - def teardown_mocks_for_rspec(); end - - def verify_mocks_for_rspec(); end -end - -module RSpec::Core::MockingAdapters::RSpec - def self.configuration(); end - - def self.framework_name(); end -end - -module RSpec::Core::MockingAdapters -end - -class RSpec::Core::OutputWrapper - def readline_nonblock(*args, &block); end -end - -class RSpec::Expectations::MultipleExpectationsNotMetError - include ::RSpec::Core::MultipleExceptionError::InterfaceTag -end - -module RSpec::Sorbet::Doubles - extend ::T::Helpers - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Racc::CparseParams -end - -class Racc::CparseParams -end - -class Ractor::ClosedError -end - -class Ractor::ClosedError -end - -class Ractor::Error -end - -class Ractor::Error -end - -class Ractor::IsolationError -end - -class Ractor::IsolationError -end - -class Ractor::MovedError -end - -class Ractor::MovedError -end - -class Ractor::MovedObject - def !(*arg); end - - def !=(*arg); end - - def ==(*arg); end - - def __id__(*arg); end - - def equal?(*arg); end -end - -class Ractor::MovedObject -end - -class Ractor::RemoteError - def ractor(); end -end - -class Ractor::RemoteError -end - -class Ractor::UnsafeError -end - -class Ractor::UnsafeError -end - -class Ractor - def self.new(*args, name: T.unsafe(nil), &block); end -end - -class Random::Base - include ::Random::Formatter - def bytes(arg); end - - def initialize(*arg); end - - def seed(); end -end - -class Random::Base - extend ::Random::Formatter -end - -class Random - def self.bytes(arg); end - - def self.seed(); end -end - -class Range - def %(arg); 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 -end - -module Reline - DEFAULT_DIALOG_CONTEXT = ::T.let(nil, ::T.untyped) - DEFAULT_DIALOG_PROC_AUTOCOMPLETE = ::T.let(nil, ::T.untyped) - FILENAME_COMPLETION_PROC = ::T.let(nil, ::T.untyped) - HISTORY = ::T.let(nil, ::T.untyped) - USERNAME_COMPLETION_PROC = ::T.let(nil, ::T.untyped) - VERSION = ::T.let(nil, ::T.untyped) -end - -class Reline::Config - KEYSEQ_PATTERN = ::T.let(nil, ::T.untyped) - VARIABLE_NAMES = ::T.let(nil, ::T.untyped) - VARIABLE_NAME_SYMBOLS = ::T.let(nil, ::T.untyped) -end - -class Reline::Core - ATTR_READER_NAMES = ::T.let(nil, ::T.untyped) -end - -Reline::IOGate = Reline::GeneralIO - -Reline::Key = Struct::Key - -class Reline::KeyActor::Base - MAPPING = ::T.let(nil, ::T.untyped) -end - -class Reline::KeyActor::Emacs - MAPPING = ::T.let(nil, ::T.untyped) -end - -class Reline::KeyActor::ViCommand - MAPPING = ::T.let(nil, ::T.untyped) -end - -class Reline::KeyActor::ViInsert - MAPPING = ::T.let(nil, ::T.untyped) -end - -module Reline::KillRing::State - CONTINUED = ::T.let(nil, ::T.untyped) - FRESH = ::T.let(nil, ::T.untyped) - PROCESSED = ::T.let(nil, ::T.untyped) - YANK = ::T.let(nil, ::T.untyped) -end - -class Reline::LineEditor - DIALOG_DEFAULT_HEIGHT = ::T.let(nil, ::T.untyped) - PROMPT_LIST_CACHE_TIMEOUT = ::T.let(nil, ::T.untyped) - VI_MOTIONS = ::T.let(nil, ::T.untyped) -end - -Reline::LineEditor::CompletionJourneyData = Struct::CompletionJourneyData - -module Reline::LineEditor::CompletionState - COMPLETION = ::T.let(nil, ::T.untyped) - JOURNEY = ::T.let(nil, ::T.untyped) - MENU = ::T.let(nil, ::T.untyped) - MENU_WITH_PERFECT_MATCH = ::T.let(nil, ::T.untyped) - NORMAL = ::T.let(nil, ::T.untyped) - PERFECT_MATCH = ::T.let(nil, ::T.untyped) -end - -Reline::LineEditor::MenuInfo = Struct::MenuInfo - -module Reline::Terminfo - extend ::Fiddle - extend ::Fiddle::CParser -end - -class Reline::Unicode - CSI_REGEXP = ::T.let(nil, ::T.untyped) - CSI_REGEXP_INDEX = ::T.let(nil, ::T.untyped) - EscapedChars = ::T.let(nil, ::T.untyped) - EscapedPairs = ::T.let(nil, ::T.untyped) - GRAPHEME_CLUSTER_INDEX = ::T.let(nil, ::T.untyped) - HalfwidthDakutenHandakuten = ::T.let(nil, ::T.untyped) - MBCharWidthRE = ::T.let(nil, ::T.untyped) - NON_PRINTING_END = ::T.let(nil, ::T.untyped) - NON_PRINTING_END_INDEX = ::T.let(nil, ::T.untyped) - NON_PRINTING_START = ::T.let(nil, ::T.untyped) - NON_PRINTING_START_INDEX = ::T.let(nil, ::T.untyped) - OSC_REGEXP = ::T.let(nil, ::T.untyped) - OSC_REGEXP_INDEX = ::T.let(nil, ::T.untyped) - WIDTH_SCANNER = ::T.let(nil, ::T.untyped) -end - -class Reline::Unicode::EastAsianWidth - TYPE_A = ::T.let(nil, ::T.untyped) - TYPE_F = ::T.let(nil, ::T.untyped) - TYPE_H = ::T.let(nil, ::T.untyped) - TYPE_N = ::T.let(nil, ::T.untyped) - TYPE_NA = ::T.let(nil, ::T.untyped) - TYPE_W = ::T.let(nil, ::T.untyped) -end - -class Requirements - RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) -end - -class Requirements - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Resolv::DNS - def extract_resources(msg, name, typeclass); end - RequestID = ::T.let(nil, ::T.untyped) - RequestIDMutex = ::T.let(nil, ::T.untyped) -end - -class Resolv::DNS::Config - def initialize(config_info=T.unsafe(nil)); end -end - -class Resolv::DNS::Label::Str - def initialize(string); end -end - -class Resolv::DNS::Message - def initialize(id=T.unsafe(nil)); end -end - -class Resolv::DNS::Message::MessageDecoder - def initialize(data); end -end - -class Resolv::DNS::Requester::ConnectedUDP - def initialize(host, port=T.unsafe(nil)); end - - def lazy_initialize(); end -end - -class Resolv::DNS::Requester::Sender - def initialize(msg, data, sock); end -end - -class Resolv::DNS::Requester::TCP - def initialize(host, port=T.unsafe(nil)); end -end - -class Resolv::DNS::Requester::UnconnectedUDP - def initialize(*nameserver_port); end - - def lazy_initialize(); end -end - -class Resolv::DNS::Requester::UnconnectedUDP::Sender - def initialize(msg, data, sock, host, port); end -end - -class Resolv::DNS::Resource - ClassValue = ::T.let(nil, ::T.untyped) -end - -class Resolv::DNS::Resource::LOC - def initialize(version, ssize, hprecision, vprecision, latitude, longitude, altitude); 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::IPv6 - Regex_8HexLinkLocal = ::T.let(nil, ::T.untyped) - Regex_CompressedHexLinkLocal = ::T.let(nil, ::T.untyped) -end - -class Ripper - def column(); end - - def debug_output(); end - - def debug_output=(debug_output); end - - def encoding(); end - - def end_seen?(); end - - def error?(); end - - def filename(); end - - def initialize(*arg); end - - def lineno(); end - - def parse(); end - - def state(); end - - def token(); end - - def yydebug(); end - - def yydebug=(yydebug); end - EXPR_ARG = ::T.let(nil, ::T.untyped) - EXPR_ARG_ANY = ::T.let(nil, ::T.untyped) - EXPR_BEG = ::T.let(nil, ::T.untyped) - EXPR_BEG_ANY = ::T.let(nil, ::T.untyped) - EXPR_CLASS = ::T.let(nil, ::T.untyped) - EXPR_CMDARG = ::T.let(nil, ::T.untyped) - EXPR_DOT = ::T.let(nil, ::T.untyped) - EXPR_END = ::T.let(nil, ::T.untyped) - EXPR_ENDARG = ::T.let(nil, ::T.untyped) - EXPR_ENDFN = ::T.let(nil, ::T.untyped) - EXPR_END_ANY = ::T.let(nil, ::T.untyped) - EXPR_FITEM = ::T.let(nil, ::T.untyped) - EXPR_FNAME = ::T.let(nil, ::T.untyped) - EXPR_LABEL = ::T.let(nil, ::T.untyped) - EXPR_LABELED = ::T.let(nil, ::T.untyped) - EXPR_MID = ::T.let(nil, ::T.untyped) - EXPR_NONE = ::T.let(nil, ::T.untyped) - EXPR_VALUE = ::T.let(nil, ::T.untyped) - Version = ::T.let(nil, ::T.untyped) -end - -class Ripper::Filter - def initialize(src, filename=T.unsafe(nil), lineno=T.unsafe(nil)); end -end - -class Ripper::Lexer - def errors(); end - - def lex(**kw); end - - def parse(raise_errors: T.unsafe(nil)); end - - def scan(**kw); end - - def tokenize(**kw); end -end - -class Ripper::Lexer::Elem - def [](index); end - - def event(); end - - def event=(event); end - - def initialize(pos, event, tok, state, message=T.unsafe(nil)); end - - def message(); end - - def message=(message); end - - def pos(); end - - def pos=(pos); end - - def state(); end - - def state=(state); end - - def to_a(); end - - def tok(); end - - def tok=(tok); end -end - -class Ripper::Lexer::Elem -end - -class Ripper::Lexer::State - def &(i); end - - def ==(i); end - - def [](index); end - - def allbits?(i); end - - def anybits?(i); end - - def initialize(i); end - - def nobits?(i); end - - def to_i(); end - - def to_int(); end - - def |(i); end -end - -class Ripper::Lexer::State -end - -class Ripper::Lexer -end - -class Ripper::SexpBuilder - def on_BEGIN(*args); end - - def on_CHAR(tok); end - - def on_END(*args); end - - def on___end__(tok); end - - def on_alias(*args); end - - def on_alias_error(*args); end - - def on_aref(*args); end - - def on_aref_field(*args); end - - def on_arg_ambiguous(*args); end - - def on_arg_paren(*args); end - - def on_args_add(*args); end - - def on_args_add_block(*args); end - - def on_args_add_star(*args); end - - def on_args_forward(*args); end - - def on_args_new(*args); end - - def on_array(*args); end - - def on_aryptn(*args); end - - def on_assign(*args); end - - def on_assign_error(*args); end - - def on_assoc_new(*args); end - - def on_assoc_splat(*args); end - - def on_assoclist_from_args(*args); end - - def on_backref(tok); end - - def on_backtick(tok); end - - def on_bare_assoc_hash(*args); end - - def on_begin(*args); end - - def on_binary(*args); end - - def on_block_var(*args); end - - def on_blockarg(*args); end - - def on_bodystmt(*args); end - - def on_brace_block(*args); end - - def on_break(*args); end - - def on_call(*args); end - - def on_case(*args); end - - def on_class(*args); end - - def on_class_name_error(*args); end - - def on_comma(tok); end - - def on_command(*args); end - - def on_command_call(*args); end - - def on_comment(tok); end - - def on_const(tok); end - - def on_const_path_field(*args); end - - def on_const_path_ref(*args); end - - def on_const_ref(*args); end - - def on_cvar(tok); end - - def on_def(*args); end - - def on_defined(*args); end - - def on_defs(*args); end - - def on_do_block(*args); end - - def on_dot2(*args); end - - def on_dot3(*args); end - - def on_dyna_symbol(*args); end - - def on_else(*args); end - - def on_elsif(*args); end - - def on_embdoc(tok); end - - def on_embdoc_beg(tok); end - - def on_embdoc_end(tok); end - - def on_embexpr_beg(tok); end - - def on_embexpr_end(tok); end - - def on_embvar(tok); end - - def on_ensure(*args); end - - def on_excessed_comma(*args); end - - def on_fcall(*args); end - - def on_field(*args); end - - def on_float(tok); end - - def on_fndptn(*args); end - - def on_for(*args); end - - def on_gvar(tok); end - - def on_hash(*args); end - - def on_heredoc_beg(tok); end - - def on_heredoc_end(tok); end - - def on_hshptn(*args); end - - def on_ident(tok); end - - def on_if(*args); end - - def on_if_mod(*args); end - - def on_ifop(*args); end - - def on_ignored_nl(tok); end - - def on_ignored_sp(tok); end - - def on_imaginary(tok); end - - def on_in(*args); end - - def on_int(tok); end - - def on_ivar(tok); end - - def on_kw(tok); end - - def on_kwrest_param(*args); end - - def on_label(tok); end - - def on_label_end(tok); end - - def on_lambda(*args); end - - def on_lbrace(tok); end - - def on_lbracket(tok); end - - def on_lparen(tok); end - - def on_magic_comment(*args); end - - def on_massign(*args); end - - def on_method_add_arg(*args); end - - def on_method_add_block(*args); end - - def on_mlhs_add(*args); end - - def on_mlhs_add_post(*args); end - - def on_mlhs_add_star(*args); end - - def on_mlhs_new(*args); end - - def on_mlhs_paren(*args); end - - def on_module(*args); end - - def on_mrhs_add(*args); end - - def on_mrhs_add_star(*args); end - - def on_mrhs_new(*args); end - - def on_mrhs_new_from_args(*args); end - - def on_next(*args); end - - def on_nl(tok); end - - def on_nokw_param(*args); end - - def on_op(tok); end - - def on_opassign(*args); end - - def on_operator_ambiguous(*args); end - - def on_param_error(*args); end - - def on_params(*args); end - - def on_paren(*args); end - - def on_period(tok); end - - def on_program(*args); end - - def on_qsymbols_add(*args); end - - def on_qsymbols_beg(tok); end - - def on_qsymbols_new(*args); end - - def on_qwords_add(*args); end - - def on_qwords_beg(tok); end - - def on_qwords_new(*args); end - - def on_rational(tok); end - - def on_rbrace(tok); end - - def on_rbracket(tok); end - - def on_redo(*args); end - - def on_regexp_add(*args); end - - def on_regexp_beg(tok); end - - def on_regexp_end(tok); end - - def on_regexp_literal(*args); end - - def on_regexp_new(*args); end - - def on_rescue(*args); end - - def on_rescue_mod(*args); end - - def on_rest_param(*args); end - - def on_retry(*args); end - - def on_return(*args); end - - def on_return0(*args); end - - def on_rparen(tok); end - - def on_sclass(*args); end - - def on_semicolon(tok); end - - def on_sp(tok); end - - def on_stmts_add(*args); end - - def on_stmts_new(*args); end - - def on_string_add(*args); end - - def on_string_concat(*args); end - - def on_string_content(*args); end - - def on_string_dvar(*args); end - - def on_string_embexpr(*args); end - - def on_string_literal(*args); end - - def on_super(*args); end - - def on_symbeg(tok); end - - def on_symbol(*args); end - - def on_symbol_literal(*args); end - - def on_symbols_add(*args); end - - def on_symbols_beg(tok); end - - def on_symbols_new(*args); end - - def on_tlambda(tok); end - - def on_tlambeg(tok); end - - def on_top_const_field(*args); end - - def on_top_const_ref(*args); end - - def on_tstring_beg(tok); end - - def on_tstring_content(tok); end - - def on_tstring_end(tok); end - - def on_unary(*args); end - - def on_undef(*args); end - - def on_unless(*args); end - - def on_unless_mod(*args); end - - def on_until(*args); end - - def on_until_mod(*args); end - - def on_var_alias(*args); end - - def on_var_field(*args); end - - def on_var_ref(*args); end - - def on_vcall(*args); end - - def on_void_stmt(*args); end - - def on_when(*args); end - - def on_while(*args); end - - def on_while_mod(*args); end - - def on_word_add(*args); end - - def on_word_new(*args); end - - def on_words_add(*args); end - - def on_words_beg(tok); end - - def on_words_new(*args); end - - def on_words_sep(tok); end - - def on_xstring_add(*args); end - - def on_xstring_literal(*args); end - - def on_xstring_new(*args); end - - def on_yield(*args); end - - def on_yield0(*args); end - - def on_zsuper(*args); end -end - -class Ripper::TokenPattern - def initialize(pattern); end - - def match(str); end - - def match_list(tokens); end - MAP = ::T.let(nil, ::T.untyped) -end - -class Ripper::TokenPattern::CompileError -end - -class Ripper::TokenPattern::CompileError -end - -class Ripper::TokenPattern::Error -end - -class Ripper::TokenPattern::Error -end - -class Ripper::TokenPattern::MatchData - def initialize(tokens, match); end - - def string(n=T.unsafe(nil)); end -end - -class Ripper::TokenPattern::MatchData -end - -class Ripper::TokenPattern::MatchError -end - -class Ripper::TokenPattern::MatchError -end - -class Ripper::TokenPattern - def self.compile(*arg, **arg1); end -end - -class Ripper - def self.dedent_string(arg, arg1); end - - def self.lex_state_name(arg); end - - def self.token_match(src, pattern); end -end - -module RuboCop::AST::CollectionNode - def compact_blank(*args, **arg, &block); end - - def exclude?(*args, **arg, &block); end - - def fifth(*args, **arg, &block); end - - def fourth(*args, **arg, &block); end - - def save_plist(*args, **arg, &block); end - - def second(*args, **arg, &block); end - - def third(*args, **arg, &block); end - - def to_plist(*args, **arg, &block); end - - def to_sentence(*args, **arg, &block); end -end - -module RuboCop::AST::NodePattern::Sets - SET_ARM_INTEL = ::T.let(nil, ::T.untyped) - SET_BASH_COMPLETION_ZSH_COMPLETION_FISH_COMPLETION = ::T.let(nil, ::T.untyped) - SET_BUILD_RECOMMENDED_TEST_OPTIONAL = ::T.let(nil, ::T.untyped) - SET_DEPENDS_ON_USES_FROM_MACOS = ::T.let(nil, ::T.untyped) - SET_INCLUDE_WITH_WITHOUT = ::T.let(nil, ::T.untyped) - SET_MAC_LINUX = ::T.let(nil, ::T.untyped) - SET_ON_ARM_ON_INTEL_ON_SONOMA_ETC = ::T.let(nil, ::T.untyped) - SET_ON_INTEL_ON_ARM = ::T.let(nil, ::T.untyped) - SET_OR_NEWER_OR_OLDER = ::T.let(nil, ::T.untyped) - SET_SYSTEM_SHELL_OUTPUT_PIPE_OUTPUT = ::T.let(nil, ::T.untyped) - SET_WITH_WITHOUT = ::T.let(nil, ::T.untyped) - SET____ETC_5 = ::T.let(nil, ::T.untyped) -end - -class RuboCop::Cask::AST::Stanza - def app?(); end - - def appcast?(); end - - def arch?(); end - - def artifact?(); end - - def audio_unit_plugin?(); end - - def auto_updates?(); end - - def binary?(); end - - def caveats?(); end - - def colorpicker?(); end - - def conflicts_with?(); end - - def container?(); end - - def depends_on?(); end - - def deprecate?(); end - - def desc?(); end - - def dictionary?(); end - - def disable?(); end - - def font?(); end - - def homepage?(); end - - def input_method?(); end - - def installer?(); end - - def internet_plugin?(); end - - def keyboard_layout?(); end - - def language?(); end - - def livecheck?(); end - - def manpage?(); end - - def mdimporter?(); end - - def name?(); end - - def on_arch_conditional?(); end - - def on_arm?(); end - - def on_big_sur?(); end - - def on_catalina?(); end - - def on_el_capitan?(); end - - def on_high_sierra?(); end - - def on_intel?(); end - - def on_mojave?(); end - - def on_monterey?(); end - - def on_sierra?(); end - - def on_sonoma?(); end - - def on_ventura?(); end - - def pkg?(); end - - def postflight?(); end - - def preflight?(); end - - def prefpane?(); end - - def qlplugin?(); end - - def screen_saver?(); end - - def service?(); end - - def sha256?(); end - - def stage_only?(); end - - def suite?(); end - - def uninstall?(); end - - def uninstall_postflight?(); end - - def uninstall_preflight?(); end - - def url?(); end - - def version?(); end - - def vst3_plugin?(); end - - def vst_plugin?(); end - - def zap?(); end -end - -module RuboCop::Cop::Cask::CaskHelp - include ::RuboCop::Cop::CommentsHelp -end - -module RuboCop::Cop::Cask::CaskHelp - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class RuboCop::Cop::Cask::Desc - include ::RuboCop::Cop::CommentsHelp -end - -class RuboCop::Cop::Cask::Discontinued - include ::RuboCop::Cop::CommentsHelp -end - -class RuboCop::Cop::Cask::HomepageUrlTrailingSlash - include ::RuboCop::Cop::CommentsHelp -end - -class RuboCop::Cop::Cask::NoOverrides - include ::RuboCop::Cop::CommentsHelp -end - -module RuboCop::Cop::Cask::OnDescStanza - include ::RuboCop::Cop::CommentsHelp -end - -module RuboCop::Cop::Cask::OnHomepageStanza - include ::RuboCop::Cop::CommentsHelp -end - -class RuboCop::Cop::Cask::OnSystemConditionals - include ::RuboCop::Cop::CommentsHelp -end - -module RuboCop::Cop::Cask::OnUrlStanza - include ::RuboCop::Cop::CommentsHelp -end - -class RuboCop::Cop::Cask::StanzaGrouping - include ::RuboCop::Cop::CommentsHelp -end - -class RuboCop::Cop::Cask::StanzaOrder - include ::RuboCop::Cop::CommentsHelp -end - -class RuboCop::Cop::Cask::Url - include ::RuboCop::Cop::CommentsHelp -end - -class RuboCop::Cop::Cask::Variables - include ::RuboCop::Cop::CommentsHelp -end - -class RuboCop::Cop::Cop - def highlights(); end - - def messages(); end -end - -class RuboCop::Cop::FormulaAudit::ComponentsOrder - def depends_on_node?(param0=T.unsafe(nil)); end -end - -class RuboCop::Cop::FormulaAudit::DependencyOrder - def build_with_dependency_node(param0); end - - def buildtime_dependency?(param0); end - - def dependency_name_node(param0); end - - def depends_on_node?(param0=T.unsafe(nil)); end - - def negate_normal_dependency?(param0); end - - def optional_dependency?(param0); end - - def recommended_dependency?(param0); end - - def test_dependency?(param0); end - - def uses_from_macos_node?(param0=T.unsafe(nil)); end -end - -class RuboCop::Cop::FormulaAudit::DeprecateDisableDate - def date(param0); end -end - -class RuboCop::Cop::FormulaAudit::DeprecateDisableReason - def reason(param0); end -end - -class RuboCop::Cop::FormulaAudit::GenerateCompletionsDSL - def correctable_shell_completion_node(param0); end - - def shell_completion_node(param0); end -end - -class RuboCop::Cop::FormulaAudit::GitUrls - def url_has_revision?(param0=T.unsafe(nil)); end -end - -class RuboCop::Cop::FormulaAudit::Licenses - def license_exception?(param0=T.unsafe(nil)); end -end - -class RuboCop::Cop::FormulaAudit::Miscellaneous - def conditional_dependencies(param0); end - - def destructure_hash(param0=T.unsafe(nil)); end - - def formula_path_strings(param0, param1); end - - def hash_dep(param0=T.unsafe(nil)); end - - def languageNodeModule?(param0); end -end - -class RuboCop::Cop::FormulaAudit::OptionDeclarations - def depends_on_build_with(param0); end -end - -class RuboCop::Cop::FormulaAudit::Patches - def patch_data?(param0); end -end - -class RuboCop::Cop::FormulaAudit::Test - def test_calls(param0); end -end - -class RuboCop::Cop::FormulaAudit::Text - def prefix_path(param0); end -end - -class RuboCop::Cop::FormulaAuditStrict::GitUrls - def url_has_tag?(param0=T.unsafe(nil)); end -end - -class RuboCop::Cop::FormulaAuditStrict::Text - def interpolated_share_path_starts_with(param0, param1); end - - def share_path_starts_with(param0, param1); end -end - -class RuboCop::Cop::FormulaCop - def dependency_name_hash_match?(param0, param1); end - - def dependency_type_hash_match?(param0, param1); end - - def required_dependency?(param0); end - - def required_dependency_name?(param0, param1); end -end - -class RuboCop::Cop::FormulaCop - extend ::T::Private::Abstract::Hooks -end - -module RuboCop::Cop::HelperFunctions - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class RuboCop::Cop::Homebrew::Blank - def nil_or_empty?(param0=T.unsafe(nil)); end -end - -class RuboCop::Cop::Homebrew::CompactBlank - def reject_with_block?(param0=T.unsafe(nil)); end - - def reject_with_block_pass?(param0=T.unsafe(nil)); end -end - -class RuboCop::Cop::Homebrew::MoveToExtendOS - def os_check?(param0=T.unsafe(nil)); end -end - -class RuboCop::Cop::Homebrew::NegateInclude - def negate_include_call?(param0=T.unsafe(nil)); end -end - -class RuboCop::Cop::Homebrew::Presence - def redundant_negative_receiver_and_other(param0=T.unsafe(nil)); end - - def redundant_receiver_and_other(param0=T.unsafe(nil)); end -end - -class RuboCop::Cop::Homebrew::Present - def exists_and_not_empty?(param0=T.unsafe(nil)); end -end - -class RuboCop::Cop::Homebrew::SafeNavigationWithBlank - def safe_navigation_blank_in_conditional?(param0=T.unsafe(nil)); end -end - -module RuboCop::Cop::OnSystemConditionalsHelper - def hardware_cpu_search(param0, method:); end - - def if_arch_node_search(param0, arch:); end - - def if_base_os_node_search(param0, base_os:); end - - def if_macos_version_node_search(param0, os_version:); end - - def macos_version_comparison_search(param0, os_version:); end - - def on_macos_version_method_call(param0=T.unsafe(nil), on_method:); end - - def on_system_method_call(param0=T.unsafe(nil)); end -end - -module RuboCop::RSpec::ExpectOffense - def expect_correction(correction, loop: T.unsafe(nil), source: T.unsafe(nil)); end - - def expect_no_corrections(); end - - def expect_no_offenses(source, file=T.unsafe(nil)); end - - def expect_offense(source, file=T.unsafe(nil), severity: T.unsafe(nil), chomp: T.unsafe(nil), **replacements); end - - def format_offense(source, **replacements); end - - def parse_annotations(source, raise_error: T.unsafe(nil), **replacements); end - - def parse_processed_source(source, file=T.unsafe(nil)); end - - def set_formatter_options(); end -end - -class RuboCop::RSpec::ExpectOffense::AnnotatedSource - def ==(other); end - - def annotations(); end - - def initialize(lines, annotations); end - - def lines(); end - - def match_annotations?(other); end - - def plain_source(); end - - def with_offense_annotations(offenses); end - ABBREV = ::T.let(nil, ::T.untyped) - ANNOTATION_PATTERN = ::T.let(nil, ::T.untyped) -end - -class RuboCop::RSpec::ExpectOffense::AnnotatedSource - def self.parse(annotated_source); end -end - -module RuboCop::RSpec::ExpectOffense -end - -class RuboCop::RSpec::ParallelFormatter - def dump_pending(*arg); end -end - -class RuboCop::RSpec::ParallelFormatter -end - -class RubyLex - def check_code_block(code, tokens=T.unsafe(nil)); end - - def check_corresponding_token_depth(lines, line_index); end - - def check_newline_depth_difference(); end - - def check_state(code, tokens=T.unsafe(nil), context: T.unsafe(nil)); end - - def check_string_literal(tokens); end - - def check_termination_in_prev_line(code, context: T.unsafe(nil)); end - - def each_top_level_statement(); end - - def find_prev_spaces(line_index); end - - def initialize_input(); end - - def is_method_calling?(tokens, index); end - - def is_the_in_correspond_to_a_for(tokens, index); end - - def lex(); end - - def process_continue(tokens=T.unsafe(nil)); end - - def process_literal_type(tokens=T.unsafe(nil)); end - - def process_nesting_level(tokens=T.unsafe(nil)); end - - def prompt(); end - - def set_auto_indent(context); end - - def set_input(io, p=T.unsafe(nil), context: T.unsafe(nil), &block); end - - def set_prompt(p=T.unsafe(nil), &block); end - - def take_corresponding_syntax_to_kw_do(tokens, index); end - ERROR_TOKENS = ::T.let(nil, ::T.untyped) -end - -class RubyLex::TerminateLineInput - def initialize(); end -end - -class RubyLex::TerminateLineInput -end - -class RubyLex - def self.compile_with_errors_suppressed(code, line_no: T.unsafe(nil)); end - - def self.ripper_lex_without_warning(code, context: T.unsafe(nil)); end -end - -class RubyVM::AbstractSyntaxTree::Node - def node_id(); end - - def pretty_print_children(q, names=T.unsafe(nil)); end - - def script_lines(); end - - def source(); end -end - -class RubyVM::InstructionSequence - def script_lines(); end -end - -module RubyVM::MJIT -end - -module RubyVM::MJIT - def self.enabled?(); end - - def self.pause(*arg); end - - def self.resume(); end -end - -class RubyVM - def self.keep_script_lines(); end - - def self.keep_script_lines=(keep_script_lines); end -end - -ScanError = StringScanner::Error - -class Set - def ==(other); end - - def ===(o); 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 SharedEnvExtension - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class SimpleDelegator - RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) -end - -module Singleton - def _dump(depth=T.unsafe(nil)); end - - def clone(); end - - def dup(); end - VERSION = ::T.let(nil, ::T.untyped) -end - -module Singleton::SingletonClassMethods - def _load(str); end - - def clone(); end -end - -module Singleton - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks - def self.__init__(klass); end -end - -class Socket - AF_CCITT = ::T.let(nil, ::T.untyped) - AF_CHAOS = ::T.let(nil, ::T.untyped) - AF_CNT = ::T.let(nil, ::T.untyped) - AF_COIP = ::T.let(nil, ::T.untyped) - AF_DATAKIT = ::T.let(nil, ::T.untyped) - AF_DECnet = ::T.let(nil, ::T.untyped) - AF_DLI = ::T.let(nil, ::T.untyped) - AF_E164 = ::T.let(nil, ::T.untyped) - AF_ECMA = ::T.let(nil, ::T.untyped) - AF_HYLINK = ::T.let(nil, ::T.untyped) - AF_IMPLINK = ::T.let(nil, ::T.untyped) - AF_ISO = ::T.let(nil, ::T.untyped) - AF_LAT = ::T.let(nil, ::T.untyped) - AF_LINK = ::T.let(nil, ::T.untyped) - AF_NATM = ::T.let(nil, ::T.untyped) - AF_NDRV = ::T.let(nil, ::T.untyped) - AF_NETBIOS = ::T.let(nil, ::T.untyped) - AF_NS = ::T.let(nil, ::T.untyped) - AF_OSI = ::T.let(nil, ::T.untyped) - AF_PPP = ::T.let(nil, ::T.untyped) - AF_PUP = ::T.let(nil, ::T.untyped) - AF_SIP = ::T.let(nil, ::T.untyped) - AF_SYSTEM = ::T.let(nil, ::T.untyped) - AF_VSOCK = ::T.let(nil, ::T.untyped) - AI_DEFAULT = ::T.let(nil, ::T.untyped) - AI_MASK = ::T.let(nil, ::T.untyped) - AI_V4MAPPED_CFG = ::T.let(nil, ::T.untyped) - EAI_BADHINTS = ::T.let(nil, ::T.untyped) - EAI_MAX = ::T.let(nil, ::T.untyped) - EAI_PROTOCOL = ::T.let(nil, ::T.untyped) - IFF_ALTPHYS = ::T.let(nil, ::T.untyped) - IFF_LINK0 = ::T.let(nil, ::T.untyped) - IFF_LINK1 = ::T.let(nil, ::T.untyped) - IFF_LINK2 = ::T.let(nil, ::T.untyped) - IFF_OACTIVE = ::T.let(nil, ::T.untyped) - IFF_SIMPLEX = ::T.let(nil, ::T.untyped) - IPPROTO_EON = ::T.let(nil, ::T.untyped) - IPPROTO_GGP = ::T.let(nil, ::T.untyped) - IPPROTO_HELLO = ::T.let(nil, ::T.untyped) - IPPROTO_MAX = ::T.let(nil, ::T.untyped) - IPPROTO_ND = ::T.let(nil, ::T.untyped) - IPPROTO_XTP = ::T.let(nil, ::T.untyped) - IPV6_DONTFRAG = ::T.let(nil, ::T.untyped) - IPV6_PATHMTU = ::T.let(nil, ::T.untyped) - IPV6_RECVPATHMTU = ::T.let(nil, ::T.untyped) - IPV6_USE_MIN_MTU = ::T.let(nil, ::T.untyped) - IP_DONTFRAG = ::T.let(nil, ::T.untyped) - IP_PORTRANGE = ::T.let(nil, ::T.untyped) - IP_RECVDSTADDR = ::T.let(nil, ::T.untyped) - IP_RECVIF = ::T.let(nil, ::T.untyped) - LOCAL_PEERCRED = ::T.let(nil, ::T.untyped) - MSG_EOF = ::T.let(nil, ::T.untyped) - MSG_FLUSH = ::T.let(nil, ::T.untyped) - MSG_HAVEMORE = ::T.let(nil, ::T.untyped) - MSG_HOLD = ::T.let(nil, ::T.untyped) - MSG_RCVMORE = ::T.let(nil, ::T.untyped) - MSG_SEND = ::T.let(nil, ::T.untyped) - PF_CCITT = ::T.let(nil, ::T.untyped) - PF_CHAOS = ::T.let(nil, ::T.untyped) - PF_CNT = ::T.let(nil, ::T.untyped) - PF_COIP = ::T.let(nil, ::T.untyped) - PF_DATAKIT = ::T.let(nil, ::T.untyped) - PF_DECnet = ::T.let(nil, ::T.untyped) - PF_DLI = ::T.let(nil, ::T.untyped) - PF_ECMA = ::T.let(nil, ::T.untyped) - PF_HYLINK = ::T.let(nil, ::T.untyped) - PF_IMPLINK = ::T.let(nil, ::T.untyped) - PF_ISO = ::T.let(nil, ::T.untyped) - PF_LAT = ::T.let(nil, ::T.untyped) - PF_LINK = ::T.let(nil, ::T.untyped) - PF_NATM = ::T.let(nil, ::T.untyped) - PF_NDRV = ::T.let(nil, ::T.untyped) - PF_NETBIOS = ::T.let(nil, ::T.untyped) - PF_NS = ::T.let(nil, ::T.untyped) - PF_OSI = ::T.let(nil, ::T.untyped) - PF_PIP = ::T.let(nil, ::T.untyped) - PF_PPP = ::T.let(nil, ::T.untyped) - PF_PUP = ::T.let(nil, ::T.untyped) - PF_RTIP = ::T.let(nil, ::T.untyped) - PF_SIP = ::T.let(nil, ::T.untyped) - PF_SYSTEM = ::T.let(nil, ::T.untyped) - PF_VSOCK = ::T.let(nil, ::T.untyped) - PF_XTP = ::T.let(nil, ::T.untyped) - SCM_CREDS = ::T.let(nil, ::T.untyped) - SO_DONTTRUNC = ::T.let(nil, ::T.untyped) - SO_NKE = ::T.let(nil, ::T.untyped) - SO_NOSIGPIPE = ::T.let(nil, ::T.untyped) - SO_NREAD = ::T.let(nil, ::T.untyped) - SO_USELOOPBACK = ::T.let(nil, ::T.untyped) - SO_WANTMORE = ::T.let(nil, ::T.untyped) - SO_WANTOOBFLAG = ::T.let(nil, ::T.untyped) - TCP_NOOPT = ::T.let(nil, ::T.untyped) - TCP_NOPUSH = ::T.let(nil, ::T.untyped) -end - -module Socket::Constants - AF_CCITT = ::T.let(nil, ::T.untyped) - AF_CHAOS = ::T.let(nil, ::T.untyped) - AF_CNT = ::T.let(nil, ::T.untyped) - AF_COIP = ::T.let(nil, ::T.untyped) - AF_DATAKIT = ::T.let(nil, ::T.untyped) - AF_DECnet = ::T.let(nil, ::T.untyped) - AF_DLI = ::T.let(nil, ::T.untyped) - AF_E164 = ::T.let(nil, ::T.untyped) - AF_ECMA = ::T.let(nil, ::T.untyped) - AF_HYLINK = ::T.let(nil, ::T.untyped) - AF_IMPLINK = ::T.let(nil, ::T.untyped) - AF_ISO = ::T.let(nil, ::T.untyped) - AF_LAT = ::T.let(nil, ::T.untyped) - AF_LINK = ::T.let(nil, ::T.untyped) - AF_NATM = ::T.let(nil, ::T.untyped) - AF_NDRV = ::T.let(nil, ::T.untyped) - AF_NETBIOS = ::T.let(nil, ::T.untyped) - AF_NS = ::T.let(nil, ::T.untyped) - AF_OSI = ::T.let(nil, ::T.untyped) - AF_PPP = ::T.let(nil, ::T.untyped) - AF_PUP = ::T.let(nil, ::T.untyped) - AF_SIP = ::T.let(nil, ::T.untyped) - AF_SYSTEM = ::T.let(nil, ::T.untyped) - AF_VSOCK = ::T.let(nil, ::T.untyped) - AI_DEFAULT = ::T.let(nil, ::T.untyped) - AI_MASK = ::T.let(nil, ::T.untyped) - AI_V4MAPPED_CFG = ::T.let(nil, ::T.untyped) - EAI_BADHINTS = ::T.let(nil, ::T.untyped) - EAI_MAX = ::T.let(nil, ::T.untyped) - EAI_PROTOCOL = ::T.let(nil, ::T.untyped) - IFF_ALTPHYS = ::T.let(nil, ::T.untyped) - IFF_LINK0 = ::T.let(nil, ::T.untyped) - IFF_LINK1 = ::T.let(nil, ::T.untyped) - IFF_LINK2 = ::T.let(nil, ::T.untyped) - IFF_OACTIVE = ::T.let(nil, ::T.untyped) - IFF_SIMPLEX = ::T.let(nil, ::T.untyped) - IPPROTO_EON = ::T.let(nil, ::T.untyped) - IPPROTO_GGP = ::T.let(nil, ::T.untyped) - IPPROTO_HELLO = ::T.let(nil, ::T.untyped) - IPPROTO_MAX = ::T.let(nil, ::T.untyped) - IPPROTO_ND = ::T.let(nil, ::T.untyped) - IPPROTO_XTP = ::T.let(nil, ::T.untyped) - IPV6_DONTFRAG = ::T.let(nil, ::T.untyped) - IPV6_PATHMTU = ::T.let(nil, ::T.untyped) - IPV6_RECVPATHMTU = ::T.let(nil, ::T.untyped) - IPV6_USE_MIN_MTU = ::T.let(nil, ::T.untyped) - IP_DONTFRAG = ::T.let(nil, ::T.untyped) - IP_PORTRANGE = ::T.let(nil, ::T.untyped) - IP_RECVDSTADDR = ::T.let(nil, ::T.untyped) - IP_RECVIF = ::T.let(nil, ::T.untyped) - LOCAL_PEERCRED = ::T.let(nil, ::T.untyped) - MSG_EOF = ::T.let(nil, ::T.untyped) - MSG_FLUSH = ::T.let(nil, ::T.untyped) - MSG_HAVEMORE = ::T.let(nil, ::T.untyped) - MSG_HOLD = ::T.let(nil, ::T.untyped) - MSG_RCVMORE = ::T.let(nil, ::T.untyped) - MSG_SEND = ::T.let(nil, ::T.untyped) - PF_CCITT = ::T.let(nil, ::T.untyped) - PF_CHAOS = ::T.let(nil, ::T.untyped) - PF_CNT = ::T.let(nil, ::T.untyped) - PF_COIP = ::T.let(nil, ::T.untyped) - PF_DATAKIT = ::T.let(nil, ::T.untyped) - PF_DECnet = ::T.let(nil, ::T.untyped) - PF_DLI = ::T.let(nil, ::T.untyped) - PF_ECMA = ::T.let(nil, ::T.untyped) - PF_HYLINK = ::T.let(nil, ::T.untyped) - PF_IMPLINK = ::T.let(nil, ::T.untyped) - PF_ISO = ::T.let(nil, ::T.untyped) - PF_LAT = ::T.let(nil, ::T.untyped) - PF_LINK = ::T.let(nil, ::T.untyped) - PF_NATM = ::T.let(nil, ::T.untyped) - PF_NDRV = ::T.let(nil, ::T.untyped) - PF_NETBIOS = ::T.let(nil, ::T.untyped) - PF_NS = ::T.let(nil, ::T.untyped) - PF_OSI = ::T.let(nil, ::T.untyped) - PF_PIP = ::T.let(nil, ::T.untyped) - PF_PPP = ::T.let(nil, ::T.untyped) - PF_PUP = ::T.let(nil, ::T.untyped) - PF_RTIP = ::T.let(nil, ::T.untyped) - PF_SIP = ::T.let(nil, ::T.untyped) - PF_SYSTEM = ::T.let(nil, ::T.untyped) - PF_VSOCK = ::T.let(nil, ::T.untyped) - PF_XTP = ::T.let(nil, ::T.untyped) - SCM_CREDS = ::T.let(nil, ::T.untyped) - SO_DONTTRUNC = ::T.let(nil, ::T.untyped) - SO_NKE = ::T.let(nil, ::T.untyped) - SO_NOSIGPIPE = ::T.let(nil, ::T.untyped) - SO_NREAD = ::T.let(nil, ::T.untyped) - SO_USELOOPBACK = ::T.let(nil, ::T.untyped) - SO_WANTMORE = ::T.let(nil, ::T.untyped) - SO_WANTOOBFLAG = ::T.let(nil, ::T.untyped) - TCP_NOOPT = ::T.let(nil, ::T.untyped) - TCP_NOPUSH = ::T.let(nil, ::T.untyped) -end - -module Spoom::Cli::Helper - HIGHLIGHT_COLOR = ::T.let(nil, ::T.untyped) -end - -module Spoom::Cli::Helper - extend ::T::Helpers - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Spoom::Colorize - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Spoom::Context::Bundle - extend ::T::Helpers - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Spoom::Context::Exec - extend ::T::Helpers - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Spoom::Context::FileSystem - extend ::T::Helpers - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Spoom::Context::Git - extend ::T::Helpers - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Spoom::Context::Sorbet - extend ::T::Helpers - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Spoom::Coverage::D3::Base - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks -end - -module Spoom::Coverage::D3 - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Spoom::Coverage::Template - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks -end - -module Spoom::Coverage - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Spoom::Deadcode::Error - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks -end - -class Spoom::Deadcode::Plugins::Base - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks -end - -module Spoom::Deadcode - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Spoom::FileTree::Visitor - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks -end - -module Spoom::LSP::PrintableSymbol - extend ::T::Helpers - extend ::T::Private::Abstract::Hooks - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Spoom::Printer - extend ::T::Helpers -end - -module Spoom::Sorbet::Errors - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Spoom::Sorbet::MetricsParser - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Spoom::Sorbet::Sigils - extend ::T::Private::Methods::SingletonMethodHooks -end - -class String - include ::JSON::Ext::Generator::GeneratorMethods::String - def fast_xs(); end - - def to_nfc(); end - - def to_nfd(); end - - def to_nfkc(); end - - def to_nfkd(); end -end - -class StringIO - def set_encoding_by_bom(); end - VERSION = ::T.let(nil, ::T.untyped) -end - -class StringIO - def self.new(*arg); end -end - -class StringScanner - def bol?(); end - - def fixed_anchor?(); end - - def initialize(*arg); end - Id = ::T.let(nil, ::T.untyped) - Version = ::T.let(nil, ::T.untyped) -end - -class Struct - def deconstruct(); end - - def deconstruct_keys(arg); end - - def filter(*arg); end -end - -Struct::Group = Etc::Group - -Struct::Passwd = Etc::Passwd - -class Struct - def self.new(*arg); end -end - -module Superenv - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Symbol - def to_msgpack_ext(); end -end - -module Tapioca - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Tempfile - def _close(); end - RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) -end - -class Tempfile::Remover - def call(*args); end - - def initialize(tmpfile); end -end - -class Tempfile::Remover -end - -class Test::Helper::OutputAsTTY::Output - RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped) -end - -class Thread::Backtrace - def self.limit(); end -end - -class Thread - def self.ignore_deadlock(); end - - def self.ignore_deadlock=(ignore_deadlock); end - - def self.new(*arg); end -end - -module Timeout - VERSION = ::T.let(nil, ::T.untyped) -end - -class TracePoint - def eval_script(); end - - def instruction_sequence(); end - - def parameters(); end -end - -class TracePoint - def self.allow_reentry(); end - - def self.new(*events); end -end - -class TrueClass - include ::JSON::Ext::Generator::GeneratorMethods::TrueClass -end - -module Tty - extend ::T::Private::Methods::SingletonMethodHooks -end - -module URI - include ::URI::RFC2396_REGEXP - TBLENCURICOMP_ = ::T.let(nil, ::T.untyped) -end - -class URI::FTP - def buffer_open(buf, proxy, options); 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::Generic - def decoded_password(); end - - def decoded_user(); end -end - -class URI::HTTP - def authority(); end - - def buffer_open(buf, proxy, options); end - - def origin(); end -end - -class URI::LDAP - def attributes(); end - - def attributes=(val); end - - def dn(); end - - def dn=(val); end - - def extensions(); end - - def extensions=(val); end - - def filter(); end - - def filter=(val); end - - def initialize(*arg); end - - def scope(); end - - def scope=(val); end - - def set_attributes(val); end - - def set_dn(val); end - - def set_extensions(val); end - - def set_filter(val); end - - def set_scope(val); end -end - -class URI::MailTo - def initialize(*arg); end -end - -class URI::RFC2396_Parser - def initialize(opts=T.unsafe(nil)); end -end - -class URI::RFC3986_Parser - def join(*uris); end - - def parse(uri); end - - def regexp(); end - - def split(uri); end - RFC3986_relative_ref = ::T.let(nil, ::T.untyped) -end - -module URI::Util - def self.make_components_hash(klass, array_hash); end -end - -class URI::WSS - DEFAULT_PORT = ::T.let(nil, ::T.untyped) -end - -class URI::WSS -end - -module URI - def self.decode_uri_component(str, enc=T.unsafe(nil)); end - - def self.for(scheme, *arguments, default: T.unsafe(nil)); end - - def self.get_encoding(label); end - - def self.open(name, *rest, &block); end - - def self.register_scheme(scheme, klass); end -end - -class UnboundMethod - def private?(); end - - def protected?(); end - - def public?(); end -end - -module UnicodeNormalize -end - -module UnicodeNormalize -end - -module Utils::AST - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Utils::Autoremove - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Utils::Backtrace - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Utils::Gzip - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Utils::Inreplace - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Utils::Service - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Utils::Shebang - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Utils::Shell - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Utils::Timer - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module Utils - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Version::Parser - extend ::T::Private::Abstract::Hooks -end - -class Version::Token - extend ::T::Private::Abstract::Hooks -end - -module YARDSorbet::Directives - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module YARDSorbet::Handlers::StructClassHandler - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module YARDSorbet::NodeUtils - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -module YARDSorbet::SigToYARD - extend ::T::Private::Methods::SingletonMethodHooks -end - -module YARDSorbet::TagUtils - extend ::T::Private::Methods::MethodHooks - extend ::T::Private::Methods::SingletonMethodHooks -end - -class Zlib::Deflate - def initialize(*arg); end -end - -class Zlib::GzipReader - def initialize(*arg); end -end - -class Zlib::GzipReader - def self.zcat(*arg); end -end - -class Zlib::GzipWriter - def initialize(*arg); end -end - -class Zlib::InProgressError -end - -class Zlib::InProgressError -end - -class Zlib::Inflate - def initialize(*arg); end -end