# This file is autogenerated. Do not edit it by hand. Regenerate it with:
#   srb rbi hidden-definitions

# typed: autogenerated

module ActiveSupport
  def parse_json_times(); end

  def parse_json_times=(obj); end
end

class ActiveSupport::ArrayInquirer
  def any?(*candidates); end
end

class ActiveSupport::ArrayInquirer
end

class ActiveSupport::BacktraceCleaner
  FORMATTED_GEMS_PATTERN = ::T.let(nil, ::T.untyped)
end

module ActiveSupport::BigDecimalWithDefaultFormat
  def to_s(format=T.unsafe(nil)); end
end

module ActiveSupport::BigDecimalWithDefaultFormat
end

module ActiveSupport::Cache
  UNIVERSAL_OPTIONS = ::T.let(nil, ::T.untyped)
end

class ActiveSupport::Cache::Entry
  DEFAULT_COMPRESS_LIMIT = ::T.let(nil, ::T.untyped)
end

class ActiveSupport::Cache::FileStore
  include ::ActiveSupport::Cache::Strategy::LocalCache
  DIR_FORMATTER = ::T.let(nil, ::T.untyped)
  FILENAME_MAX_SIZE = ::T.let(nil, ::T.untyped)
  FILEPATH_MAX_SIZE = ::T.let(nil, ::T.untyped)
  GITKEEP_FILES = ::T.let(nil, ::T.untyped)
end

class ActiveSupport::Cache::MemoryStore
  PER_ENTRY_OVERHEAD = ::T.let(nil, ::T.untyped)
end

class ActiveSupport::Cache::NullStore
  include ::ActiveSupport::Cache::Strategy::LocalCache
end

module ActiveSupport::Callbacks
  CALLBACK_FILTER_TYPES = ::T.let(nil, ::T.untyped)
end

module ActiveSupport::Configurable
  def config(); end
end

module ActiveSupport::Configurable::ClassMethods
  def config(); end

  def configure(); end
end

module ActiveSupport::Configurable::ClassMethods
end

class ActiveSupport::Configurable::Configuration
  def compile_methods!(); end
end

class ActiveSupport::Configurable::Configuration
  def self.compile_methods!(keys); end
end

module ActiveSupport::Configurable
  extend ::ActiveSupport::Concern
end

module ActiveSupport::Dependencies
  Reference = ::T.let(nil, ::T.untyped)
end

class ActiveSupport::Deprecation
  def deprecation_horizon(); end

  def deprecation_horizon=(deprecation_horizon); end

  def initialize(deprecation_horizon=T.unsafe(nil), gem_name=T.unsafe(nil)); end
  DEFAULT_BEHAVIORS = ::T.let(nil, ::T.untyped)
end

module ActiveSupport::Deprecation::Reporting
  RAILS_GEM_ROOT = ::T.let(nil, ::T.untyped)
end

class ActiveSupport::Deprecation
  extend ::ActiveSupport::Deprecation::InstanceDelegator::OverrideDelegators
end

class ActiveSupport::Digest
end

class ActiveSupport::Digest
  def self.hash_digest_class(); end

  def self.hash_digest_class=(klass); end

  def self.hexdigest(arg); end
end

class ActiveSupport::Duration
  PARTS = ::T.let(nil, ::T.untyped)
  PARTS_IN_SECONDS = ::T.let(nil, ::T.untyped)
  SECONDS_PER_DAY = ::T.let(nil, ::T.untyped)
  SECONDS_PER_HOUR = ::T.let(nil, ::T.untyped)
  SECONDS_PER_MINUTE = ::T.let(nil, ::T.untyped)
  SECONDS_PER_MONTH = ::T.let(nil, ::T.untyped)
  SECONDS_PER_WEEK = ::T.let(nil, ::T.untyped)
  SECONDS_PER_YEAR = ::T.let(nil, ::T.untyped)
end

class ActiveSupport::Duration::ISO8601Parser
  def initialize(string); end

  def mode(); end

  def mode=(mode); end

  def parse!(); end

  def parts(); end

  def scanner(); end

  def sign(); end

  def sign=(sign); end
  COMMA = ::T.let(nil, ::T.untyped)
  DATE_COMPONENT = ::T.let(nil, ::T.untyped)
  DATE_COMPONENTS = ::T.let(nil, ::T.untyped)
  DATE_MARKER = ::T.let(nil, ::T.untyped)
  DATE_TO_PART = ::T.let(nil, ::T.untyped)
  PERIOD = ::T.let(nil, ::T.untyped)
  PERIOD_OR_COMMA = ::T.let(nil, ::T.untyped)
  SIGN_MARKER = ::T.let(nil, ::T.untyped)
  TIME_COMPONENT = ::T.let(nil, ::T.untyped)
  TIME_COMPONENTS = ::T.let(nil, ::T.untyped)
  TIME_MARKER = ::T.let(nil, ::T.untyped)
  TIME_TO_PART = ::T.let(nil, ::T.untyped)
end

class ActiveSupport::Duration::ISO8601Parser::ParsingError
end

class ActiveSupport::Duration::ISO8601Parser::ParsingError
end

class ActiveSupport::Duration::ISO8601Parser
end

class ActiveSupport::Duration::ISO8601Serializer
  def initialize(duration, precision: T.unsafe(nil)); end

  def serialize(); end
end

class ActiveSupport::Duration::ISO8601Serializer
end

class ActiveSupport::ExecutionWrapper
  Null = ::T.let(nil, ::T.untyped)
end

module ActiveSupport::Gzip
end

class ActiveSupport::Gzip::Stream
end

class ActiveSupport::Gzip::Stream
end

module ActiveSupport::Gzip
  def self.compress(source, level=T.unsafe(nil), strategy=T.unsafe(nil)); end

  def self.decompress(source); end
end

class ActiveSupport::InheritableOptions
  def inheritable_copy(); end

  def initialize(parent=T.unsafe(nil)); end
end

class ActiveSupport::InheritableOptions
end

module ActiveSupport::JSON
  DATETIME_REGEX = ::T.let(nil, ::T.untyped)
  DATE_REGEX = ::T.let(nil, ::T.untyped)
end

module ActiveSupport::JSON::Encoding
end

class ActiveSupport::JSON::Encoding::JSONGemEncoder
  def encode(value); end

  def initialize(options=T.unsafe(nil)); end

  def options(); end
end

class ActiveSupport::JSON::Encoding::JSONGemEncoder
end

module ActiveSupport::JSON::Encoding
  def self.escape_html_entities_in_json(); end

  def self.escape_html_entities_in_json=(escape_html_entities_in_json); end

  def self.json_encoder(); end

  def self.json_encoder=(json_encoder); end

  def self.time_precision(); end

  def self.time_precision=(time_precision); end

  def self.use_standard_json_time_format(); end

  def self.use_standard_json_time_format=(use_standard_json_time_format); end
end

module ActiveSupport::JSON
  def self.decode(json); end

  def self.encode(value, options=T.unsafe(nil)); end

  def self.parse_error(); end
end

class ActiveSupport::KeyGenerator
  def generate_key(salt, key_size=T.unsafe(nil)); end

  def initialize(secret, options=T.unsafe(nil)); end
end

class ActiveSupport::KeyGenerator
end

class ActiveSupport::LogSubscriber
  def colorize_logging(); end

  def colorize_logging=(obj); end

  def debug(progname=T.unsafe(nil), &block); end

  def error(progname=T.unsafe(nil), &block); end

  def fatal(progname=T.unsafe(nil), &block); end

  def info(progname=T.unsafe(nil), &block); end

  def logger(); end

  def unknown(progname=T.unsafe(nil), &block); end

  def warn(progname=T.unsafe(nil), &block); 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)
  RED = ::T.let(nil, ::T.untyped)
  WHITE = ::T.let(nil, ::T.untyped)
  YELLOW = ::T.let(nil, ::T.untyped)
end

class ActiveSupport::MessageEncryptor
  include ::ActiveSupport::Messages::Rotator::Encryptor
  include ::ActiveSupport::Messages::Rotator
  def encrypt_and_sign(value, expires_at: T.unsafe(nil), expires_in: T.unsafe(nil), purpose: T.unsafe(nil)); end
end

class ActiveSupport::MessageEncryptor::InvalidMessage
end

class ActiveSupport::MessageEncryptor::InvalidMessage
end

module ActiveSupport::MessageEncryptor::NullSerializer
end

module ActiveSupport::MessageEncryptor::NullSerializer
  def self.dump(value); end

  def self.load(value); end
end

module ActiveSupport::MessageEncryptor::NullVerifier
end

module ActiveSupport::MessageEncryptor::NullVerifier
  def self.generate(value); end

  def self.verify(value); end
end

ActiveSupport::MessageEncryptor::OpenSSLCipherError = OpenSSL::Cipher::CipherError

class ActiveSupport::MessageEncryptor
  def self.default_cipher(); end

  def self.key_len(cipher=T.unsafe(nil)); end

  def self.use_authenticated_message_encryption(); end

  def self.use_authenticated_message_encryption=(obj); end
end

class ActiveSupport::MessageVerifier
  include ::ActiveSupport::Messages::Rotator::Verifier
  include ::ActiveSupport::Messages::Rotator
  def generate(value, expires_at: T.unsafe(nil), expires_in: T.unsafe(nil), purpose: T.unsafe(nil)); end

  def valid_message?(signed_message); end

  def verify(*args, **options); end
end

class ActiveSupport::MessageVerifier::InvalidSignature
end

class ActiveSupport::MessageVerifier::InvalidSignature
end

class ActiveSupport::MessageVerifier
end

module ActiveSupport::Messages::Rotator
  def initialize(*_, **options); end

  def rotate(*secrets, **options); end
end

module ActiveSupport::Messages::Rotator::Encryptor
  include ::ActiveSupport::Messages::Rotator
  def decrypt_and_verify(*args, on_rotation: T.unsafe(nil), **options); end
end

module ActiveSupport::Messages::Rotator::Encryptor
end

module ActiveSupport::Messages::Rotator::Verifier
  include ::ActiveSupport::Messages::Rotator
  def verified(*args, on_rotation: T.unsafe(nil), **options); end
end

module ActiveSupport::Messages::Rotator::Verifier
end

module ActiveSupport::Messages::Rotator
end

class ActiveSupport::Multibyte::Chars
  include ::Comparable
  def =~(*args, &block); end

  def acts_like_string?(*args, &block); end

  def compose(); end

  def decompose(); end

  def grapheme_length(); end

  def initialize(string); end

  def limit(limit); end

  def method_missing(method, *args, &block); end

  def normalize(form=T.unsafe(nil)); end

  def reverse(); end

  def reverse!(*args); end

  def slice!(*args); end

  def split(*args); end

  def tidy_bytes(force=T.unsafe(nil)); end

  def tidy_bytes!(*args); end

  def titlecase(); end

  def titleize(); end

  def to_str(); end

  def wrapped_string(); end
end

class ActiveSupport::Multibyte::Chars
  def self.consumes?(string); end
end

module ActiveSupport::Multibyte::Unicode
  def compose(codepoints); end

  def decompose(type, codepoints); end

  def default_normalization_form(); end

  def default_normalization_form=(default_normalization_form); end

  def downcase(string); end

  def normalize(string, form=T.unsafe(nil)); end

  def pack_graphemes(unpacked); end

  def swapcase(string); end

  def tidy_bytes(string, force=T.unsafe(nil)); end

  def unpack_graphemes(string); end

  def upcase(string); end
  NORMALIZATION_FORMS = ::T.let(nil, ::T.untyped)
  NORMALIZATION_FORM_ALIASES = ::T.let(nil, ::T.untyped)
  UNICODE_VERSION = ::T.let(nil, ::T.untyped)
end

module ActiveSupport::Multibyte::Unicode
  extend ::ActiveSupport::Multibyte::Unicode
end

class ActiveSupport::NumberHelper::NumberConverter
  def execute(); end

  def initialize(number, options); end

  def namespace(); end

  def namespace=(val); end

  def namespace?(); end

  def number(); end

  def opts(); end

  def validate_float(); end

  def validate_float=(val); end

  def validate_float?(); end
  DEFAULTS = ::T.let(nil, ::T.untyped)
end

class ActiveSupport::NumberHelper::NumberConverter
  def self.convert(number, options); end

  def self.namespace(); end

  def self.namespace=(val); end

  def self.namespace?(); end

  def self.validate_float(); end

  def self.validate_float=(val); end

  def self.validate_float?(); end
end

class ActiveSupport::NumberHelper::NumberToCurrencyConverter
  def convert(); end
end

class ActiveSupport::NumberHelper::NumberToCurrencyConverter
end

class ActiveSupport::NumberHelper::NumberToDelimitedConverter
  def convert(); end
  DEFAULT_DELIMITER_REGEX = ::T.let(nil, ::T.untyped)
end

class ActiveSupport::NumberHelper::NumberToDelimitedConverter
end

class ActiveSupport::NumberHelper::NumberToHumanConverter
  def convert(); end
  DECIMAL_UNITS = ::T.let(nil, ::T.untyped)
  INVERTED_DECIMAL_UNITS = ::T.let(nil, ::T.untyped)
end

class ActiveSupport::NumberHelper::NumberToHumanConverter
end

class ActiveSupport::NumberHelper::NumberToHumanSizeConverter
  def convert(); end
  STORAGE_UNITS = ::T.let(nil, ::T.untyped)
end

class ActiveSupport::NumberHelper::NumberToHumanSizeConverter
end

class ActiveSupport::NumberHelper::NumberToPercentageConverter
  def convert(); end
end

class ActiveSupport::NumberHelper::NumberToPercentageConverter
end

class ActiveSupport::NumberHelper::NumberToPhoneConverter
  def convert(); end
end

class ActiveSupport::NumberHelper::NumberToPhoneConverter
end

class ActiveSupport::NumberHelper::NumberToRoundedConverter
  def convert(); end
end

class ActiveSupport::NumberHelper::NumberToRoundedConverter
end

class ActiveSupport::NumberHelper::RoundingHelper
  def digit_count(number); end

  def initialize(options); end

  def options(); end

  def round(number); end
end

class ActiveSupport::NumberHelper::RoundingHelper
end

module ActiveSupport::NumberHelper
  extend ::ActiveSupport::Autoload
  extend ::ActiveSupport::NumberHelper
end

class ActiveSupport::OptionMerger
  def initialize(context, options); end
end

class ActiveSupport::OptionMerger
end

class ActiveSupport::OrderedHash
  def encode_with(coder); end

  def nested_under_indifferent_access(); end

  def reject(*args, &block); end

  def select(*args, &block); end

  def to_yaml_type(); end
end

class ActiveSupport::OrderedHash
end

class ActiveSupport::OrderedOptions
  def [](key); end

  def []=(key, value); end

  def _get(_); end

  def method_missing(name, *args); end
end

class ActiveSupport::OrderedOptions
end

module ActiveSupport::Rescuable
  def handler_for_rescue(exception); end

  def rescue_with_handler(exception); end
end

module ActiveSupport::Rescuable::ClassMethods
  def handler_for_rescue(exception, object: T.unsafe(nil)); end

  def rescue_from(*klasses, with: T.unsafe(nil), &block); end

  def rescue_with_handler(exception, object: T.unsafe(nil), visited_exceptions: T.unsafe(nil)); end
end

module ActiveSupport::Rescuable::ClassMethods
end

module ActiveSupport::Rescuable
  extend ::ActiveSupport::Concern
end

class ActiveSupport::SafeBuffer
  def %(args); end

  def *(*_); end

  def +(other); end

  def <<(value); end

  def [](*args); end

  def []=(*args); end

  def capitalize(*args, &block); end

  def capitalize!(*args); end

  def chomp(*args, &block); end

  def chomp!(*args); end

  def chop(*args, &block); end

  def chop!(*args); end

  def clone_empty(); end

  def concat(value); end

  def delete(*args, &block); end

  def delete!(*args); end

  def delete_prefix(*args, &block); end

  def delete_prefix!(*args); end

  def delete_suffix(*args, &block); end

  def delete_suffix!(*args); end

  def downcase(*args, &block); end

  def downcase!(*args); end

  def encode_with(coder); end

  def gsub(*args, &block); end

  def gsub!(*args, &block); end

  def initialize(str=T.unsafe(nil)); end

  def insert(index, value); end

  def lstrip(*args, &block); end

  def lstrip!(*args); end

  def next(*args, &block); end

  def next!(*args); end

  def prepend(value); end

  def replace(value); end

  def reverse(*args, &block); end

  def reverse!(*args); end

  def rstrip(*args, &block); end

  def rstrip!(*args); end

  def safe_concat(value); end

  def slice(*args, &block); end

  def slice!(*args); end

  def squeeze(*args, &block); end

  def squeeze!(*args); end

  def strip(*args, &block); end

  def strip!(*args); end

  def sub(*args, &block); end

  def sub!(*args, &block); end

  def succ(*args, &block); end

  def succ!(*args); end

  def swapcase(*args, &block); end

  def swapcase!(*args); end

  def tr(*args, &block); end

  def tr!(*args); end

  def tr_s(*args, &block); end

  def tr_s!(*args); end

  def unicode_normalize(*args, &block); end

  def unicode_normalize!(*args); end

  def upcase(*args, &block); end

  def upcase!(*args); end
  UNSAFE_STRING_METHODS = ::T.let(nil, ::T.untyped)
  UNSAFE_STRING_METHODS_WITH_BACKREF = ::T.let(nil, ::T.untyped)
end

class ActiveSupport::SafeBuffer::SafeConcatError
  def initialize(); end
end

class ActiveSupport::SafeBuffer::SafeConcatError
end

class ActiveSupport::SafeBuffer
end

class ActiveSupport::StringInquirer
end

class ActiveSupport::StringInquirer
end

class ActiveSupport::Subscriber
  def finish(name, id, payload); end

  def patterns(); end

  def start(name, id, payload); end
end

class ActiveSupport::TestCase
  include ::ActiveSupport::Testing::TaggedLogging
  include ::ActiveSupport::Callbacks
  include ::ActiveSupport::Testing::Assertions
  include ::ActiveSupport::Testing::Deprecation
  include ::ActiveSupport::Testing::TimeHelpers
  include ::ActiveSupport::Testing::FileFixtures
  include ::ActiveSupport::Testing::SetupAndTeardown
  def __callbacks(); end

  def __callbacks?(); end

  def _run_setup_callbacks(&block); end

  def _run_teardown_callbacks(&block); end

  def _setup_callbacks(); end

  def _teardown_callbacks(); end

  def assert_no_match(matcher, obj, msg=T.unsafe(nil)); end

  def assert_not_empty(obj, msg=T.unsafe(nil)); end

  def assert_not_equal(exp, act, msg=T.unsafe(nil)); end

  def assert_not_in_delta(exp, act, delta=T.unsafe(nil), msg=T.unsafe(nil)); end

  def assert_not_in_epsilon(a, b, epsilon=T.unsafe(nil), msg=T.unsafe(nil)); end

  def assert_not_includes(collection, obj, msg=T.unsafe(nil)); end

  def assert_not_instance_of(cls, obj, msg=T.unsafe(nil)); end

  def assert_not_kind_of(cls, obj, msg=T.unsafe(nil)); end

  def assert_not_nil(obj, msg=T.unsafe(nil)); end

  def assert_not_operator(o1, op, o2=T.unsafe(nil), msg=T.unsafe(nil)); end

  def assert_not_predicate(o1, op, msg=T.unsafe(nil)); end

  def assert_not_respond_to(obj, meth, msg=T.unsafe(nil)); end

  def assert_not_same(exp, act, msg=T.unsafe(nil)); end

  def assert_raise(*exp); end

  def file_fixture_path(); end

  def file_fixture_path?(); end

  def method_name(); end
end

class ActiveSupport::TestCase::Assertion
  def error(); end

  def location(); end

  def result_code(); end

  def result_label(); end
end

class ActiveSupport::TestCase::Assertion
end

class ActiveSupport::TestCase
  extend ::ActiveSupport::Callbacks::ClassMethods
  extend ::ActiveSupport::DescendantsTracker
  def self.__callbacks(); end

  def self.__callbacks=(val); end

  def self.__callbacks?(); end

  def self._setup_callbacks(); end

  def self._setup_callbacks=(value); end

  def self._teardown_callbacks(); end

  def self._teardown_callbacks=(value); end

  def self.file_fixture_path(); end

  def self.file_fixture_path=(val); end

  def self.file_fixture_path?(); end

  def self.parallelize(workers: T.unsafe(nil), with: T.unsafe(nil)); end

  def self.parallelize_setup(&block); end

  def self.parallelize_teardown(&block); end

  def self.test_order=(new_order); end
end

module ActiveSupport::Testing::Assertions
  def assert_changes(expression, message=T.unsafe(nil), from: T.unsafe(nil), to: T.unsafe(nil), &block); end

  def assert_difference(expression, *args, &block); end

  def assert_no_changes(expression, message=T.unsafe(nil), &block); end

  def assert_no_difference(expression, message=T.unsafe(nil), &block); end

  def assert_not(object, message=T.unsafe(nil)); end

  def assert_nothing_raised(); end
  UNTRACKED = ::T.let(nil, ::T.untyped)
end

module ActiveSupport::Testing::Assertions
end

module ActiveSupport::Testing::Deprecation
  def assert_deprecated(match=T.unsafe(nil), deprecator=T.unsafe(nil), &block); end

  def assert_not_deprecated(deprecator=T.unsafe(nil), &block); end

  def collect_deprecations(deprecator=T.unsafe(nil)); end
end

module ActiveSupport::Testing::Deprecation
end

module ActiveSupport::Testing::FileFixtures
  def file_fixture(fixture_name); end
end

module ActiveSupport::Testing::FileFixtures
  extend ::ActiveSupport::Concern
end

module ActiveSupport::Testing::SetupAndTeardown
  def after_teardown(); end

  def before_setup(); end
end

module ActiveSupport::Testing::SetupAndTeardown
  def self.prepended(klass); end
end

module ActiveSupport::Testing::TaggedLogging
  def before_setup(); end

  def tagged_logger=(tagged_logger); end
end

module ActiveSupport::Testing::TaggedLogging
end

module ActiveSupport::Testing::TimeHelpers
  def after_teardown(); end

  def freeze_time(&block); end

  def travel(duration, &block); end

  def travel_back(); end

  def travel_to(date_or_time); end

  def unfreeze_time(); end
end

module ActiveSupport::Testing::TimeHelpers
end

class ActiveSupport::TimeWithZone
  include ::DateAndTime::Compatibility
  PRECISIONS = ::T.let(nil, ::T.untyped)
end

class ActiveSupport::TimeZone
  MAPPING = ::T.let(nil, ::T.untyped)
end

module ActiveSupport::ToJsonWithActiveSupportEncoder
  def to_json(options=T.unsafe(nil)); end
end

module ActiveSupport::ToJsonWithActiveSupportEncoder
end

module ActiveSupport::VERSION
  MAJOR = ::T.let(nil, ::T.untyped)
  MINOR = ::T.let(nil, ::T.untyped)
  PRE = ::T.let(nil, ::T.untyped)
  STRING = ::T.let(nil, ::T.untyped)
  TINY = ::T.let(nil, ::T.untyped)
end

module ActiveSupport::XmlMini
  DEFAULT_ENCODINGS = ::T.let(nil, ::T.untyped)
  FORMATTING = ::T.let(nil, ::T.untyped)
  PARSING = ::T.let(nil, ::T.untyped)
  TYPE_NAMES = ::T.let(nil, ::T.untyped)
end

module ActiveSupport::XmlMini_REXML
  CONTENT_KEY = ::T.let(nil, ::T.untyped)
end

module ActiveSupport
  def self.escape_html_entities_in_json(*args, &block); end

  def self.escape_html_entities_in_json=(arg); end

  def self.json_encoder(*args, &block); end

  def self.json_encoder=(arg); end

  def self.parse_json_times(); end

  def self.parse_json_times=(obj); end

  def self.time_precision(*args, &block); end

  def self.time_precision=(arg); end

  def self.use_standard_json_time_format(*args, &block); end

  def self.use_standard_json_time_format=(arg); end
end

class Addrinfo
  def connect_internal(local_addrinfo, timeout=T.unsafe(nil)); end
end

class Array
  include ::JSON::Ext::Generator::GeneratorMethods::Array
  def shelljoin(); end

  def to_h(); end

end

class Array
  def self.try_convert(_); 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
end

class BigDecimal
  include ::ActiveSupport::BigDecimalWithDefaultFormat
  def clone(); end

  def to_digits(); end
  EXCEPTION_NaN = ::T.let(nil, ::T.untyped)
  VERSION = ::T.let(nil, ::T.untyped)
end

class BigDecimal
  def self.new(*args, **kwargs); end
end

class Binding
  def clone(); end

  def irb(); end
end

class Bundler::Dependency
  def branch(); end

  def expanded_platforms(); end

  def git(); end
end

Bundler::Deprecate = Gem::Deprecate

class Bundler::Env
end

class Bundler::Env
  def self.environment(); end

  def self.report(options=T.unsafe(nil)); end

  def self.write(io); end
end

class Bundler::Fetcher
  def fetch_spec(spec); end

  def fetchers(); end

  def http_proxy(); end

  def initialize(remote); end

  def specs(gem_names, source); end

  def specs_with_retry(gem_names, source); end

  def uri(); end

  def use_api(); end

  def user_agent(); end
  FAIL_ERRORS = ::T.let(nil, ::T.untyped)
  FETCHERS = ::T.let(nil, ::T.untyped)
  HTTP_ERRORS = ::T.let(nil, ::T.untyped)
  NET_ERRORS = ::T.let(nil, ::T.untyped)
end

class Bundler::Fetcher::AuthenticationRequiredError
  def initialize(remote_uri); end
end

class Bundler::Fetcher::BadAuthenticationError
  def initialize(remote_uri); end
end

class Bundler::Fetcher::Base
  def api_fetcher?(); end

  def available?(); end

  def display_uri(); end

  def downloader(); end

  def fetch_uri(); end

  def initialize(downloader, remote, display_uri); end

  def remote(); end

  def remote_uri(); end
end

class Bundler::Fetcher::Base
end

class Bundler::Fetcher::CertificateFailureError
  def initialize(remote_uri); end
end

class Bundler::Fetcher::CompactIndex
  def available?(*args, &blk); end

  def fetch_spec(*args, &blk); end

  def specs(*args, &blk); end

  def specs_for_names(gem_names); end
end

class Bundler::Fetcher::CompactIndex::ClientFetcher
  def call(path, headers); end

  def fetcher(); end

  def fetcher=(_); end

  def ui(); end

  def ui=(_); end
end

class Bundler::Fetcher::CompactIndex::ClientFetcher
  def self.[](*_); end

  def self.members(); end
end

class Bundler::Fetcher::CompactIndex
  def self.compact_index_request(method_name); end
end

class Bundler::Fetcher::Dependency
  def dependency_api_uri(gem_names=T.unsafe(nil)); end

  def dependency_specs(gem_names); end

  def get_formatted_specs_and_deps(gem_list); end

  def specs(gem_names, full_dependency_list=T.unsafe(nil), last_spec_list=T.unsafe(nil)); end

  def unmarshalled_dep_gems(gem_names); end
end

class Bundler::Fetcher::Dependency
end

class Bundler::Fetcher::Downloader
  def connection(); end

  def fetch(uri, headers=T.unsafe(nil), counter=T.unsafe(nil)); end

  def initialize(connection, redirect_limit); end

  def redirect_limit(); end

  def request(uri, headers); end
end

class Bundler::Fetcher::Downloader
end

class Bundler::Fetcher::Index
  def fetch_spec(spec); end

  def specs(_gem_names); end
end

class Bundler::Fetcher::Index
end

class Bundler::Fetcher::SSLError
  def initialize(msg=T.unsafe(nil)); end
end

class Bundler::Fetcher::TooManyRequestsError
end

class Bundler::Fetcher::TooManyRequestsError
end

class Bundler::Fetcher
  def self.api_timeout(); end

  def self.api_timeout=(api_timeout); end

  def self.disable_endpoint(); end

  def self.disable_endpoint=(disable_endpoint); end

  def self.max_retries(); end

  def self.max_retries=(max_retries); end

  def self.redirect_limit(); end

  def self.redirect_limit=(redirect_limit); end
end

module Bundler::FileUtils
  VERSION = ::T.let(nil, ::T.untyped)
end

class Bundler::FileUtils::Entry_
  def link(dest); end
end

module Bundler::FileUtils
  def self.cp_lr(src, dest, noop: T.unsafe(nil), verbose: T.unsafe(nil), dereference_root: T.unsafe(nil), remove_destination: T.unsafe(nil)); end

  def self.link_entry(src, dest, dereference_root=T.unsafe(nil), remove_destination=T.unsafe(nil)); end
end

class Bundler::GemHelper
  include ::Rake::DSL
  include ::Rake::FileUtilsExt
  include ::FileUtils
  include ::FileUtils::StreamUtils_
  def allowed_push_host(); end

  def already_tagged?(); end

  def base(); end

  def build_gem(); end

  def built_gem_path(); end

  def clean?(); end

  def committed?(); end

  def gem_command(); end

  def gem_key(); end

  def gem_push?(); end

  def gem_push_host(); end

  def gemspec(); end

  def git_push(remote=T.unsafe(nil)); end

  def guard_clean(); end

  def initialize(base=T.unsafe(nil), name=T.unsafe(nil)); end

  def install(); end

  def install_gem(built_gem_path=T.unsafe(nil), local=T.unsafe(nil)); end

  def name(); end

  def perform_git_push(options=T.unsafe(nil)); end

  def rubygem_push(path); end

  def sh(cmd, &block); end

  def sh_with_input(cmd); end

  def sh_with_status(cmd, &block); end

  def spec_path(); end

  def tag_version(); end

  def version(); end

  def version_tag(); end
end

class Bundler::GemHelper
  def self.gemspec(&block); end

  def self.install_tasks(opts=T.unsafe(nil)); end

  def self.instance(); end

  def self.instance=(instance); end
end

class Bundler::GemVersionPromoter
  def initialize(locked_specs=T.unsafe(nil), unlock_gems=T.unsafe(nil)); end

  def level(); end

  def level=(value); end

  def locked_specs(); end

  def major?(); end

  def minor?(); end

  def prerelease_specified(); end

  def prerelease_specified=(prerelease_specified); end

  def sort_versions(dep, spec_groups); end

  def strict(); end

  def strict=(strict); end

  def unlock_gems(); end
  DEBUG = ::T.let(nil, ::T.untyped)
end

class Bundler::GemVersionPromoter
end

class Bundler::Graph
  def edge_options(); end

  def groups(); end

  def initialize(env, output_file, show_version=T.unsafe(nil), show_requirements=T.unsafe(nil), output_format=T.unsafe(nil), without=T.unsafe(nil)); end

  def node_options(); end

  def output_file(); end

  def output_format(); end

  def relations(); end

  def viz(); end
  GRAPH_NAME = ::T.let(nil, ::T.untyped)
end

class Bundler::Graph::GraphVizClient
  def g(); end

  def initialize(graph_instance); end

  def run(); end
end

class Bundler::Graph::GraphVizClient
end

class Bundler::Graph
end

class Bundler::Index
  include ::Enumerable
end

class Bundler::Injector
  def initialize(deps, options=T.unsafe(nil)); end

  def inject(gemfile_path, lockfile_path); end

  def remove(gemfile_path, lockfile_path); end
  INJECTED_GEMS = ::T.let(nil, ::T.untyped)
end

class Bundler::Injector
  def self.inject(new_deps, options=T.unsafe(nil)); end

  def self.remove(gems, options=T.unsafe(nil)); end
end

class Bundler::Installer
  def generate_bundler_executable_stubs(spec, options=T.unsafe(nil)); end

  def generate_standalone_bundler_executable_stubs(spec); end

  def initialize(root, definition); end

  def post_install_messages(); end

  def run(options); end
end

class Bundler::Installer
  def self.ambiguous_gems(); end

  def self.ambiguous_gems=(ambiguous_gems); end

  def self.install(root, definition, options=T.unsafe(nil)); end
end

class Bundler::Molinillo::DependencyGraph
  include ::Enumerable
end

class Bundler::Molinillo::DependencyGraph::Log
  extend ::Enumerable
end

class Bundler::Molinillo::DependencyGraph::Vertex
  def _recursive_predecessors(vertices=T.unsafe(nil)); end

  def _recursive_successors(vertices=T.unsafe(nil)); end
end

module Bundler::Plugin::API::Source
  def ==(other); end

  def app_cache_dirname(); end

  def app_cache_path(custom_path=T.unsafe(nil)); end

  def bundler_plugin_api_source?(); end

  def cache(spec, custom_path=T.unsafe(nil)); end

  def cached!(); end

  def can_lock?(spec); end

  def dependency_names(); end

  def dependency_names=(dependency_names); end

  def double_check_for(*_); end

  def eql?(other); end

  def fetch_gemspec_files(); end

  def gem_install_dir(); end

  def hash(); end

  def include?(other); end

  def initialize(opts); end

  def install(spec, opts); end

  def install_path(); end

  def installed?(); end

  def name(); end

  def options(); end

  def options_to_lock(); end

  def post_install(spec, disable_exts=T.unsafe(nil)); end

  def remote!(); end

  def root(); end

  def specs(); end

  def to_lock(); end

  def to_s(); end

  def unlock!(); end

  def unmet_deps(); end

  def uri(); end

  def uri_hash(); end
end

module Bundler::Plugin::API::Source
end

module Bundler::Plugin::Events
  GEM_AFTER_INSTALL = ::T.let(nil, ::T.untyped)
  GEM_AFTER_INSTALL_ALL = ::T.let(nil, ::T.untyped)
  GEM_BEFORE_INSTALL = ::T.let(nil, ::T.untyped)
  GEM_BEFORE_INSTALL_ALL = ::T.let(nil, ::T.untyped)
end

class Bundler::Plugin::Index
  def installed_plugins(); end

  def plugin_commands(plugin); end
end

class Bundler::Plugin::Index::CommandConflict
  def initialize(plugin, commands); end
end

class Bundler::Plugin::Index::CommandConflict
end

class Bundler::Plugin::Index::SourceConflict
  def initialize(plugin, sources); end
end

class Bundler::Plugin::Index::SourceConflict
end

class Bundler::Plugin::Installer
  def install(names, options); end

  def install_definition(definition); end
end

class Bundler::Plugin::Installer::Git
  def generate_bin(spec, disable_extensions=T.unsafe(nil)); end
end

class Bundler::Plugin::Installer::Git
end

class Bundler::Plugin::Installer::Rubygems
end

class Bundler::Plugin::Installer::Rubygems
end

class Bundler::Plugin::Installer
end

class Bundler::Plugin::SourceList
end

class Bundler::Plugin::SourceList
end

module Bundler::Plugin
  def self.list(); end
end

class Bundler::ProcessLock
end

class Bundler::ProcessLock
  def self.lock(bundle_path=T.unsafe(nil)); end
end

class Bundler::Retry
  def attempt(&block); end

  def attempts(&block); end

  def current_run(); end

  def current_run=(current_run); end

  def initialize(name, exceptions=T.unsafe(nil), retries=T.unsafe(nil)); end

  def name(); end

  def name=(name); end

  def total_runs(); end

  def total_runs=(total_runs); end
end

class Bundler::Retry
  def self.attempts(); end

  def self.default_attempts(); end

  def self.default_retries(); end
end

class Bundler::RubyGemsGemInstaller
end

class Bundler::RubyGemsGemInstaller
end

class Bundler::RubygemsIntegration
  def add_to_load_path(paths); end

  def all_specs(); end

  def backport_ext_builder_monitor(); end

  def correct_for_windows_path(path); end

  def default_stubs(); end

  def find_name(name); end

  def gem_remote_fetcher(); end

  def plain_specs(); end

  def plain_specs=(specs); end

  def stub_rubygems(specs); end

  def use_gemdeps(gemfile); end
end

class Bundler::Settings::Mirror
  def ==(other); end

  def fallback_timeout(); end

  def fallback_timeout=(timeout); end

  def initialize(uri=T.unsafe(nil), fallback_timeout=T.unsafe(nil)); end

  def uri(); end

  def uri=(uri); end

  def valid?(); end

  def validate!(probe=T.unsafe(nil)); end
  DEFAULT_FALLBACK_TIMEOUT = ::T.let(nil, ::T.untyped)
end

class Bundler::Settings::Mirror
end

class Bundler::Settings::Mirrors
  def each(&blk); end

  def for(uri); end

  def initialize(prober=T.unsafe(nil)); end

  def parse(key, value); end
end

class Bundler::Settings::Mirrors
end

class Bundler::Settings::Validator
end

class Bundler::Settings::Validator::Rule
  def description(); end

  def fail!(key, value, *reasons); end

  def initialize(keys, description, &validate); end

  def k(key); end

  def set(settings, key, value, *reasons); end

  def validate!(key, value, settings); end
end

class Bundler::Settings::Validator::Rule
end

class Bundler::Settings::Validator
  def self.validate!(key, value, settings); end
end

class Bundler::Source::Git
  def glob(); end
end

class Bundler::SpecSet
  include ::Enumerable
end

class Bundler::Thor
  include ::Bundler::Thor::Base
  include ::Bundler::Thor::Invocation
  include ::Bundler::Thor::Shell
  def help(command=T.unsafe(nil), subcommand=T.unsafe(nil)); end
  HELP_MAPPINGS = ::T.let(nil, ::T.untyped)
  TEMPLATE_EXTNAME = ::T.let(nil, ::T.untyped)
  THOR_RESERVED_WORDS = ::T.let(nil, ::T.untyped)
end

module Bundler::Thor::Actions
  def _cleanup_options_and_set(options, key); end

  def _shared_configuration(); end

  def action(instance); end

  def add_file(destination, *args, &block); end

  def add_link(destination, *args); end

  def append_file(path, *args, &block); end

  def append_to_file(path, *args, &block); end

  def apply(path, config=T.unsafe(nil)); end

  def behavior(); end

  def behavior=(behavior); end

  def chmod(path, mode, config=T.unsafe(nil)); end

  def comment_lines(path, flag, *args); end

  def copy_file(source, *args, &block); end

  def create_file(destination, *args, &block); end

  def create_link(destination, *args); end

  def destination_root(); end

  def destination_root=(root); end

  def directory(source, *args, &block); end

  def empty_directory(destination, config=T.unsafe(nil)); end

  def find_in_source_paths(file); end

  def get(source, *args, &block); end

  def gsub_file(path, flag, *args, &block); end

  def in_root(); end

  def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil)); end

  def inject_into_class(path, klass, *args, &block); end

  def inject_into_file(destination, *args, &block); end

  def inject_into_module(path, module_name, *args, &block); end

  def insert_into_file(destination, *args, &block); end

  def inside(dir=T.unsafe(nil), config=T.unsafe(nil), &block); end

  def link_file(source, *args); end

  def prepend_file(path, *args, &block); end

  def prepend_to_file(path, *args, &block); end

  def relative_to_original_destination_root(path, remove_dot=T.unsafe(nil)); end

  def remove_dir(path, config=T.unsafe(nil)); end

  def remove_file(path, config=T.unsafe(nil)); end

  def run(command, config=T.unsafe(nil)); end

  def run_ruby_script(command, config=T.unsafe(nil)); end

  def source_paths(); end

  def template(source, *args, &block); end

  def thor(command, *args); end

  def uncomment_lines(path, flag, *args); end
  WARNINGS = ::T.let(nil, ::T.untyped)
end

class Bundler::Thor::Actions::CapturableERB
end

class Bundler::Thor::Actions::CapturableERB
end

module Bundler::Thor::Actions::ClassMethods
  def add_runtime_options!(); end

  def source_paths(); end

  def source_paths_for_search(); end

  def source_root(path=T.unsafe(nil)); end
end

module Bundler::Thor::Actions::ClassMethods
end

class Bundler::Thor::Actions::CreateFile
  def data(); end

  def force_on_collision?(); end

  def force_or_skip_or_conflict(force, skip, &block); end

  def identical?(); end

  def initialize(base, destination, data, config=T.unsafe(nil)); end

  def on_conflict_behavior(&block); end

  def render(); end
end

class Bundler::Thor::Actions::CreateFile
end

class Bundler::Thor::Actions::CreateLink
end

class Bundler::Thor::Actions::CreateLink
end

class Bundler::Thor::Actions::Directory
  def execute!(); end

  def file_level_lookup(previous_lookup); end

  def files(lookup); end

  def initialize(base, source, destination=T.unsafe(nil), config=T.unsafe(nil), &block); end

  def source(); end
end

class Bundler::Thor::Actions::Directory
end

class Bundler::Thor::Actions::EmptyDirectory
  def base(); end

  def config(); end

  def convert_encoded_instructions(filename); end

  def destination(); end

  def destination=(destination); end

  def exists?(); end

  def given_destination(); end

  def initialize(base, destination, config=T.unsafe(nil)); end

  def invoke!(); end

  def invoke_with_conflict_check(&block); end

  def on_conflict_behavior(); end

  def on_file_clash_behavior(); end

  def pretend?(); end

  def relative_destination(); end

  def revoke!(); end

  def say_status(status, color); end
end

class Bundler::Thor::Actions::EmptyDirectory
end

class Bundler::Thor::Actions::InjectIntoFile
  def behavior(); end

  def flag(); end

  def initialize(base, destination, data, config); end

  def replace!(regexp, string, force); end

  def replacement(); end

  def say_status(behavior, warning: T.unsafe(nil), color: T.unsafe(nil)); end
end

class Bundler::Thor::Actions::InjectIntoFile
end

module Bundler::Thor::Actions
  def self.included(base); end
end

class Bundler::Thor::AmbiguousCommandError
end

class Bundler::Thor::AmbiguousCommandError
end

Bundler::Thor::AmbiguousTaskError = Bundler::Thor::AmbiguousCommandError

class Bundler::Thor::Argument
  def banner(); end

  def default(); end

  def default_banner(); end

  def description(); end

  def enum(); end

  def human_name(); end

  def initialize(name, options=T.unsafe(nil)); end

  def name(); end

  def required(); end

  def required?(); end

  def show_default?(); end

  def type(); end

  def usage(); end

  def valid_type?(type); end

  def validate!(); end
  VALID_TYPES = ::T.let(nil, ::T.untyped)
end

class Bundler::Thor::Argument
end

class Bundler::Thor::Arguments
  def initialize(arguments=T.unsafe(nil)); end

  def parse(args); end

  def remaining(); end
  NUMERIC = ::T.let(nil, ::T.untyped)
end

class Bundler::Thor::Arguments
  def self.parse(*args); end

  def self.split(args); end
end

module Bundler::Thor::Base
  def args(); end

  def args=(args); end

  def initialize(args=T.unsafe(nil), local_options=T.unsafe(nil), config=T.unsafe(nil)); end

  def options(); end

  def options=(options); end

  def parent_options(); end

  def parent_options=(parent_options); end
end

module Bundler::Thor::Base::ClassMethods
  def all_commands(); end

  def all_tasks(); end

  def allow_incompatible_default_type!(); end

  def argument(name, options=T.unsafe(nil)); end

  def arguments(); end

  def attr_accessor(*_); end

  def attr_reader(*_); end

  def attr_writer(*_); end

  def baseclass(); end

  def basename(); end

  def build_option(name, options, scope); end

  def build_options(options, scope); end

  def check_default_type(); end

  def check_default_type!(); end

  def check_unknown_options(); end

  def check_unknown_options!(); end

  def check_unknown_options?(config); end

  def class_option(name, options=T.unsafe(nil)); end

  def class_options(options=T.unsafe(nil)); end

  def class_options_help(shell, groups=T.unsafe(nil)); end

  def commands(); end

  def create_command(meth); end

  def create_task(meth); end

  def disable_required_check?(command_name); end

  def dispatch(command, given_args, given_opts, config); end

  def exit_on_failure?(); end

  def find_and_refresh_command(name); end

  def find_and_refresh_task(name); end

  def from_superclass(method, default=T.unsafe(nil)); end

  def group(name=T.unsafe(nil)); end

  def handle_argument_error(command, error, args, arity); end

  def handle_no_command_error(command, has_namespace=T.unsafe(nil)); end

  def handle_no_task_error(command, has_namespace=T.unsafe(nil)); end

  def inherited(klass); end

  def initialize_added(); end

  def is_thor_reserved_word?(word, type); end

  def method_added(meth); end

  def namespace(name=T.unsafe(nil)); end

  def no_commands(&block); end

  def no_commands?(); end

  def no_commands_context(); end

  def no_tasks(&block); end

  def print_options(shell, options, group_name=T.unsafe(nil)); end

  def public_command(*names); end

  def public_task(*names); end

  def remove_argument(*names); end

  def remove_class_option(*names); end

  def remove_command(*names); end

  def remove_task(*names); end

  def start(given_args=T.unsafe(nil), config=T.unsafe(nil)); end

  def stop_on_unknown_option?(command_name); end

  def strict_args_position(); end

  def strict_args_position!(); end

  def strict_args_position?(config); end

  def tasks(); end
end

module Bundler::Thor::Base::ClassMethods
end

module Bundler::Thor::Base
  def self.included(base); end

  def self.register_klass_file(klass); end

  def self.shell(); end

  def self.shell=(shell); end

  def self.subclass_files(); end

  def self.subclasses(); end
end

class Bundler::Thor::Command
  def formatted_usage(klass, namespace=T.unsafe(nil), subcommand=T.unsafe(nil)); end

  def handle_argument_error?(instance, error, caller); end

  def handle_no_method_error?(instance, error, caller); end

  def hidden?(); end

  def initialize(name, description, long_description, usage, options=T.unsafe(nil)); end

  def local_method?(instance, name); end

  def not_debugging?(instance); end

  def private_method?(instance); end

  def public_method?(instance); end

  def required_arguments_for(klass, usage); end

  def required_options(); end

  def run(instance, args=T.unsafe(nil)); end

  def sans_backtrace(backtrace, caller); end
  FILE_REGEXP = ::T.let(nil, ::T.untyped)
end

class Bundler::Thor::Command
end

module Bundler::Thor::CoreExt
end

class Bundler::Thor::CoreExt::HashWithIndifferentAccess
  def [](key); end

  def []=(key, value); end

  def convert_key(key); end

  def delete(key); end

  def fetch(key, *args); end

  def initialize(hash=T.unsafe(nil)); end

  def key?(key); end

  def merge(other); end

  def merge!(other); end

  def method_missing(method, *args); end

  def replace(other_hash); end

  def reverse_merge(other); end

  def values_at(*indices); end
end

class Bundler::Thor::CoreExt::HashWithIndifferentAccess
end

module Bundler::Thor::CoreExt
end

Bundler::Thor::Correctable = DidYouMean::Correctable

class Bundler::Thor::DynamicCommand
  def initialize(name, options=T.unsafe(nil)); end
end

class Bundler::Thor::DynamicCommand
end

Bundler::Thor::DynamicTask = Bundler::Thor::DynamicCommand

class Bundler::Thor::Error
end

class Bundler::Thor::Error
end

class Bundler::Thor::Group
  include ::Bundler::Thor::Base
  include ::Bundler::Thor::Invocation
  include ::Bundler::Thor::Shell
  def _invoke_for_class_method(klass, command=T.unsafe(nil), *args, &block); end
end

class Bundler::Thor::Group
  extend ::Bundler::Thor::Base::ClassMethods
  extend ::Bundler::Thor::Invocation::ClassMethods
  def self.banner(); end

  def self.desc(description=T.unsafe(nil)); end

  def self.get_options_from_invocations(group_options, base_options); end

  def self.handle_argument_error(command, error, _args, arity); end

  def self.help(shell); end

  def self.invocation_blocks(); end

  def self.invocations(); end

  def self.invoke(*names, &block); end

  def self.invoke_from_option(*names, &block); end

  def self.printable_commands(*_); end

  def self.printable_tasks(*_); end

  def self.remove_invocation(*names); end

  def self.self_command(); end

  def self.self_task(); end
end

class Bundler::Thor::HiddenCommand
end

class Bundler::Thor::HiddenCommand
end

Bundler::Thor::HiddenTask = Bundler::Thor::HiddenCommand

module Bundler::Thor::Invocation
  def _parse_initialization_options(args, opts, config); end

  def _retrieve_class_and_command(name, sent_command=T.unsafe(nil)); end

  def _retrieve_class_and_task(name, sent_command=T.unsafe(nil)); end

  def _shared_configuration(); end

  def current_command_chain(); end

  def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil), &block); end

  def invoke(name=T.unsafe(nil), *args); end

  def invoke_all(); end

  def invoke_command(command, *args); end

  def invoke_task(command, *args); end

  def invoke_with_padding(*args); end
end

module Bundler::Thor::Invocation::ClassMethods
  def prepare_for_invocation(key, name); end
end

module Bundler::Thor::Invocation::ClassMethods
end

module Bundler::Thor::Invocation
  def self.included(base); end
end

class Bundler::Thor::InvocationError
end

class Bundler::Thor::InvocationError
end

module Bundler::Thor::LineEditor
end

class Bundler::Thor::LineEditor::Basic
  def initialize(prompt, options); end

  def options(); end

  def prompt(); end

  def readline(); end
end

class Bundler::Thor::LineEditor::Basic
  def self.available?(); end
end

class Bundler::Thor::LineEditor::Readline
end

class Bundler::Thor::LineEditor::Readline::PathCompletion
  def initialize(text); end

  def matches(); end
end

class Bundler::Thor::LineEditor::Readline::PathCompletion
end

class Bundler::Thor::LineEditor::Readline
end

module Bundler::Thor::LineEditor
  def self.best_available(); end

  def self.readline(prompt, options=T.unsafe(nil)); end
end

class Bundler::Thor::MalformattedArgumentError
end

class Bundler::Thor::MalformattedArgumentError
end

class Bundler::Thor::NestedContext
  def enter(); end

  def entered?(); end
end

class Bundler::Thor::NestedContext
end

class Bundler::Thor::NoKwargSpellChecker
  def initialize(dictionary); end
end

class Bundler::Thor::NoKwargSpellChecker
end

class Bundler::Thor::Option
  def aliases(); end

  def array?(); end

  def boolean?(); end

  def dasherize(str); end

  def dasherized?(); end

  def group(); end

  def hash?(); end

  def hide(); end

  def lazy_default(); end

  def numeric?(); end

  def repeatable(); end

  def string?(); end

  def switch_name(); end

  def undasherize(str); end

  def usage(padding=T.unsafe(nil)); end

  def validate_default_type!(); end
  VALID_TYPES = ::T.let(nil, ::T.untyped)
end

class Bundler::Thor::Option
  def self.parse(key, value); end
end

class Bundler::Thor::Options
  def assign_result!(option, result); end

  def check_unknown!(); end

  def current_is_switch?(); end

  def current_is_switch_formatted?(); end

  def initialize(hash_options=T.unsafe(nil), defaults=T.unsafe(nil), stop_on_unknown=T.unsafe(nil), disable_required_check=T.unsafe(nil)); end

  def normalize_switch(arg); end

  def parse_boolean(switch); end

  def parse_peek(switch, option); end

  def parsing_options?(); end

  def switch?(arg); end

  def switch_option(arg); end
  EQ_RE = ::T.let(nil, ::T.untyped)
  LONG_RE = ::T.let(nil, ::T.untyped)
  OPTS_END = ::T.let(nil, ::T.untyped)
  SHORT_NUM = ::T.let(nil, ::T.untyped)
  SHORT_RE = ::T.let(nil, ::T.untyped)
  SHORT_SQ_RE = ::T.let(nil, ::T.untyped)
end

class Bundler::Thor::Options
  def self.to_switches(options); end
end

module Bundler::Thor::RakeCompat
  include ::Rake::DSL
  include ::Rake::FileUtilsExt
  include ::FileUtils
  include ::FileUtils::StreamUtils_
end

module Bundler::Thor::RakeCompat
  def self.included(base); end

  def self.rake_classes(); end
end

class Bundler::Thor::RequiredArgumentMissingError
end

class Bundler::Thor::RequiredArgumentMissingError
end

module Bundler::Thor::Sandbox
end

module Bundler::Thor::Sandbox
end

module Bundler::Thor::Shell
  def _shared_configuration(); end

  def ask(*args, &block); end

  def error(*args, &block); end

  def file_collision(*args, &block); end

  def initialize(args=T.unsafe(nil), options=T.unsafe(nil), config=T.unsafe(nil)); end

  def no?(*args, &block); end

  def print_in_columns(*args, &block); end

  def print_table(*args, &block); end

  def print_wrapped(*args, &block); end

  def say(*args, &block); end

  def say_status(*args, &block); end

  def set_color(*args, &block); end

  def shell(); end

  def shell=(shell); end

  def terminal_width(*args, &block); end

  def with_padding(); end

  def yes?(*args, &block); end
  SHELL_DELEGATED_METHODS = ::T.let(nil, ::T.untyped)
end

class Bundler::Thor::Shell::Basic
  def answer_match(possibilities, answer, case_insensitive); end

  def as_unicode(); end

  def ask(statement, *args); end

  def ask_filtered(statement, color, options); end

  def ask_simply(statement, color, options); end

  def base(); end

  def base=(base); end

  def can_display_colors?(); end

  def dynamic_width(); end

  def dynamic_width_stty(); end

  def dynamic_width_tput(); end

  def error(statement); end

  def file_collision(destination); end

  def file_collision_help(); end

  def git_merge_tool(); end

  def indent(count=T.unsafe(nil)); end

  def is?(value); end

  def lookup_color(color); end

  def merge(destination, content); end

  def merge_tool(); end

  def mute(); end

  def mute?(); end

  def no?(statement, color=T.unsafe(nil)); end

  def padding(); end

  def padding=(value); end

  def prepare_message(message, *color); end

  def print_in_columns(array); end

  def print_table(array, options=T.unsafe(nil)); end

  def print_wrapped(message, options=T.unsafe(nil)); end

  def quiet?(); end

  def say(message=T.unsafe(nil), color=T.unsafe(nil), force_new_line=T.unsafe(nil)); end

  def say_status(status, message, log_status=T.unsafe(nil)); end

  def set_color(string, *_); end

  def show_diff(destination, content); end

  def stderr(); end

  def stdout(); end

  def terminal_width(); end

  def truncate(string, width); end

  def unix?(); end

  def yes?(statement, color=T.unsafe(nil)); end
  DEFAULT_TERMINAL_WIDTH = ::T.let(nil, ::T.untyped)
end

class Bundler::Thor::Shell::Basic
end

class Bundler::Thor::Shell::Color
  def are_colors_disabled?(); end

  def diff_lcs_loaded?(); end

  def output_diff_line(diff); end

  def set_color(string, *colors); end
  BLACK = ::T.let(nil, ::T.untyped)
  BLUE = ::T.let(nil, ::T.untyped)
  BOLD = ::T.let(nil, ::T.untyped)
  CLEAR = ::T.let(nil, ::T.untyped)
  CYAN = ::T.let(nil, ::T.untyped)
  GREEN = ::T.let(nil, ::T.untyped)
  MAGENTA = ::T.let(nil, ::T.untyped)
  ON_BLACK = ::T.let(nil, ::T.untyped)
  ON_BLUE = ::T.let(nil, ::T.untyped)
  ON_CYAN = ::T.let(nil, ::T.untyped)
  ON_GREEN = ::T.let(nil, ::T.untyped)
  ON_MAGENTA = ::T.let(nil, ::T.untyped)
  ON_RED = ::T.let(nil, ::T.untyped)
  ON_WHITE = ::T.let(nil, ::T.untyped)
  ON_YELLOW = ::T.let(nil, ::T.untyped)
  RED = ::T.let(nil, ::T.untyped)
  WHITE = ::T.let(nil, ::T.untyped)
  YELLOW = ::T.let(nil, ::T.untyped)
end

class Bundler::Thor::Shell::Color
end

class Bundler::Thor::Shell::HTML
  def ask(statement, color=T.unsafe(nil)); end

  def diff_lcs_loaded?(); end

  def output_diff_line(diff); end

  def set_color(string, *colors); end
  BLACK = ::T.let(nil, ::T.untyped)
  BLUE = ::T.let(nil, ::T.untyped)
  BOLD = ::T.let(nil, ::T.untyped)
  CYAN = ::T.let(nil, ::T.untyped)
  GREEN = ::T.let(nil, ::T.untyped)
  MAGENTA = ::T.let(nil, ::T.untyped)
  ON_BLACK = ::T.let(nil, ::T.untyped)
  ON_BLUE = ::T.let(nil, ::T.untyped)
  ON_CYAN = ::T.let(nil, ::T.untyped)
  ON_GREEN = ::T.let(nil, ::T.untyped)
  ON_MAGENTA = ::T.let(nil, ::T.untyped)
  ON_RED = ::T.let(nil, ::T.untyped)
  ON_WHITE = ::T.let(nil, ::T.untyped)
  ON_YELLOW = ::T.let(nil, ::T.untyped)
  RED = ::T.let(nil, ::T.untyped)
  WHITE = ::T.let(nil, ::T.untyped)
  YELLOW = ::T.let(nil, ::T.untyped)
end

class Bundler::Thor::Shell::HTML
end

module Bundler::Thor::Shell
end

Bundler::Thor::Task = Bundler::Thor::Command

class Bundler::Thor::UndefinedCommandError
  include ::DidYouMean::Correctable
  def all_commands(); end

  def command(); end

  def initialize(command, all_commands, namespace); end
end

class Bundler::Thor::UndefinedCommandError::SpellChecker
  def corrections(); end

  def error(); end

  def initialize(error); end

  def spell_checker(); end
end

class Bundler::Thor::UndefinedCommandError::SpellChecker
end

class Bundler::Thor::UndefinedCommandError
end

Bundler::Thor::UndefinedTaskError = Bundler::Thor::UndefinedCommandError

class Bundler::Thor::UnknownArgumentError
  include ::DidYouMean::Correctable
  def initialize(switches, unknown); end

  def switches(); end

  def unknown(); end
end

class Bundler::Thor::UnknownArgumentError::SpellChecker
  def corrections(); end

  def error(); end

  def initialize(error); end

  def spell_checker(); end
end

class Bundler::Thor::UnknownArgumentError::SpellChecker
end

class Bundler::Thor::UnknownArgumentError
end

module Bundler::Thor::Util
end

module Bundler::Thor::Util
  def self.camel_case(str); end

  def self.escape_globs(path); end

  def self.escape_html(string); end

  def self.find_by_namespace(namespace); end

  def self.find_class_and_command_by_namespace(namespace, fallback=T.unsafe(nil)); end

  def self.find_class_and_task_by_namespace(namespace, fallback=T.unsafe(nil)); end

  def self.globs_for(path); end

  def self.load_thorfile(path, content=T.unsafe(nil), debug=T.unsafe(nil)); end

  def self.namespace_from_thor_class(constant); end

  def self.namespaces_in_content(contents, file=T.unsafe(nil)); end

  def self.ruby_command(); end

  def self.snake_case(str); end

  def self.thor_classes_in(klass); end

  def self.thor_root(); end

  def self.thor_root_glob(); end

  def self.user_home(); end
end

class Bundler::Thor
  extend ::Bundler::Thor::Base::ClassMethods
  extend ::Bundler::Thor::Invocation::ClassMethods
  def self.banner(command, namespace=T.unsafe(nil), subcommand=T.unsafe(nil)); end

  def self.check_unknown_options!(options=T.unsafe(nil)); end

  def self.command_help(shell, command_name); end

  def self.default_command(meth=T.unsafe(nil)); end

  def self.default_task(meth=T.unsafe(nil)); end

  def self.deprecation_warning(message); end

  def self.desc(usage, description, options=T.unsafe(nil)); end

  def self.disable_required_check(); end

  def self.disable_required_check!(*command_names); end

  def self.disable_required_check?(command); end

  def self.dispatch(meth, given_args, given_opts, config); end

  def self.dynamic_command_class(); end

  def self.find_command_possibilities(meth); end

  def self.find_task_possibilities(meth); end

  def self.help(shell, subcommand=T.unsafe(nil)); end

  def self.long_desc(long_description, options=T.unsafe(nil)); end

  def self.map(mappings=T.unsafe(nil), **kw); end

  def self.method_option(name, options=T.unsafe(nil)); end

  def self.method_options(options=T.unsafe(nil)); end

  def self.normalize_command_name(meth); end

  def self.normalize_task_name(meth); end

  def self.option(name, options=T.unsafe(nil)); end

  def self.options(options=T.unsafe(nil)); end

  def self.package_name(name, _=T.unsafe(nil)); end

  def self.printable_commands(all=T.unsafe(nil), subcommand=T.unsafe(nil)); end

  def self.printable_tasks(all=T.unsafe(nil), subcommand=T.unsafe(nil)); end

  def self.register(klass, subcommand_name, usage, description, options=T.unsafe(nil)); end

  def self.retrieve_command_name(args); end

  def self.retrieve_task_name(args); end

  def self.stop_on_unknown_option(); end

  def self.stop_on_unknown_option!(*command_names); end

  def self.stop_on_unknown_option?(command); end

  def self.subcommand(subcommand, subcommand_class); end

  def self.subcommand_classes(); end

  def self.subcommand_help(cmd); end

  def self.subcommands(); end

  def self.subtask(subcommand, subcommand_class); end

  def self.subtask_help(cmd); end

  def self.subtasks(); end

  def self.task_help(shell, command_name); end
end

class Bundler::UI::Shell
  def add_color(string, *color); end

  def ask(msg); end

  def confirm(msg, newline=T.unsafe(nil)); end

  def debug(msg, newline=T.unsafe(nil)); end

  def debug?(); end

  def error(msg, newline=T.unsafe(nil)); end

  def info(msg, newline=T.unsafe(nil)); end

  def initialize(options=T.unsafe(nil)); end

  def level(name=T.unsafe(nil)); end

  def level=(level); end

  def no?(); end

  def quiet?(); end

  def shell=(shell); end

  def silence(&blk); end

  def trace(e, newline=T.unsafe(nil), force=T.unsafe(nil)); end

  def unprinted_warnings(); end

  def warn(msg, newline=T.unsafe(nil)); end

  def yes?(msg); end
  LEVELS = ::T.let(nil, ::T.untyped)
end

class Bundler::UI::Shell
end

module Bundler::URI
  include ::Bundler::URI::RFC2396_REGEXP
  ABS_PATH = ::T.let(nil, ::T.untyped)
  ABS_URI = ::T.let(nil, ::T.untyped)
  ABS_URI_REF = ::T.let(nil, ::T.untyped)
  DEFAULT_PARSER = ::T.let(nil, ::T.untyped)
  ESCAPED = ::T.let(nil, ::T.untyped)
  FRAGMENT = ::T.let(nil, ::T.untyped)
  HOST = ::T.let(nil, ::T.untyped)
  OPAQUE = ::T.let(nil, ::T.untyped)
  PORT = ::T.let(nil, ::T.untyped)
  QUERY = ::T.let(nil, ::T.untyped)
  REGISTRY = ::T.let(nil, ::T.untyped)
  REL_PATH = ::T.let(nil, ::T.untyped)
  REL_URI = ::T.let(nil, ::T.untyped)
  REL_URI_REF = ::T.let(nil, ::T.untyped)
  RFC3986_PARSER = ::T.let(nil, ::T.untyped)
  SCHEME = ::T.let(nil, ::T.untyped)
  TBLDECWWWCOMP_ = ::T.let(nil, ::T.untyped)
  TBLENCWWWCOMP_ = ::T.let(nil, ::T.untyped)
  UNSAFE = ::T.let(nil, ::T.untyped)
  URI_REF = ::T.let(nil, ::T.untyped)
  USERINFO = ::T.let(nil, ::T.untyped)
  VERSION = ::T.let(nil, ::T.untyped)
  VERSION_CODE = ::T.let(nil, ::T.untyped)
  WEB_ENCODINGS_ = ::T.let(nil, ::T.untyped)
end

class Bundler::URI::BadURIError
end

class Bundler::URI::BadURIError
end

class Bundler::URI::Error
end

class Bundler::URI::Error
end

module Bundler::URI::Escape
  def decode(*arg); end

  def encode(*arg); end

  def escape(*arg); end

  def unescape(*arg); end
end

module Bundler::URI::Escape
end

class Bundler::URI::FTP
  def set_typecode(v); end

  def typecode(); end

  def typecode=(typecode); end
  COMPONENT = ::T.let(nil, ::T.untyped)
  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
  TYPECODE = ::T.let(nil, ::T.untyped)
  TYPECODE_PREFIX = ::T.let(nil, ::T.untyped)
end

class Bundler::URI::FTP
  def self.new2(user, password, host, port, path, typecode=T.unsafe(nil), arg_check=T.unsafe(nil)); end
end

class Bundler::URI::File
  def check_password(user); end

  def check_user(user); end

  def check_userinfo(user); end

  def set_userinfo(v); end
  COMPONENT = ::T.let(nil, ::T.untyped)
  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
end

class Bundler::URI::File
end

class Bundler::URI::Generic
  include ::Bundler::URI
  include ::Bundler::URI::RFC2396_REGEXP
  def +(oth); end

  def -(oth); end

  def ==(oth); end

  def absolute(); end

  def absolute?(); end

  def coerce(oth); end

  def component(); end

  def component_ary(); end

  def default_port(); end

  def eql?(oth); end

  def find_proxy(env=T.unsafe(nil)); end

  def fragment(); end

  def fragment=(v); end

  def hierarchical?(); end

  def host(); end

  def host=(v); end

  def hostname(); end

  def hostname=(v); end

  def initialize(scheme, userinfo, host, port, registry, path, opaque, query, fragment, parser=T.unsafe(nil), arg_check=T.unsafe(nil)); end

  def merge(oth); end

  def merge!(oth); end

  def normalize(); end

  def normalize!(); end

  def opaque(); end

  def opaque=(v); end

  def parser(); end

  def password(); end

  def password=(password); end

  def path(); end

  def path=(v); end

  def port(); end

  def port=(v); end

  def query(); end

  def query=(v); end

  def registry(); end

  def registry=(v); end

  def relative?(); end

  def route_from(oth); end

  def route_to(oth); end

  def scheme(); end

  def scheme=(v); end

  def select(*components); end

  def set_host(v); end

  def set_opaque(v); end

  def set_password(v); end

  def set_path(v); end

  def set_port(v); end

  def set_registry(v); end

  def set_scheme(v); end

  def set_user(v); end

  def set_userinfo(user, password=T.unsafe(nil)); end

  def user(); end

  def user=(user); end

  def userinfo(); end

  def userinfo=(userinfo); end
  COMPONENT = ::T.let(nil, ::T.untyped)
  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
  USE_REGISTRY = ::T.let(nil, ::T.untyped)
end

class Bundler::URI::Generic
  def self.build(args); end

  def self.build2(args); end

  def self.component(); end

  def self.default_port(); end

  def self.use_proxy?(hostname, addr, port, no_proxy); end

  def self.use_registry(); end
end

class Bundler::URI::HTTP
  def request_uri(); end
  COMPONENT = ::T.let(nil, ::T.untyped)
  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
end

class Bundler::URI::HTTP
end

class Bundler::URI::HTTPS
  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
end

class Bundler::URI::HTTPS
end

class Bundler::URI::InvalidComponentError
end

class Bundler::URI::InvalidComponentError
end

class Bundler::URI::InvalidURIError
end

class Bundler::URI::InvalidURIError
end

class Bundler::URI::LDAP
  def attributes(); end

  def attributes=(val); end

  def dn(); end

  def dn=(val); end

  def extensions(); end

  def extensions=(val); end

  def filter(); end

  def filter=(val); end

  def initialize(*arg); end

  def scope(); end

  def scope=(val); end

  def set_attributes(val); end

  def set_dn(val); end

  def set_extensions(val); end

  def set_filter(val); end

  def set_scope(val); end
  COMPONENT = ::T.let(nil, ::T.untyped)
  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
  SCOPE = ::T.let(nil, ::T.untyped)
  SCOPE_BASE = ::T.let(nil, ::T.untyped)
  SCOPE_ONE = ::T.let(nil, ::T.untyped)
  SCOPE_SUB = ::T.let(nil, ::T.untyped)
end

class Bundler::URI::LDAP
end

class Bundler::URI::LDAPS
  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
end

class Bundler::URI::LDAPS
end

class Bundler::URI::MailTo
  def headers(); end

  def headers=(v); end

  def initialize(*arg); end

  def set_headers(v); end

  def set_to(v); end

  def to(); end

  def to=(v); end

  def to_mailtext(); end

  def to_rfc822text(); end
  COMPONENT = ::T.let(nil, ::T.untyped)
  DEFAULT_PORT = ::T.let(nil, ::T.untyped)
  EMAIL_REGEXP = ::T.let(nil, ::T.untyped)
  HEADER_REGEXP = ::T.let(nil, ::T.untyped)
end

class Bundler::URI::MailTo
end

Bundler::URI::Parser = Bundler::URI::RFC2396_Parser

Bundler::URI::REGEXP = Bundler::URI::RFC2396_REGEXP

class Bundler::URI::RFC2396_Parser
  include ::Bundler::URI::RFC2396_REGEXP
  def escape(str, unsafe=T.unsafe(nil)); end

  def extract(str, schemes=T.unsafe(nil)); end

  def initialize(opts=T.unsafe(nil)); end

  def join(*uris); end

  def make_regexp(schemes=T.unsafe(nil)); end

  def parse(uri); end

  def pattern(); end

  def regexp(); end

  def split(uri); end

  def unescape(str, escaped=T.unsafe(nil)); end
end

class Bundler::URI::RFC2396_Parser
end

module Bundler::URI::RFC2396_REGEXP
end

module Bundler::URI::RFC2396_REGEXP::PATTERN
  ABS_PATH = ::T.let(nil, ::T.untyped)
  ABS_URI = ::T.let(nil, ::T.untyped)
  ALNUM = ::T.let(nil, ::T.untyped)
  ALPHA = ::T.let(nil, ::T.untyped)
  DOMLABEL = ::T.let(nil, ::T.untyped)
  ESCAPED = ::T.let(nil, ::T.untyped)
  FRAGMENT = ::T.let(nil, ::T.untyped)
  HEX = ::T.let(nil, ::T.untyped)
  HIER_PART = ::T.let(nil, ::T.untyped)
  HOST = ::T.let(nil, ::T.untyped)
  HOSTNAME = ::T.let(nil, ::T.untyped)
  HOSTPORT = ::T.let(nil, ::T.untyped)
  IPV4ADDR = ::T.let(nil, ::T.untyped)
  IPV6ADDR = ::T.let(nil, ::T.untyped)
  IPV6REF = ::T.let(nil, ::T.untyped)
  NET_PATH = ::T.let(nil, ::T.untyped)
  OPAQUE_PART = ::T.let(nil, ::T.untyped)
  PATH_SEGMENTS = ::T.let(nil, ::T.untyped)
  PORT = ::T.let(nil, ::T.untyped)
  QUERY = ::T.let(nil, ::T.untyped)
  REG_NAME = ::T.let(nil, ::T.untyped)
  REL_PATH = ::T.let(nil, ::T.untyped)
  REL_SEGMENT = ::T.let(nil, ::T.untyped)
  REL_URI = ::T.let(nil, ::T.untyped)
  RESERVED = ::T.let(nil, ::T.untyped)
  SCHEME = ::T.let(nil, ::T.untyped)
  TOPLABEL = ::T.let(nil, ::T.untyped)
  UNRESERVED = ::T.let(nil, ::T.untyped)
  URIC = ::T.let(nil, ::T.untyped)
  URIC_NO_SLASH = ::T.let(nil, ::T.untyped)
  URI_REF = ::T.let(nil, ::T.untyped)
  USERINFO = ::T.let(nil, ::T.untyped)
  X_ABS_URI = ::T.let(nil, ::T.untyped)
  X_REL_URI = ::T.let(nil, ::T.untyped)
end

module Bundler::URI::RFC2396_REGEXP::PATTERN
end

module Bundler::URI::RFC2396_REGEXP
end

class Bundler::URI::RFC3986_Parser
  def join(*uris); end

  def parse(uri); end

  def regexp(); end

  def split(uri); end
  RFC3986_URI = ::T.let(nil, ::T.untyped)
  RFC3986_relative_ref = ::T.let(nil, ::T.untyped)
end

class Bundler::URI::RFC3986_Parser
end

module Bundler::URI::Util
end

module Bundler::URI::Util
  def self.make_components_hash(klass, array_hash); end
end

module Bundler::URI
  extend ::Bundler::URI::Escape
  def self.decode_www_form(str, enc=T.unsafe(nil), separator: T.unsafe(nil), use__charset_: T.unsafe(nil), isindex: T.unsafe(nil)); end

  def self.decode_www_form_component(str, enc=T.unsafe(nil)); end

  def self.encode_www_form(enum, enc=T.unsafe(nil)); end

  def self.encode_www_form_component(str, enc=T.unsafe(nil)); end

  def self.extract(str, schemes=T.unsafe(nil), &block); end

  def self.get_encoding(label); end

  def self.join(*str); end

  def self.parse(uri); end

  def self.regexp(schemes=T.unsafe(nil)); end

  def self.scheme_list(); end

  def self.split(uri); end
end

module Bundler::VersionRanges
end

class Bundler::VersionRanges::NEq
  def version(); end

  def version=(_); end
end

class Bundler::VersionRanges::NEq
  def self.[](*_); end

  def self.members(); end
end

class Bundler::VersionRanges::ReqR
  def cover?(v); end

  def empty?(); end

  def left(); end

  def left=(_); end

  def right(); end

  def right=(_); end

  def single?(); end
  INFINITY = ::T.let(nil, ::T.untyped)
  UNIVERSAL = ::T.let(nil, ::T.untyped)
  ZERO = ::T.let(nil, ::T.untyped)
end

class Bundler::VersionRanges::ReqR::Endpoint
  def inclusive(); end

  def inclusive=(_); end

  def version(); end

  def version=(_); end
end

class Bundler::VersionRanges::ReqR::Endpoint
  def self.[](*_); end

  def self.members(); end
end

class Bundler::VersionRanges::ReqR
  def self.[](*_); end

  def self.members(); end
end

module Bundler::VersionRanges
  def self.empty?(ranges, neqs); end

  def self.for(requirement); end

  def self.for_many(requirements); end
end

module Bundler
  def self.original_exec(*args); end

  def self.original_system(*args); end

  def self.unbundled_env(); end

  def self.unbundled_exec(*args); end

  def self.unbundled_system(*args); end

  def self.with_unbundled_env(); end
end

module Byebug
  PORT = ::T.let(nil, ::T.untyped)
end

class Byebug::AutoirbSetting
  DEFAULT = ::T.let(nil, ::T.untyped)
end

class Byebug::AutolistSetting
  DEFAULT = ::T.let(nil, ::T.untyped)
end

class Byebug::AutoprySetting
  DEFAULT = ::T.let(nil, ::T.untyped)
end

class Byebug::AutosaveSetting
  DEFAULT = ::T.let(nil, ::T.untyped)
end

class Byebug::CallstyleSetting
  DEFAULT = ::T.let(nil, ::T.untyped)
end

class Byebug::Command
  extend ::Byebug::Helpers::StringHelper
end

class Byebug::Context
  extend ::Byebug::Helpers::PathHelper
end

class Byebug::FullpathSetting
  DEFAULT = ::T.let(nil, ::T.untyped)
end

class Byebug::HistfileSetting
  DEFAULT = ::T.let(nil, ::T.untyped)
end

class Byebug::HistsizeSetting
  DEFAULT = ::T.let(nil, ::T.untyped)
end

class Byebug::ListsizeSetting
  DEFAULT = ::T.let(nil, ::T.untyped)
end

class Byebug::LocalInterface
  EOF_ALIAS = ::T.let(nil, ::T.untyped)
end

class Byebug::Printers::Base
  SEPARATOR = ::T.let(nil, ::T.untyped)
end

class Byebug::SavefileSetting
  DEFAULT = ::T.let(nil, ::T.untyped)
end

class Byebug::Setting
  DEFAULT = ::T.let(nil, ::T.untyped)
end

class Byebug::ThreadsTable
end

class Byebug::ThreadsTable
end

class Byebug::WidthSetting
  DEFAULT = ::T.let(nil, ::T.untyped)
end

module CGI::HtmlExtension
  def a(href=T.unsafe(nil)); end

  def base(href=T.unsafe(nil)); end

  def blockquote(cite=T.unsafe(nil)); end

  def caption(align=T.unsafe(nil)); end

  def checkbox(name=T.unsafe(nil), value=T.unsafe(nil), checked=T.unsafe(nil)); end

  def checkbox_group(name=T.unsafe(nil), *values); end

  def file_field(name=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end

  def form(method=T.unsafe(nil), action=T.unsafe(nil), enctype=T.unsafe(nil)); end

  def hidden(name=T.unsafe(nil), value=T.unsafe(nil)); end

  def html(attributes=T.unsafe(nil)); end

  def image_button(src=T.unsafe(nil), name=T.unsafe(nil), alt=T.unsafe(nil)); end

  def img(src=T.unsafe(nil), alt=T.unsafe(nil), width=T.unsafe(nil), height=T.unsafe(nil)); end

  def multipart_form(action=T.unsafe(nil), enctype=T.unsafe(nil)); end

  def password_field(name=T.unsafe(nil), value=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end

  def popup_menu(name=T.unsafe(nil), *values); end

  def radio_button(name=T.unsafe(nil), value=T.unsafe(nil), checked=T.unsafe(nil)); end

  def radio_group(name=T.unsafe(nil), *values); end

  def reset(value=T.unsafe(nil), name=T.unsafe(nil)); end

  def scrolling_list(name=T.unsafe(nil), *values); end

  def submit(value=T.unsafe(nil), name=T.unsafe(nil)); end

  def text_field(name=T.unsafe(nil), value=T.unsafe(nil), size=T.unsafe(nil), maxlength=T.unsafe(nil)); end

  def textarea(name=T.unsafe(nil), cols=T.unsafe(nil), rows=T.unsafe(nil)); end
end

module CGI::HtmlExtension
end

class Class
  def json_creatable?(); end
end

module CodeRay
  CODERAY_PATH = ::T.let(nil, ::T.untyped)
  TokenKinds = ::T.let(nil, ::T.untyped)
  VERSION = ::T.let(nil, ::T.untyped)
end

class CodeRay::Encoders::Encoder
  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
end

CodeRay::Encoders::Encoder::PLUGIN_HOST = CodeRay::Encoders

class CodeRay::Encoders::HTML
  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
  FILE_EXTENSION = ::T.let(nil, ::T.untyped)
  HTML_ESCAPE = ::T.let(nil, ::T.untyped)
  HTML_ESCAPE_PATTERN = ::T.let(nil, ::T.untyped)
  TOKEN_KIND_TO_INFO = ::T.let(nil, ::T.untyped)
  TRANSPARENT_TOKEN_KINDS = ::T.let(nil, ::T.untyped)
end

class CodeRay::Encoders::HTML::CSS
  CSS_CLASS_PATTERN = ::T.let(nil, ::T.untyped)
end

module CodeRay::Encoders::HTML::Output
  DIV = ::T.let(nil, ::T.untyped)
  PAGE = ::T.let(nil, ::T.untyped)
  SPAN = ::T.let(nil, ::T.untyped)
  TABLE = ::T.let(nil, ::T.untyped)
end

class CodeRay::Encoders::Terminal
  TOKEN_COLORS = ::T.let(nil, ::T.untyped)
end

module CodeRay::FileType
  TypeFromExt = ::T.let(nil, ::T.untyped)
  TypeFromName = ::T.let(nil, ::T.untyped)
  TypeFromShebang = ::T.let(nil, ::T.untyped)
end

module CodeRay::PluginHost
  PLUGIN_HOSTS = ::T.let(nil, ::T.untyped)
  PLUGIN_HOSTS_BY_ID = ::T.let(nil, ::T.untyped)
end

class CodeRay::Scanners::Java
  CONSTANTS = ::T.let(nil, ::T.untyped)
  DIRECTIVES = ::T.let(nil, ::T.untyped)
  ESCAPE = ::T.let(nil, ::T.untyped)
  IDENT = ::T.let(nil, ::T.untyped)
  IDENT_KIND = ::T.let(nil, ::T.untyped)
  KEYWORDS = ::T.let(nil, ::T.untyped)
  MAGIC_VARIABLES = ::T.let(nil, ::T.untyped)
  RESERVED = ::T.let(nil, ::T.untyped)
  STRING_CONTENT_PATTERN = ::T.let(nil, ::T.untyped)
  TYPES = ::T.let(nil, ::T.untyped)
  UNICODE_ESCAPE = ::T.let(nil, ::T.untyped)
end

module CodeRay::Scanners::Java::BuiltinTypes
  List = ::T.let(nil, ::T.untyped)
end

module CodeRay::Scanners::Ruby::Patterns
  BINARY = ::T.let(nil, ::T.untyped)
  CHARACTER = ::T.let(nil, ::T.untyped)
  CLASS_VARIABLE = ::T.let(nil, ::T.untyped)
  CONTROL_META_ESCAPE = ::T.let(nil, ::T.untyped)
  DATA = ::T.let(nil, ::T.untyped)
  DECIMAL = ::T.let(nil, ::T.untyped)
  ESCAPE = ::T.let(nil, ::T.untyped)
  EXPONENT = ::T.let(nil, ::T.untyped)
  FANCY_STRING_INTERPRETED = ::T.let(nil, ::T.untyped)
  FANCY_STRING_KIND = ::T.let(nil, ::T.untyped)
  FANCY_STRING_START = ::T.let(nil, ::T.untyped)
  FLOAT_OR_INT = ::T.let(nil, ::T.untyped)
  FLOAT_SUFFIX = ::T.let(nil, ::T.untyped)
  GLOBAL_VARIABLE = ::T.let(nil, ::T.untyped)
  HEREDOC_OPEN = ::T.let(nil, ::T.untyped)
  HEXADECIMAL = ::T.let(nil, ::T.untyped)
  IDENT = ::T.let(nil, ::T.untyped)
  IDENT_KIND = ::T.let(nil, ::T.untyped)
  INSTANCE_VARIABLE = ::T.let(nil, ::T.untyped)
  KEYWORDS = ::T.let(nil, ::T.untyped)
  KEYWORDS_EXPECTING_VALUE = ::T.let(nil, ::T.untyped)
  KEYWORD_NEW_STATE = ::T.let(nil, ::T.untyped)
  METHOD_AFTER_DOT = ::T.let(nil, ::T.untyped)
  METHOD_NAME = ::T.let(nil, ::T.untyped)
  METHOD_NAME_EX = ::T.let(nil, ::T.untyped)
  METHOD_NAME_OPERATOR = ::T.let(nil, ::T.untyped)
  METHOD_NAME_OR_SYMBOL = ::T.let(nil, ::T.untyped)
  METHOD_SUFFIX = ::T.let(nil, ::T.untyped)
  NUMERIC = ::T.let(nil, ::T.untyped)
  OBJECT_VARIABLE = ::T.let(nil, ::T.untyped)
  OCTAL = ::T.let(nil, ::T.untyped)
  PREDEFINED_CONSTANTS = ::T.let(nil, ::T.untyped)
  PREFIX_VARIABLE = ::T.let(nil, ::T.untyped)
  QUOTE_TO_TYPE = ::T.let(nil, ::T.untyped)
  REGEXP_MODIFIERS = ::T.let(nil, ::T.untyped)
  RUBYDOC = ::T.let(nil, ::T.untyped)
  RUBYDOC_OR_DATA = ::T.let(nil, ::T.untyped)
  SIMPLE_ESCAPE = ::T.let(nil, ::T.untyped)
  SYMBOL = ::T.let(nil, ::T.untyped)
  VALUE_FOLLOWS = ::T.let(nil, ::T.untyped)
  VARIABLE = ::T.let(nil, ::T.untyped)
end

class CodeRay::Scanners::Ruby::StringState
  CLOSING_PAREN = ::T.let(nil, ::T.untyped)
  STRING_PATTERN = ::T.let(nil, ::T.untyped)
end

class CodeRay::Scanners::Scanner
  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
  KINDS_NOT_LOC = ::T.let(nil, ::T.untyped)
  SCANNER_STATE_INFO = ::T.let(nil, ::T.untyped)
  SCAN_ERROR_MESSAGE = ::T.let(nil, ::T.untyped)
end

CodeRay::Scanners::Scanner::PLUGIN_HOST = CodeRay::Scanners

class CodeRay::Styles::Style
  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
end

CodeRay::Styles::Style::PLUGIN_HOST = CodeRay::Styles

module Concurrent
  NULL = ::T.let(nil, ::T.untyped)
  NULL_LOGGER = ::T.let(nil, ::T.untyped)
  VERSION = ::T.let(nil, ::T.untyped)
end

class Concurrent::AbstractExecutorService
  FALLBACK_POLICIES = ::T.let(nil, ::T.untyped)
end

Concurrent::Collection::MapImplementation = Concurrent::Collection::MriMapBackend

class Concurrent::ConcurrentUpdateError
  CONC_UP_ERR_BACKTRACE = ::T.let(nil, ::T.untyped)
end

class Concurrent::LockFreeStack
  EMPTY = ::T.let(nil, ::T.untyped)
end

class Concurrent::MVar
  EMPTY = ::T.let(nil, ::T.untyped)
  TIMEOUT = ::T.let(nil, ::T.untyped)
end

class Concurrent::Maybe
  NONE = ::T.let(nil, ::T.untyped)
end

module Concurrent::Promises::InternalStates
  PENDING = ::T.let(nil, ::T.untyped)
  RESERVED = ::T.let(nil, ::T.untyped)
  RESOLVED = ::T.let(nil, ::T.untyped)
end

class Concurrent::ReadWriteLock
  MAX_READERS = ::T.let(nil, ::T.untyped)
  MAX_WRITERS = ::T.let(nil, ::T.untyped)
  RUNNING_WRITER = ::T.let(nil, ::T.untyped)
  WAITING_WRITER = ::T.let(nil, ::T.untyped)
end

class Concurrent::ReentrantReadWriteLock
  MAX_READERS = ::T.let(nil, ::T.untyped)
  MAX_WRITERS = ::T.let(nil, ::T.untyped)
  READER_BITS = ::T.let(nil, ::T.untyped)
  READ_LOCK_MASK = ::T.let(nil, ::T.untyped)
  RUNNING_WRITER = ::T.let(nil, ::T.untyped)
  WAITING_WRITER = ::T.let(nil, ::T.untyped)
  WRITER_BITS = ::T.let(nil, ::T.untyped)
  WRITE_LOCK_HELD = ::T.let(nil, ::T.untyped)
  WRITE_LOCK_MASK = ::T.let(nil, ::T.untyped)
end

class Concurrent::RubyThreadPoolExecutor
  DEFAULT_MAX_POOL_SIZE = ::T.let(nil, ::T.untyped)
  DEFAULT_MAX_QUEUE_SIZE = ::T.let(nil, ::T.untyped)
  DEFAULT_MIN_POOL_SIZE = ::T.let(nil, ::T.untyped)
  DEFAULT_THREAD_IDLETIMEOUT = ::T.let(nil, ::T.untyped)
end

class Concurrent::SerializedExecutionDelegator
  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
end

Concurrent::Synchronization::Volatile = Concurrent::Synchronization::MriAttrVolatile

class Concurrent::SynchronizedDelegator
  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
end

module Concurrent::ThreadSafe::Util
  CPU_COUNT = ::T.let(nil, ::T.untyped)
  FIXNUM_BIT_SIZE = ::T.let(nil, ::T.untyped)
  MAX_INT = ::T.let(nil, ::T.untyped)
end

class Concurrent::TimerTask
  EXECUTION_INTERVAL = ::T.let(nil, ::T.untyped)
  TIMEOUT_INTERVAL = ::T.let(nil, ::T.untyped)
end

class Concurrent::Transaction
  ABORTED = ::T.let(nil, ::T.untyped)
end

module Concurrent::Utility::NativeInteger
  MAX_VALUE = ::T.let(nil, ::T.untyped)
  MIN_VALUE = ::T.let(nil, ::T.untyped)
end

class DRb::DRbArray
  def _dump(lv); end
end

class DRb::DRbArray
  def self._load(s); end
end

class DRb::DRbConn
  def alive?(); end

  def close(); end

  def initialize(remote_uri); end

  def send_message(ref, msg_id, arg, block); end

  def uri(); end
end

class DRb::DRbConn
  def self.open(remote_uri); end
end

class DRb::DRbMessage
  def dump(obj, error=T.unsafe(nil)); end

  def initialize(config); end

  def load(soc); end

  def recv_reply(stream); end

  def recv_request(stream); end

  def send_reply(stream, succ, result); end

  def send_request(stream, ref, msg_id, arg, b); end
end

class DRb::DRbObject
  def ==(other); end

  def eql?(other); end

  def initialize(obj, uri=T.unsafe(nil)); end
end

class DRb::DRbObject
  def self.prepare_backtrace(uri, result); end

  def self.with_friend(uri); end
end

module DRb::DRbProtocol
  def self.auto_load(uri); end
end

class DRb::DRbRemoteError
  def initialize(error); end
end

class DRb::DRbServer
  def initialize(uri=T.unsafe(nil), front=T.unsafe(nil), config_or_acl=T.unsafe(nil)); end

  def safe_level(); end
end

class DRb::DRbServer::InvokeMethod
  include ::DRb::DRbServer::InvokeMethod18Mixin
  def initialize(drb_server, client); end

  def perform(); end
end

class DRb::DRbServer::InvokeMethod
end

module DRb::DRbServer::InvokeMethod18Mixin
  def block_yield(x); end

  def perform_with_block(); end
end

module DRb::DRbServer::InvokeMethod18Mixin
end

class DRb::DRbServer
  def self.default_safe_level(level); end

  def self.make_config(hash=T.unsafe(nil)); end
end

class DRb::DRbTCPSocket
  def accept(); end

  def alive?(); end

  def close(); end

  def initialize(uri, soc, config=T.unsafe(nil)); end

  def peeraddr(); end

  def recv_reply(); end

  def recv_request(); end

  def send_reply(succ, result); end

  def send_request(ref, msg_id, arg, b); end

  def set_sockopt(soc); end

  def shutdown(); end

  def stream(); end

  def uri(); end
end

class DRb::DRbTCPSocket
  def self.getservername(); end

  def self.open(uri, config); end

  def self.open_server(uri, config); end

  def self.open_server_inaddr_any(host, port); end

  def self.parse_uri(uri); end

  def self.uri_option(uri, config); end
end

class DRb::DRbUNIXSocket
  def initialize(uri, soc, config=T.unsafe(nil), server_mode=T.unsafe(nil)); end
  Max_try = ::T.let(nil, ::T.untyped)
end

class DRb::DRbUNIXSocket
  def self.temp_server(); end
end

class DRb::DRbURIOption
  def ==(other); end

  def eql?(other); end

  def initialize(option); end

  def option(); end
end

class DRb::DRbURIOption
end

module DRb::DRbUndumped
  def _dump(dummy); end
end

class DRb::DRbUnknown
  def _dump(lv); end
end

class DRb::DRbUnknown
  def self._load(s); end
end

class DRb::DRbUnknownError
  def _dump(lv); end

  def initialize(unknown); end
end

class DRb::DRbUnknownError
  def self._load(s); end
end

module DRb
  def self.mutex(); end
end

DRbIdConv = DRb::DRbIdConv

DRbObject = DRb::DRbObject

DRbUndumped = DRb::DRbUndumped

class Date
  def default_inspect(); end

  def readable_inspect(); end

  def to_default_s(); end

  def to_formatted_s(format=T.unsafe(nil)); end

  DATE_FORMATS = ::T.let(nil, ::T.untyped)
end

class Date::Infinity
  def initialize(d=T.unsafe(nil)); end
end

module DateAndTime::Calculations
  DAYS_INTO_WEEK = ::T.let(nil, ::T.untyped)
  WEEKEND_DAYS = ::T.let(nil, ::T.untyped)
end

class DateTime
  def formatted_offset(colon=T.unsafe(nil), alternate_utc_string=T.unsafe(nil)); end

  def nsec(); end

  def to_f(); end

  def to_i(); end

  def usec(); end
end

class DateTime
  def self.civil_from_format(utc_or_local, year, month=T.unsafe(nil), day=T.unsafe(nil), hour=T.unsafe(nil), min=T.unsafe(nil), sec=T.unsafe(nil)); end
end

class Delegator
  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
end

class DidYouMean::ClassNameChecker
  def class_name(); end

  def class_names(); end

  def corrections(); end

  def initialize(exception); end

  def scopes(); end
end

module DidYouMean::Correctable
  def corrections(); end

  def original_message(); end

  def spell_checker(); end

  def to_s(); end
end

module DidYouMean::Jaro
  def self.distance(str1, str2); end
end

module DidYouMean::JaroWinkler
  def self.distance(str1, str2); end
end

class DidYouMean::KeyErrorChecker
  def corrections(); end

  def initialize(key_error); end
end

class DidYouMean::KeyErrorChecker
end

module DidYouMean::Levenshtein
  def self.distance(str1, str2); end

  def self.min3(a, b, c); end
end

class DidYouMean::MethodNameChecker
  def corrections(); end

  def initialize(exception); end

  def method_name(); end

  def method_names(); end

  def receiver(); end
  RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped)
end

class DidYouMean::NullChecker
  def corrections(); end

  def initialize(*_); end
end

class DidYouMean::PlainFormatter
  def message_for(corrections); end
end

class DidYouMean::PlainFormatter
end

class DidYouMean::VariableNameChecker
  def corrections(); end

  def cvar_names(); end

  def initialize(exception); end

  def ivar_names(); end

  def lvar_names(); end

  def method_names(); end

  def name(); end
  RB_RESERVED_WORDS = ::T.let(nil, ::T.untyped)
end

module DidYouMean
  def self.formatter(); end

  def self.formatter=(formatter); end
end

class Dir
  def children(); end

  def each_child(); end
end

class Dir
  def self.exists?(_); end

end

module Docile
  VERSION = ::T.let(nil, ::T.untyped)
end

class Docile::FallbackContextProxy
  NON_FALLBACK_METHODS = ::T.let(nil, ::T.untyped)
  NON_PROXIED_INSTANCE_VARIABLES = ::T.let(nil, ::T.untyped)
  NON_PROXIED_METHODS = ::T.let(nil, ::T.untyped)
end

module Dry::Core::Constants
  EMPTY_ARRAY = ::T.let(nil, ::T.untyped)
  EMPTY_HASH = ::T.let(nil, ::T.untyped)
  EMPTY_OPTS = ::T.let(nil, ::T.untyped)
  EMPTY_SET = ::T.let(nil, ::T.untyped)
  EMPTY_STRING = ::T.let(nil, ::T.untyped)
  Self = ::T.let(nil, ::T.untyped)
  Undefined = ::T.let(nil, ::T.untyped)
end

module Dry::Core::Deprecations
  STACK = ::T.let(nil, ::T.untyped)
end

module Dry::Monads
  EMPTY_ARRAY = ::T.let(nil, ::T.untyped)
  EMPTY_HASH = ::T.let(nil, ::T.untyped)
  EMPTY_OPTS = ::T.let(nil, ::T.untyped)
  EMPTY_SET = ::T.let(nil, ::T.untyped)
  EMPTY_STRING = ::T.let(nil, ::T.untyped)
  Self = ::T.let(nil, ::T.untyped)
  Traverse = ::T.let(nil, ::T.untyped)
  Undefined = ::T.let(nil, ::T.untyped)
  Unit = ::T.let(nil, ::T.untyped)
end

module Dry::Monads::Do
  DELEGATE = ::T.let(nil, ::T.untyped)
end

class Dry::Monads::ExampleClass
  def my_maybe(*args, &blk); end

  def my_result(*args, &blk); end
end

class Dry::Monads::ExampleClass
  extend ::T::Sig
  extend ::T::Private::Methods::MethodHooks
  extend ::T::Private::Methods::SingletonMethodHooks
end

Dry::Monads::Failure = Dry::Monads::Result::Failure

Dry::Monads::Invalid = Dry::Monads::Validated::Invalid

module Dry::Monads::Lazy::Mixin
  Unit = ::T.let(nil, ::T.untyped)
end

Dry::Monads::Lazy::Mixin::Lazy = Dry::Monads::Lazy

class Dry::Monads::List
  EMPTY = ::T.let(nil, ::T.untyped)
  Maybe = ::T.let(nil, ::T.untyped)
  Result = ::T.let(nil, ::T.untyped)
  Task = ::T.let(nil, ::T.untyped)
  Try = ::T.let(nil, ::T.untyped)
  Validated = ::T.let(nil, ::T.untyped)
end

Dry::Monads::List::Mixin::L = Dry::Monads::List

Dry::Monads::Maybe::Mixin::Maybe = Dry::Monads::Maybe

Dry::Monads::Maybe::Mixin::None = Dry::Monads::Maybe::None

Dry::Monads::Maybe::Mixin::Some = Dry::Monads::Maybe::Some

Dry::Monads::None = Dry::Monads::Maybe::None

Dry::Monads::Result::Mixin::Failure = Dry::Monads::Result::Failure

Dry::Monads::Result::Mixin::Success = Dry::Monads::Result::Success

Dry::Monads::Some = Dry::Monads::Maybe::Some

Dry::Monads::Success = Dry::Monads::Result::Success

module Dry::Monads::Task::Mixin
  Unit = ::T.let(nil, ::T.untyped)
end

Dry::Monads::Task::Mixin::Task = Dry::Monads::Task

class Dry::Monads::Try
  DEFAULT_EXCEPTIONS = ::T.let(nil, ::T.untyped)
end

Dry::Monads::Try::Mixin::Try = Dry::Monads::Try

Dry::Monads::Valid = Dry::Monads::Validated::Valid

Dry::Monads::Validated::Mixin::Invalid = Dry::Monads::Validated::Invalid

Dry::Monads::Validated::Mixin::Valid = Dry::Monads::Validated::Valid

module Dry::Monads
  extend ::Dry::Monads::Lazy::Mixin::Constructors
  extend ::Dry::Monads::Try::Mixin::Constructors
  extend ::Dry::Monads::Task::Mixin::Constructors
end

EM = EventMachine

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

module ERB::Util
  HTML_ESCAPE = ::T.let(nil, ::T.untyped)
  HTML_ESCAPE_ONCE_REGEXP = ::T.let(nil, ::T.untyped)
  JSON_ESCAPE = ::T.let(nil, ::T.untyped)
  JSON_ESCAPE_REGEXP = ::T.let(nil, ::T.untyped)
end

module ERB::Util
  def self.html_escape_once(s); end

  def self.json_escape(s); end

  def self.unwrapped_html_escape(s); end
end

class Encoding
  def _dump(*_); end
end

class Encoding::Converter
  def initialize(*_); end
end

class Encoding
  def self._load(_); end
end

module Enumerable
  include ::ActiveSupport::ToJsonWithActiveSupportEncoder
  def as_json(options=T.unsafe(nil)); end

  def chain(*_); end

  def sum(*_); end
end

class Enumerator
  def +(_); end

  def each_with_index(); end
end

class Enumerator::ArithmeticSequence
  def begin(); end

  def each(&blk); end

  def end(); end

  def exclude_end?(); end

  def last(*_); end

  def step(); end
end

class Enumerator::ArithmeticSequence
end

class Enumerator::Chain
end

class Enumerator::Chain
end

class Enumerator::Generator
  def each(*_, &blk); end

  def initialize(*_); end
end

class Errno::EAUTH
  Errno = ::T.let(nil, ::T.untyped)
end

class Errno::EAUTH
end

class Errno::EBADARCH
  Errno = ::T.let(nil, ::T.untyped)
end

class Errno::EBADARCH
end

class Errno::EBADEXEC
  Errno = ::T.let(nil, ::T.untyped)
end

class Errno::EBADEXEC
end

class Errno::EBADMACHO
  Errno = ::T.let(nil, ::T.untyped)
end

class Errno::EBADMACHO
end

class Errno::EBADRPC
  Errno = ::T.let(nil, ::T.untyped)
end

class Errno::EBADRPC
end

Errno::ECAPMODE = Errno::NOERROR

Errno::EDEADLOCK = Errno::NOERROR

class Errno::EDEVERR
  Errno = ::T.let(nil, ::T.untyped)
end

class Errno::EDEVERR
end

Errno::EDOOFUS = Errno::NOERROR

class Errno::EFTYPE
  Errno = ::T.let(nil, ::T.untyped)
end

class Errno::EFTYPE
end

Errno::EIPSEC = Errno::NOERROR

class Errno::ELAST
  Errno = ::T.let(nil, ::T.untyped)
end

class Errno::ELAST
end

class Errno::ENEEDAUTH
  Errno = ::T.let(nil, ::T.untyped)
end

class Errno::ENEEDAUTH
end

class Errno::ENOATTR
  Errno = ::T.let(nil, ::T.untyped)
end

class Errno::ENOATTR
end

class Errno::ENOPOLICY
  Errno = ::T.let(nil, ::T.untyped)
end

class Errno::ENOPOLICY
end

Errno::ENOTCAPABLE = Errno::NOERROR

class Errno::ENOTSUP
  Errno = ::T.let(nil, ::T.untyped)
end

class Errno::ENOTSUP
end

class Errno::EPROCLIM
  Errno = ::T.let(nil, ::T.untyped)
end

class Errno::EPROCLIM
end

class Errno::EPROCUNAVAIL
  Errno = ::T.let(nil, ::T.untyped)
end

class Errno::EPROCUNAVAIL
end

class Errno::EPROGMISMATCH
  Errno = ::T.let(nil, ::T.untyped)
end

class Errno::EPROGMISMATCH
end

class Errno::EPROGUNAVAIL
  Errno = ::T.let(nil, ::T.untyped)
end

class Errno::EPROGUNAVAIL
end

class Errno::EPWROFF
  Errno = ::T.let(nil, ::T.untyped)
end

class Errno::EPWROFF
end

Errno::EQFULL = Errno::ELAST

class Errno::ERPCMISMATCH
  Errno = ::T.let(nil, ::T.untyped)
end

class Errno::ERPCMISMATCH
end

class Errno::ESHLIBVERS
  Errno = ::T.let(nil, ::T.untyped)
end

class Errno::ESHLIBVERS
end

class Etc::Group
  def gid(); end

  def gid=(_); end

  def mem(); end

  def mem=(_); end

  def name(); end

  def name=(_); end

  def passwd(); end

  def passwd=(_); end
end

class Etc::Group
  extend ::Enumerable
  def self.[](*_); end

  def self.each(&blk); end

  def self.members(); end
end

class Etc::Passwd
  def change(); end

  def change=(_); end

  def dir=(_); end

  def expire(); end

  def expire=(_); end

  def gecos(); end

  def gecos=(_); end

  def gid=(_); end

  def name=(_); end

  def passwd=(_); end

  def shell=(_); end

  def uclass(); end

  def uclass=(_); end

  def uid=(_); end
end

class Etc::Passwd
  extend ::Enumerable
  def self.[](*_); end

  def self.each(&blk); end

  def self.members(); end
end

module EventMachine
  ConnectionAccepted = ::T.let(nil, ::T.untyped)
  ConnectionCompleted = ::T.let(nil, ::T.untyped)
  ConnectionData = ::T.let(nil, ::T.untyped)
  ConnectionNotifyReadable = ::T.let(nil, ::T.untyped)
  ConnectionNotifyWritable = ::T.let(nil, ::T.untyped)
  ConnectionUnbound = ::T.let(nil, ::T.untyped)
  EM_PROTO_SSLv2 = ::T.let(nil, ::T.untyped)
  EM_PROTO_SSLv3 = ::T.let(nil, ::T.untyped)
  EM_PROTO_TLSv1 = ::T.let(nil, ::T.untyped)
  EM_PROTO_TLSv1_1 = ::T.let(nil, ::T.untyped)
  EM_PROTO_TLSv1_2 = ::T.let(nil, ::T.untyped)
  ERRNOS = ::T.let(nil, ::T.untyped)
  LoopbreakSignalled = ::T.let(nil, ::T.untyped)
  SslHandshakeCompleted = ::T.let(nil, ::T.untyped)
  SslVerify = ::T.let(nil, ::T.untyped)
  TimerFired = ::T.let(nil, ::T.untyped)
  VERSION = ::T.let(nil, ::T.untyped)
end

class EventMachine::ConnectionError
end

class EventMachine::ConnectionError
end

class EventMachine::ConnectionNotBound
end

class EventMachine::ConnectionNotBound
end

class EventMachine::DNS::Resolver
  HOSTS_FILE = ::T.let(nil, ::T.untyped)
end

EventMachine::Deferrable::Pool = EventMachine::Pool

class EventMachine::FileStreamer
  BackpressureLevel = ::T.let(nil, ::T.untyped)
  ChunkSize = ::T.let(nil, ::T.untyped)
  MappingThreshold = ::T.let(nil, ::T.untyped)
end

class EventMachine::FileWatch
  Cdeleted = ::T.let(nil, ::T.untyped)
  Cmodified = ::T.let(nil, ::T.untyped)
  Cmoved = ::T.let(nil, ::T.untyped)
end

class EventMachine::InvalidSignature
end

class EventMachine::InvalidSignature
end

class EventMachine::Iterator
  Stop = ::T.let(nil, ::T.untyped)
end

class EventMachine::NoHandlerForAcceptedConnection
end

class EventMachine::NoHandlerForAcceptedConnection
end

EventMachine::P = EventMachine::Protocols

class EventMachine::ProcessWatch
  Cexit = ::T.let(nil, ::T.untyped)
  Cfork = ::T.let(nil, ::T.untyped)
end

class EventMachine::Protocols::HeaderAndContentProtocol
  include ::EventMachine::Protocols::LineText2
  def headers_2_hash(hdrs); end

  def receive_binary_data(text); end

  def receive_line(line); end
  ContentLengthPattern = ::T.let(nil, ::T.untyped)
end

class EventMachine::Protocols::HeaderAndContentProtocol
  def self.headers_2_hash(hdrs); end
end

class EventMachine::Protocols::HttpClient
  include ::EventMachine::Deferrable
  def dispatch_response(); end

  def initialize(); end

  def send_request(args); end
  MaxPostContentLength = ::T.let(nil, ::T.untyped)
end

class EventMachine::Protocols::HttpClient
  def self.request(args=T.unsafe(nil)); end
end

class EventMachine::Protocols::HttpClient2
  include ::EventMachine::Protocols::LineText2
  def get(args); end

  def initialize(); end

  def pop_request(); end

  def post(args); end

  def receive_binary_data(text); end

  def request(args); end

  def set_default_host_header(host, port, ssl); end
end

class EventMachine::Protocols::HttpClient2::Request
  include ::EventMachine::Deferrable
  def content(); end

  def header_lines(); end

  def headers(); end

  def initialize(conn, args); end

  def internal_error(); end

  def receive_chunk_header(ln); end

  def receive_chunk_trailer(ln); end

  def receive_chunked_text(text); end

  def receive_header_line(ln); end

  def receive_line(ln); end

  def receive_sized_text(text); end

  def receive_text(text); end

  def send_request(); end

  def status(); end

  def version(); end
  ChunkedRE = ::T.let(nil, ::T.untyped)
  ClenRE = ::T.let(nil, ::T.untyped)
  ColonRE = ::T.let(nil, ::T.untyped)
  HttpResponseRE = ::T.let(nil, ::T.untyped)
end

class EventMachine::Protocols::HttpClient2::Request
end

class EventMachine::Protocols::HttpClient2
  def self.connect(*args); end
end

class EventMachine::Protocols::LineAndTextProtocol
  def set_binary_mode(size=T.unsafe(nil)); end
  MaxBinaryLength = ::T.let(nil, ::T.untyped)
end

class EventMachine::Protocols::LineAndTextProtocol
end

module EventMachine::Protocols::LineProtocol
  def receive_data(data); end

  def receive_line(line); end
end

module EventMachine::Protocols::LineProtocol
end

module EventMachine::Protocols::LineText2
  def receive_binary_data(data); end

  def receive_data(data); end

  def receive_end_of_binary_data(); end

  def receive_line(ln); end

  def set_binary_mode(size=T.unsafe(nil)); end

  def set_delimiter(delim); end

  def set_line_mode(data=T.unsafe(nil)); end

  def set_text_mode(size=T.unsafe(nil)); end

  def unbind(); end
  MaxBinaryLength = ::T.let(nil, ::T.untyped)
end

module EventMachine::Protocols::LineText2
end

module EventMachine::Protocols::Memcache
  include ::EventMachine::Deferrable
  def connection_completed(); end

  def del(key, expires=T.unsafe(nil), &cb); end

  def delete(key, expires=T.unsafe(nil), &cb); end

  def get(*keys); end

  def get_hash(*keys); end

  def initialize(host, port=T.unsafe(nil)); end

  def process_cmd(line); end

  def receive_data(data); end

  def set(key, val, exptime=T.unsafe(nil), &cb); end

  def unbind(); end
  Cdeleted = ::T.let(nil, ::T.untyped)
  Cdelimiter = ::T.let(nil, ::T.untyped)
  Cempty = ::T.let(nil, ::T.untyped)
  Cend = ::T.let(nil, ::T.untyped)
  Cerror = ::T.let(nil, ::T.untyped)
  Cstored = ::T.let(nil, ::T.untyped)
  Cunknown = ::T.let(nil, ::T.untyped)
end

class EventMachine::Protocols::Memcache::ParserError
end

class EventMachine::Protocols::Memcache::ParserError
end

module EventMachine::Protocols::Memcache
  def self.connect(host=T.unsafe(nil), port=T.unsafe(nil)); end
end

module EventMachine::Protocols::ObjectProtocol
  def receive_data(data); end

  def receive_object(obj); end

  def send_object(obj); end

  def serializer(); end
end

module EventMachine::Protocols::ObjectProtocol
end

module EventMachine::Protocols::SASLauth
  def post_init(); end

  def receive_data(data); end

  def validate(username, psw, sysname, realm); end
  MaxFieldSize = ::T.let(nil, ::T.untyped)
end

module EventMachine::Protocols::SASLauth
end

class EventMachine::Protocols::SmtpClient
  include ::EventMachine::Deferrable
  include ::EventMachine::Protocols::LineText2
  def args=(args); end

  def initialize(); end
end

class EventMachine::Protocols::SmtpClient
  def self.send(args=T.unsafe(nil)); end
end

class EventMachine::Protocols::SmtpServer
  include ::EventMachine::Protocols::LineText2
  def connection_ended(); end

  def get_server_domain(); end

  def get_server_greeting(); end

  def init_protocol_state(); end

  def parms=(parms=T.unsafe(nil)); end

  def process_auth(str); end

  def process_auth_line(line); end

  def process_data(); end

  def process_data_line(ln); end

  def process_ehlo(domain); end

  def process_expn(); end

  def process_helo(domain); end

  def process_help(); end

  def process_mail_from(sender); end

  def process_noop(); end

  def process_quit(); end

  def process_rcpt_to(rcpt); end

  def process_rset(); end

  def process_starttls(); end

  def process_unknown(); end

  def process_vrfy(); end

  def receive_data_chunk(data); end

  def receive_data_command(); end

  def receive_ehlo_domain(domain); end

  def receive_message(); end

  def receive_plain_auth(user, password); end

  def receive_recipient(rcpt); end

  def receive_reset(); end

  def receive_sender(sender); end

  def receive_transaction(); end

  def reset_protocol_state(); end

  def send_server_greeting(); end
  AuthRegex = ::T.let(nil, ::T.untyped)
  DataRegex = ::T.let(nil, ::T.untyped)
  EhloRegex = ::T.let(nil, ::T.untyped)
  ExpnRegex = ::T.let(nil, ::T.untyped)
  HeloRegex = ::T.let(nil, ::T.untyped)
  HelpRegex = ::T.let(nil, ::T.untyped)
  MailFromRegex = ::T.let(nil, ::T.untyped)
  NoopRegex = ::T.let(nil, ::T.untyped)
  QuitRegex = ::T.let(nil, ::T.untyped)
  RcptToRegex = ::T.let(nil, ::T.untyped)
  RsetRegex = ::T.let(nil, ::T.untyped)
  StarttlsRegex = ::T.let(nil, ::T.untyped)
  VrfyRegex = ::T.let(nil, ::T.untyped)
end

class EventMachine::Protocols::SmtpServer
  def self.parms=(parms=T.unsafe(nil)); end
end

class EventMachine::Protocols::Socks4
  def initialize(host, port); end

  def restore_methods(); end

  def setup_methods(); end

  def socks_post_init(); end

  def socks_receive_data(data); end
end

class EventMachine::Protocols::Socks4
end

module EventMachine::Protocols::Stomp
  include ::EventMachine::Protocols::LineText2
  def ack(msgid); end

  def connect(parms=T.unsafe(nil)); end

  def init_message_reader(); end

  def receive_binary_data(data); end

  def receive_line(line); end

  def receive_msg(msg); end

  def send(destination, body, parms=T.unsafe(nil)); end

  def send_frame(verb, headers=T.unsafe(nil), body=T.unsafe(nil)); end

  def subscribe(dest, ack=T.unsafe(nil)); end
end

class EventMachine::Protocols::Stomp::Message
  def body(); end

  def body=(body); end

  def command(); end

  def command=(command); end

  def consume_line(line); end

  def header(); end

  def header=(header); end

  def headers(); end
end

class EventMachine::Protocols::Stomp::Message
end

module EventMachine::Protocols::Stomp
end

class EventMachine::Protocols::TcpConnectTester
  include ::EventMachine::Deferrable
end

class EventMachine::Protocols::TcpConnectTester
  def self.test(host, port); end
end

class EventMachine::UnknownTimerFired
end

class EventMachine::UnknownTimerFired
end

class EventMachine::Unsupported
end

class EventMachine::Unsupported
end

class EventMachine::WebSocket::Connection
  BINARY = ::T.let(nil, ::T.untyped)
  ENCODING_SUPPORTED = ::T.let(nil, ::T.untyped)
  UTF8 = ::T.let(nil, ::T.untyped)
end

module EventMachine::WebSocket::Framing03
  DATA_FRAMES = ::T.let(nil, ::T.untyped)
  FRAME_TYPES = ::T.let(nil, ::T.untyped)
  FRAME_TYPES_INVERSE = ::T.let(nil, ::T.untyped)
end

module EventMachine::WebSocket::Framing05
  DATA_FRAMES = ::T.let(nil, ::T.untyped)
  FRAME_TYPES = ::T.let(nil, ::T.untyped)
  FRAME_TYPES_INVERSE = ::T.let(nil, ::T.untyped)
end

module EventMachine::WebSocket::Framing07
  DATA_FRAMES = ::T.let(nil, ::T.untyped)
  FRAME_TYPES = ::T.let(nil, ::T.untyped)
  FRAME_TYPES_INVERSE = ::T.let(nil, ::T.untyped)
end

class EventMachine::WebSocket::Handler76
  TERMINATE_STRING = ::T.let(nil, ::T.untyped)
end

module Exception2MessageMapper
  def bind(cl); end

end

Exception2MessageMapper::E2MM = Exception2MessageMapper

class Exception2MessageMapper::ErrNotRegisteredException
end

class Exception2MessageMapper::ErrNotRegisteredException
end

module Exception2MessageMapper
  def self.Fail(klass=T.unsafe(nil), err=T.unsafe(nil), *rest); end

  def self.Raise(klass=T.unsafe(nil), err=T.unsafe(nil), *rest); end

  def self.def_e2message(k, c, m); end

  def self.def_exception(k, n, m, s=T.unsafe(nil)); end

  def self.e2mm_message(klass, exp); end

  def self.extend_object(cl); end

  def self.message(klass, exp); end
end

class ExitCalledError
end

class ExitCalledError
end

module FFaker
  BASE_LIB_PATH = ::T.let(nil, ::T.untyped)
  HEX = ::T.let(nil, ::T.untyped)
  LETTERS = ::T.let(nil, ::T.untyped)
end

module FFaker::AWS
  def instance_tenancy(); end

  def instance_type(); end

  def offering_type(); end

  def product_description(); end
end

module FFaker::AWS
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AWS
end

module FFaker::Address
  def building_number(); end

  def city(); end

  def city_prefix(); end

  def city_suffix(); end

  def country(given_code=T.unsafe(nil)); end

  def country_code(given_country=T.unsafe(nil)); end

  def neighborhood(); end

  def secondary_address(); end

  def street_address(include_secondary=T.unsafe(nil)); end

  def street_name(); end

  def street_suffix(); end

  def time_zone(); end

  def uk_country(); end

  def uk_county(); end

  def uk_postcode(); end

  def us_state(); end

  def us_state_abbr(); end

  def zip_code(); end
  CITY_PREFIXES = ::T.let(nil, ::T.untyped)
  COMPASS_DIRECTIONS = ::T.let(nil, ::T.untyped)
  SEC_ADDR = ::T.let(nil, ::T.untyped)
end

module FFaker::Address
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Address
end

module FFaker::AddressAU
  include ::FFaker::Address
  def full_address(st_abbr=T.unsafe(nil)); end

  def postcode(st_abbr=T.unsafe(nil)); end

  def state(); end

  def state_abbr(); end

  def suburb(st_abbr=T.unsafe(nil), p_code=T.unsafe(nil)); end

  def time_zone(st_abbr=T.unsafe(nil)); end
  POSTCODE = ::T.let(nil, ::T.untyped)
  STATE = ::T.let(nil, ::T.untyped)
  STATE_ABBR = ::T.let(nil, ::T.untyped)
  SUBURB = ::T.let(nil, ::T.untyped)
  TIME_ZONE = ::T.let(nil, ::T.untyped)
end

module FFaker::AddressAU
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressAU
  extend ::FFaker::Address
end

module FFaker::AddressBR
  include ::FFaker::Address
  def city(); end

  def full_address(); end

  def state(); end

  def state_abbr(); end

  def street(); end

  def street_prefix(); end

  def zip_code(); end
  STREET_PREFIX = ::T.let(nil, ::T.untyped)
end

module FFaker::AddressBR
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressBR
  extend ::FFaker::Address
end

module FFaker::AddressCA
  include ::FFaker::Address
  def city(); end

  def postal_code(); end

  def province(); end

  def province_abbr(); end
  POSTAL_CODE_CHARS = ::T.let(nil, ::T.untyped)
  POSTAL_CODE_FORMAT = ::T.let(nil, ::T.untyped)
  PROVINCE_ABBRS = ::T.let(nil, ::T.untyped)
end

module FFaker::AddressCA
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressCA
  extend ::FFaker::Address
end

module FFaker::AddressCH
  include ::FFaker::Address
  def canton_abbr(); end

  def postal_code(); end
end

module FFaker::AddressCH
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressCH
  extend ::FFaker::Address
end

module FFaker::AddressCHDE
  include ::FFaker::AddressCH
  include ::FFaker::Address
  def canton(); end
end

module FFaker::AddressCHDE
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressCHDE
  extend ::FFaker::AddressCH
  extend ::FFaker::Address
end

module FFaker::AddressCHFR
  include ::FFaker::AddressCH
  include ::FFaker::Address
  def canton(); end
end

module FFaker::AddressCHFR
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressCHFR
  extend ::FFaker::AddressCH
  extend ::FFaker::Address
end

module FFaker::AddressCHIT
  include ::FFaker::AddressCH
  include ::FFaker::Address
  def canton(); end
end

module FFaker::AddressCHIT
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressCHIT
  extend ::FFaker::AddressCH
  extend ::FFaker::Address
end

module FFaker::AddressDA
  include ::FFaker::Address
  def city(); end

  def full_address(); end

  def kommune(); end

  def post_nr(); end

  def region(); end

  def state(); end

  def street_address(); end

  def street_name(); end

  def zip_code(); end
  REGION = ::T.let(nil, ::T.untyped)
  STATE = ::T.let(nil, ::T.untyped)
end

module FFaker::AddressDA
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressDA
  extend ::FFaker::Address
end

module FFaker::AddressDE
  include ::FFaker::Address
  def city(); end

  def state(); end

  def street_address(); end

  def street_name(); end

  def zip_code(); end
end

module FFaker::AddressDE
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressDE
  extend ::FFaker::Address
end

module FFaker::AddressFI
  include ::FFaker::Address
  def city(); end

  def full_address(); end

  def random_country(); end

  def street_address(); end

  def street_name(); end

  def street_nbr(); end

  def zip_code(); end
  STREET_NBR_FORMATS = ::T.let(nil, ::T.untyped)
end

module FFaker::AddressFI
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressFI
  extend ::FFaker::Address
end

module FFaker::AddressFR
  include ::FFaker::Address
  def city(); end

  def full_address(); end

  def postal_code(); end

  def region(); end

  def street_address(); end
  MOD = ::T.let(nil, ::T.untyped)
  NUM = ::T.let(nil, ::T.untyped)
  POSTAL_CODE_FORMATS = ::T.let(nil, ::T.untyped)
  SEP = ::T.let(nil, ::T.untyped)
  TYPE = ::T.let(nil, ::T.untyped)
end

module FFaker::AddressFR
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressFR
  extend ::FFaker::Address
end

module FFaker::AddressGR
  include ::FFaker::Address
  def city(); end

  def region(); end

  def street_address(); end

  def street_name(); end

  def street_nbr(); end

  def zip_code(); end
  REGION = ::T.let(nil, ::T.untyped)
  STATE = ::T.let(nil, ::T.untyped)
  STREET_NUMBER = ::T.let(nil, ::T.untyped)
  STREET_PREFIX = ::T.let(nil, ::T.untyped)
end

module FFaker::AddressGR
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressGR
  extend ::FFaker::Address
end

module FFaker::AddressID
  include ::FFaker::Address
  def city(); end

  def state(); end

  def state_abbr(); end

  def street(); end

  def street_prefix(); end

  def zip_code(); end
  STREET_PREFIX = ::T.let(nil, ::T.untyped)
end

module FFaker::AddressID
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressID
  extend ::FFaker::Address
end

module FFaker::AddressIN
  include ::FFaker::Address
  def city(); end

  def country(); end

  def country_code(); end

  def pincode(); end

  def state(); end

  def state_abbr(); end

  def state_and_union_territory(); end

  def state_and_union_territory_abbr(); end

  def time_zone(); end

  def union_territory(); end

  def union_territory_abbr(); end

  def zip_code(); end
end

module FFaker::AddressIN
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressIN
  extend ::FFaker::Address
end

module FFaker::AddressJA
  include ::FFaker::Address
  def address(); end

  def city(); end

  def county(); end

  def designated_city(); end

  def designated_city_address(); end

  def land_number(); end

  def other_address(); end

  def postal_code(); end

  def prefecture(); end

  def street(); end

  def tokyo_ward(); end

  def tokyo_ward_address(); end

  def village(); end

  def ward(); end
  LAND_NUMBER_FORMATS = ::T.let(nil, ::T.untyped)
  ZIP_FORMATS = ::T.let(nil, ::T.untyped)
end

module FFaker::AddressJA
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressJA
  extend ::FFaker::Address
end

module FFaker::AddressKR
  def address_detail(); end

  def borough(); end

  def building_name(); end

  def city(); end

  def land_address(); end

  def land_number(); end

  def metropolitan_city(); end

  def old_postal_code(); end

  def postal_code(); end

  def province(); end

  def road_addess(); end

  def street(); end

  def town(); end
  BUILDING_DONGS = ::T.let(nil, ::T.untyped)
  BUILDING_SUFFIXES = ::T.let(nil, ::T.untyped)
  METROPOLITAN_CITIES = ::T.let(nil, ::T.untyped)
  PROVINCES = ::T.let(nil, ::T.untyped)
  STREET_SUFFIXES = ::T.let(nil, ::T.untyped)
  TOWN_SUFFIXES = ::T.let(nil, ::T.untyped)
end

module FFaker::AddressKR
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressKR
end

module FFaker::AddressMX
  def municipality(st_abbr=T.unsafe(nil)); end

  def postal_code(); end

  def state(); end

  def state_abbr(st_name=T.unsafe(nil)); end

  def zip_code(); end
  AGS = ::T.let(nil, ::T.untyped)
  BC = ::T.let(nil, ::T.untyped)
  BCS = ::T.let(nil, ::T.untyped)
  CAMP = ::T.let(nil, ::T.untyped)
  CHIH = ::T.let(nil, ::T.untyped)
  CHIS = ::T.let(nil, ::T.untyped)
  COAH = ::T.let(nil, ::T.untyped)
  COL = ::T.let(nil, ::T.untyped)
  DF = ::T.let(nil, ::T.untyped)
  DGO = ::T.let(nil, ::T.untyped)
  GRO = ::T.let(nil, ::T.untyped)
  GTO = ::T.let(nil, ::T.untyped)
  HGO = ::T.let(nil, ::T.untyped)
  JAL = ::T.let(nil, ::T.untyped)
  MEX = ::T.let(nil, ::T.untyped)
  MICH = ::T.let(nil, ::T.untyped)
  MOR = ::T.let(nil, ::T.untyped)
  MUNICIPALITY = ::T.let(nil, ::T.untyped)
  NAY = ::T.let(nil, ::T.untyped)
  NL = ::T.let(nil, ::T.untyped)
  OAX = ::T.let(nil, ::T.untyped)
  PUE = ::T.let(nil, ::T.untyped)
  QR = ::T.let(nil, ::T.untyped)
  QRO = ::T.let(nil, ::T.untyped)
  SIN = ::T.let(nil, ::T.untyped)
  SLP = ::T.let(nil, ::T.untyped)
  SON = ::T.let(nil, ::T.untyped)
  TAB = ::T.let(nil, ::T.untyped)
  TAMPS = ::T.let(nil, ::T.untyped)
  TLAX = ::T.let(nil, ::T.untyped)
  VER = ::T.let(nil, ::T.untyped)
  YUC = ::T.let(nil, ::T.untyped)
  ZAC = ::T.let(nil, ::T.untyped)
end

module FFaker::AddressMX
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressMX
end

module FFaker::AddressNL
  include ::FFaker::Address
  def city(); end

  def postal_code(); end

  def province(); end

  def street_name(); end

  def zip_code(); end
end

module FFaker::AddressNL
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressNL
  extend ::FFaker::Address
end

module FFaker::AddressPL
  def building_number(); end

  def city(); end

  def full_address(include_country=T.unsafe(nil), include_secondary=T.unsafe(nil)); end

  def postal_code(); end

  def province(); end

  def secondary_number(); end

  def square(); end

  def square_prefix(); end

  def state(); end

  def street(); end

  def street_address(include_secondary=T.unsafe(nil)); end

  def street_name(); end

  def street_prefix(); end

  def voivodeship(); end

  def voivodeship_abbr(); end

  def voivodeship_capital_city(); end

  def zip_code(); end
  SQUARE_PREFIXES = ::T.let(nil, ::T.untyped)
  STREET_PREFIXES = ::T.let(nil, ::T.untyped)
end

module FFaker::AddressPL
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressPL
end

module FFaker::AddressRU
  include ::FFaker::Address
  def city(); end

  def province(); end

  def street_address(); end

  def street_name(); end

  def street_number(); end

  def zip_code(); end
  POSTAL_CODE_FORMAT = ::T.let(nil, ::T.untyped)
  STREET_NBR_FORMATS = ::T.let(nil, ::T.untyped)
end

module FFaker::AddressRU
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressRU
  extend ::FFaker::Address
end

module FFaker::AddressSE
  include ::FFaker::Address
  def city(); end

  def full_address(); end

  def random_country(); end

  def street_address(); end

  def street_name(); end

  def street_nbr(); end

  def zip_code(); end
  STREET_NBR_FORMATS = ::T.let(nil, ::T.untyped)
  ZIP_FORMATS = ::T.let(nil, ::T.untyped)
end

module FFaker::AddressSE
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressSE
  extend ::FFaker::Address
end

module FFaker::AddressSN
  include ::FFaker::Address
  def arrondissement(); end

  def departement(); end

  def region(); end
end

module FFaker::AddressSN
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressSN
  extend ::FFaker::Address
end

module FFaker::AddressUA
  def appartment_number(); end

  def building_number(); end

  def city(); end

  def country(); end

  def province(); end

  def street_address(include_secondary=T.unsafe(nil)); end

  def street_name(); end

  def zip_code(); end
  APPARTMENT_NUMBER_FORMATS = ::T.let(nil, ::T.untyped)
  BUILDING_NUMBER_FORMATS = ::T.let(nil, ::T.untyped)
  POSTAL_CODE_FORMAT = ::T.let(nil, ::T.untyped)
end

module FFaker::AddressUA
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressUA
end

module FFaker::AddressUK
  include ::FFaker::Address
  def country(); end

  def county(); end

  def postcode(); end
  COUNTRY = ::T.let(nil, ::T.untyped)
  POSTCODE = ::T.let(nil, ::T.untyped)
end

module FFaker::AddressUK
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressUK
  extend ::FFaker::Address
end

module FFaker::AddressUS
  include ::FFaker::Address
  def continental_state(); end

  def continental_state_abbr(); end

  def state(); end

  def state_abbr(st_name=T.unsafe(nil)); end

  def state_and_territories_abbr(); end

  def zip_code(); end
  CONTINENTAL_STATE = ::T.let(nil, ::T.untyped)
  CONTINENTAL_STATE_ABBR = ::T.let(nil, ::T.untyped)
  STATE = ::T.let(nil, ::T.untyped)
  STATE_ABBR = ::T.let(nil, ::T.untyped)
  ZIP_FORMATS = ::T.let(nil, ::T.untyped)
end

module FFaker::AddressUS
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AddressUS
  extend ::FFaker::Address
end

module FFaker::Airline
  def flight_number(); end

  def name(); end
end

module FFaker::Airline
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Airline
end

module FFaker::Animal
  def common_name(); end
end

module FFaker::Animal
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Animal
end

module FFaker::AnimalCN
  def common_name(); end
end

module FFaker::AnimalCN
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AnimalCN
end

module FFaker::AnimalES
  def common_name(); end
end

module FFaker::AnimalES
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AnimalES
end

module FFaker::AnimalPL
end

module FFaker::AnimalPL
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  def self.common_name(); end
end

module FFaker::AnimalUS
  def common_name(); end
end

module FFaker::AnimalUS
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::AnimalUS
end

module FFaker::Avatar
  def image(slug=T.unsafe(nil), size=T.unsafe(nil), format=T.unsafe(nil), bgset=T.unsafe(nil)); end
  SUPPORTED_FORMATS = ::T.let(nil, ::T.untyped)
end

module FFaker::Avatar
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Avatar
end

module FFaker::BaconIpsum
  include ::FFaker::Lorem
  def word(); end

  def words(num=T.unsafe(nil)); end
end

module FFaker::BaconIpsum
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::BaconIpsum
  extend ::FFaker::Lorem
end

module FFaker::Bank
  def card_expiry_date(year_range: T.unsafe(nil), year_latest: T.unsafe(nil), format: T.unsafe(nil)); end

  def card_number(); end

  def card_type(); end

  def iban(country_code: T.unsafe(nil)); end
  COUNTRIES = ::T.let(nil, ::T.untyped)
end

module FFaker::Bank
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Bank
end

module FFaker::Book
  def author(); end

  def cover(slug=T.unsafe(nil), size=T.unsafe(nil), format=T.unsafe(nil), bgset=T.unsafe(nil)); end

  def description(sentence_count=T.unsafe(nil)); end

  def genre(); end

  def isbn(); end

  def orly_cover(name=T.unsafe(nil), book_author=T.unsafe(nil), top_text=T.unsafe(nil)); end

  def title(); end
end

module FFaker::Book
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Book
end

module FFaker::Boolean
  def maybe(); end

  def random(); end

  def sample(); end
end

module FFaker::Boolean
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Boolean
end

module FFaker::CheesyLingo
  def paragraph(number_of_phrases=T.unsafe(nil)); end

  def sentence(); end

  def title(); end

  def word(); end

  def words(count=T.unsafe(nil)); end
  TITLE_1 = ::T.let(nil, ::T.untyped)
  TITLE_2 = ::T.let(nil, ::T.untyped)
end

module FFaker::CheesyLingo
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::CheesyLingo
end

module FFaker::Code
  def ean(); end

  def npi(legacy: T.unsafe(nil)); end
end

module FFaker::Code
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Code
end

module FFaker::Color
  def hex_code(); end

  def hsl_array(); end

  def hsl_list(); end

  def hsla_array(); end

  def hsla_list(); end

  def name(); end

  def rgb_array(); end

  def rgb_list(); end

  def rgba_array(); end

  def rgba_list(); end
end

module FFaker::Color
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Color
end

module FFaker::ColorPL
  def name(); end
end

module FFaker::ColorPL
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::ColorPL
end

module FFaker::ColorUA
  def name(); end
end

module FFaker::ColorUA
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::ColorUA
end

module FFaker::Company
  def bs(); end

  def catch_phrase(); end

  def name(); end

  def position(); end

  def suffix(); end
  POSITIONS = ::T.let(nil, ::T.untyped)
  POSITION_PREFIXES = ::T.let(nil, ::T.untyped)
  SUFFIXES = ::T.let(nil, ::T.untyped)
end

module FFaker::Company
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Company
end

module FFaker::CompanyCN
  def name(); end

  def suffix(); end

  def type(); end
  SUFFIXES = ::T.let(nil, ::T.untyped)
  TYPES = ::T.let(nil, ::T.untyped)
end

module FFaker::CompanyCN
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::CompanyCN
end

module FFaker::CompanyIT
  def name(); end

  def partita_iva(); end

  def prefix(); end

  def suffix(); end
  PREFIXES = ::T.let(nil, ::T.untyped)
  SUFFIXES = ::T.let(nil, ::T.untyped)
end

module FFaker::CompanyIT
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::CompanyIT
end

module FFaker::CompanyJA
  def name(); end

  def position(); end
  DETAILED_TYPES = ::T.let(nil, ::T.untyped)
  POSITIONS = ::T.let(nil, ::T.untyped)
  TYPES = ::T.let(nil, ::T.untyped)
end

module FFaker::CompanyJA
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::CompanyJA
end

module FFaker::CompanySE
  def name(); end

  def suffix(); end
  SUFFIXES = ::T.let(nil, ::T.untyped)
end

module FFaker::CompanySE
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::CompanySE
end

module FFaker::Conference
  def name(); end
end

module FFaker::Conference
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Conference
end

module FFaker::CoursesFR
end

module FFaker::CoursesFR::Mathematiques
  def lesson(); end
end

module FFaker::CoursesFR::Mathematiques
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::CoursesFR::Mathematiques
end

module FFaker::CoursesFR::Philosophie
  def lesson(); end
end

module FFaker::CoursesFR::Philosophie
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::CoursesFR::Philosophie
end

module FFaker::CoursesFR
end

module FFaker::Currency
  def code(); end

  def name(); end

  def symbol(); end
end

module FFaker::Currency
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Currency
end

module FFaker::DizzleIpsum
  def word(); end

  def words(num=T.unsafe(nil)); end
end

module FFaker::DizzleIpsum
  extend ::FFaker::Lorem
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::DizzleIpsum
end

module FFaker::Education
  def degree(); end

  def degree_short(); end

  def major(); end

  def school(); end

  def school_generic_name(); end

  def school_name(); end
  MAJOR_ADJ = ::T.let(nil, ::T.untyped)
  SCHOOL_ADJ = ::T.let(nil, ::T.untyped)
  SCHOOL_PREFIX = ::T.let(nil, ::T.untyped)
  SCHOOL_TYPE = ::T.let(nil, ::T.untyped)
  SCHOOL_UNI = ::T.let(nil, ::T.untyped)
end

module FFaker::Education
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Education
end

module FFaker::EducationCN
  def degree(); end

  def location(); end

  def major(); end

  def school(); end
  DEGREE_PREFIX = ::T.let(nil, ::T.untyped)
  DEGREE_SUFFIX = ::T.let(nil, ::T.untyped)
  POSITION = ::T.let(nil, ::T.untyped)
  SCHOOL_UNI = ::T.let(nil, ::T.untyped)
end

module FFaker::EducationCN
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::EducationCN
end

module FFaker::Filesystem
  def extension(); end

  def file_name(dir=T.unsafe(nil), name=T.unsafe(nil), ext=T.unsafe(nil), directory_separator=T.unsafe(nil)); end

  def mime_type(); end
  SLUG_DELIMITERS = ::T.let(nil, ::T.untyped)
end

module FFaker::Filesystem
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Filesystem
end

module FFaker::Food
  def fruit(); end

  def herb_or_spice(); end

  def ingredient(); end

  def meat(); end

  def vegetable(); end
end

module FFaker::Food
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Food
end

module FFaker::Gender
  def binary(); end

  def maybe(); end

  def random(); end

  def sample(); end
  BINARY_GENDERS = ::T.let(nil, ::T.untyped)
  GENDERS = ::T.let(nil, ::T.untyped)
end

module FFaker::Gender
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Gender
end

module FFaker::GenderBR
  def maybe(); end

  def random(); end

  def sample(); end
  GENDERS = ::T.let(nil, ::T.untyped)
end

module FFaker::GenderBR
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::GenderBR
end

module FFaker::GenderCN
  def maybe(); end

  def random(); end

  def sample(); end
  GENDERS = ::T.let(nil, ::T.untyped)
end

module FFaker::GenderCN
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::GenderCN
end

module FFaker::GenderID
  def maybe(); end

  def random(); end

  def sample(); end
  GENDERS = ::T.let(nil, ::T.untyped)
end

module FFaker::GenderID
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::GenderID
end

module FFaker::GenderJA
  def maybe(); end

  def random(); end

  def sample(); end
  GENDERS = ::T.let(nil, ::T.untyped)
end

module FFaker::GenderJA
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::GenderJA
end

module FFaker::GenderJP
  include ::FFaker::GenderJA
end

module FFaker::GenderJP
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::GenderJA
end

module FFaker::GenderKR
  def maybe(); end

  def random(); end

  def sample(); end
  GENDERS = ::T.let(nil, ::T.untyped)
end

module FFaker::GenderKR
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::GenderKR
end

module FFaker::GenderPL
  def maybe(); end

  def random(); end

  def sample(); end
  GENDERS = ::T.let(nil, ::T.untyped)
end

module FFaker::GenderPL
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::GenderPL
end

module FFaker::Geolocation
  def boxed_coords(upper_left, lower_right); end

  def lat(); end

  def lng(); end
  LATLNG = ::T.let(nil, ::T.untyped)
end

module FFaker::Geolocation
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Geolocation
end

module FFaker::Guid
  def guid(); end
end

module FFaker::Guid
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Guid
end

module FFaker::HTMLIpsum
  def a(word_count=T.unsafe(nil)); end

  def body(); end

  def dl(definitions=T.unsafe(nil)); end

  def fancy_string(count=T.unsafe(nil), include_breaks=T.unsafe(nil)); end

  def ol_long(items=T.unsafe(nil)); end

  def ol_short(items=T.unsafe(nil)); end

  def p(count=T.unsafe(nil), options=T.unsafe(nil)); end

  def table(rows=T.unsafe(nil)); end

  def ul_links(items=T.unsafe(nil)); end

  def ul_long(items=T.unsafe(nil)); end

  def ul_short(items=T.unsafe(nil)); end
end

module FFaker::HTMLIpsum
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::HTMLIpsum
end

module FFaker::HealthcareIpsum
  include ::FFaker::Lorem
  def word(); end

  def words(num=T.unsafe(nil)); end
end

module FFaker::HealthcareIpsum
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::HealthcareIpsum
  extend ::FFaker::Lorem
end

module FFaker::HealthcareRU
  def doctor_specialization(); end
end

module FFaker::HealthcareRU
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::HealthcareRU
end

module FFaker::HipsterIpsum
  include ::FFaker::Lorem
  def word(); end

  def words(num=T.unsafe(nil)); end
end

module FFaker::HipsterIpsum
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::HipsterIpsum
  extend ::FFaker::Lorem
end

module FFaker::Identification
  def drivers_license(); end

  def ethnicity(); end

  def gender(); end

  def ssn(); end
  ETHNICITIES = ::T.let(nil, ::T.untyped)
  GENDERS = ::T.let(nil, ::T.untyped)
end

module FFaker::Identification
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Identification
end

module FFaker::IdentificationBR
  def cnpj(); end

  def cnpj_verification_digits(cnpj); end

  def cpf(); end

  def cpf_verification_digits(cpf); end

  def gender(); end

  def pretty_cnpj(); end

  def pretty_cpf(); end

  def pretty_rg(); end

  def rg(); end
  CNPJ_VERIFICATION_MULTIPLIERS = ::T.let(nil, ::T.untyped)
  CPF_VERIFICATION_MULTIPLIERS = ::T.let(nil, ::T.untyped)
  GENDERS = ::T.let(nil, ::T.untyped)
end

module FFaker::IdentificationBR
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::IdentificationBR
end

module FFaker::IdentificationES
  def gender(); end
  GENDERS = ::T.let(nil, ::T.untyped)
end

module FFaker::IdentificationES
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::IdentificationES
end

module FFaker::IdentificationESCL
  def rut(); end
end

module FFaker::IdentificationESCL
  extend ::FFaker::IdentificationES
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::IdentificationESCL
end

module FFaker::IdentificationESCO
  include ::FFaker::IdentificationES
  def blood_type(); end

  def driver_license_category(); end

  def drivers_license(); end

  def expedition_date(); end

  def id(); end
  BLOOD_TYPE = ::T.let(nil, ::T.untyped)
  LICENSE_CATEGORY = ::T.let(nil, ::T.untyped)
end

module FFaker::IdentificationESCO
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::IdentificationESCO
  extend ::FFaker::IdentificationES
end

module FFaker::IdentificationIN
  def aadhaar(); end
  AADHAAR_FORMAT = ::T.let(nil, ::T.untyped)
end

module FFaker::IdentificationIN
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::IdentificationIN
end

module FFaker::IdentificationKr
  def rrn(); end
end

module FFaker::IdentificationKr
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::IdentificationKr
end

module FFaker::IdentificationMX
  def curp(); end

  def rfc(); end

  def rfc_persona_fisica(); end

  def rfc_persona_moral(); end
  CONSONANTS = ::T.let(nil, ::T.untyped)
  HOMOCLAVE = ::T.let(nil, ::T.untyped)
  VOWELS = ::T.let(nil, ::T.untyped)
end

module FFaker::IdentificationMX
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::IdentificationMX
end

module FFaker::IdentificationPL
  def drivers_license(); end

  def id(); end

  def identity_card(); end

  def pesel(); end
end

module FFaker::IdentificationPL
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::IdentificationPL
end

module FFaker::IdentificationTW
  def id(); end
  AREA_CODE = ::T.let(nil, ::T.untyped)
end

module FFaker::IdentificationTW
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::IdentificationTW
end

module FFaker::Image
  def file(size=T.unsafe(nil), format=T.unsafe(nil), bg_color=T.unsafe(nil), text_color=T.unsafe(nil), text=T.unsafe(nil)); end

  def url(size=T.unsafe(nil), format=T.unsafe(nil), bg_color=T.unsafe(nil), text_color=T.unsafe(nil), text=T.unsafe(nil)); end
  SUPPORTED_FORMATS = ::T.let(nil, ::T.untyped)
end

module FFaker::Image
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Image
end

module FFaker::Internet
  def disposable_email(name=T.unsafe(nil)); end

  def domain_name(); end

  def domain_suffix(); end

  def domain_word(); end

  def email(name=T.unsafe(nil)); end

  def free_email(name=T.unsafe(nil)); end

  def http_url(); end

  def ip_v4_address(); end

  def mac(delimiter=T.unsafe(nil)); end

  def password(min_length=T.unsafe(nil), max_length=T.unsafe(nil)); end

  def safe_email(name=T.unsafe(nil)); end

  def slug(words=T.unsafe(nil), glue=T.unsafe(nil)); end

  def uri(protocol); end

  def user_name(name=T.unsafe(nil)); end
  BYTE = ::T.let(nil, ::T.untyped)
  DISPOSABLE_HOSTS = ::T.let(nil, ::T.untyped)
  DOMAIN_SUFFIXES = ::T.let(nil, ::T.untyped)
  HOSTS = ::T.let(nil, ::T.untyped)
  MAC_LIMIT = ::T.let(nil, ::T.untyped)
  SAFE_DOMAIN_SUFFIXES = ::T.let(nil, ::T.untyped)
  SLUG_DELIMITERS = ::T.let(nil, ::T.untyped)
end

module FFaker::Internet
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Internet
end

module FFaker::InternetSE
  include ::FFaker::Internet
  def company_name_single_word(); end

  def disposable_email(name=T.unsafe(nil)); end

  def domain_name(); end

  def domain_suffix(); end

  def domain_word(); end

  def email(name=T.unsafe(nil)); end

  def free_email(name=T.unsafe(nil)); end

  def http_url(); end

  def ip_v4_address(); end

  def join_to_user_name(array_parts); end

  def login_user_name(); end

  def slug(words=T.unsafe(nil), glue=T.unsafe(nil)); end

  def uri(protocol); end

  def user_name(name=T.unsafe(nil)); end

  def user_name_from_name(name); end

  def user_name_random(); end

  def user_name_variant_long(); end

  def user_name_variant_short(); end
  BYTE = ::T.let(nil, ::T.untyped)
  DISPOSABLE_HOSTS = ::T.let(nil, ::T.untyped)
  DOMAIN_SUFFIXES = ::T.let(nil, ::T.untyped)
  HOSTS = ::T.let(nil, ::T.untyped)
  SLUG_DELIMITERS = ::T.let(nil, ::T.untyped)
end

module FFaker::InternetSE
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::InternetSE
  extend ::FFaker::Internet
end

module FFaker::Job
  def title(); end
end

module FFaker::Job
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Job
end

module FFaker::JobBR
  def title(); end
end

module FFaker::JobBR
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::JobBR
end

module FFaker::JobCN
  def title(); end
end

module FFaker::JobCN
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::JobCN
end

module FFaker::JobFR
  def title(); end
  JOB_ADJECTIVES = ::T.let(nil, ::T.untyped)
end

module FFaker::JobFR
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::JobFR
end

module FFaker::JobJA
  def title(); end
end

module FFaker::JobJA
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::JobJA
end

module FFaker::JobKR
  def title(); end
end

module FFaker::JobKR
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::JobKR
end

module FFaker::JobVN
  def title(); end
end

module FFaker::JobVN
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::JobVN
end

module FFaker::Locale
  def code(given_language=T.unsafe(nil)); end

  def language(given_code=T.unsafe(nil)); end
end

module FFaker::Locale
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Locale
end

module FFaker::Lorem
  def characters(character_count=T.unsafe(nil)); end

  def paragraph(sentence_count=T.unsafe(nil)); end

  def paragraphs(paragraph_count=T.unsafe(nil)); end

  def phrase(word_count=T.unsafe(nil)); end

  def phrases(sentence_count=T.unsafe(nil)); end

  def sentence(word_count=T.unsafe(nil)); end

  def sentences(sentence_count=T.unsafe(nil)); end

  def word(); end

  def words(num=T.unsafe(nil)); end
end

module FFaker::Lorem
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Lorem
end

module FFaker::LoremAR
  def paragraph(sentence_count=T.unsafe(nil)); end

  def paragraphs(paragraph_count=T.unsafe(nil)); end

  def phrase(word_count=T.unsafe(nil)); end

  def phrases(sentence_count=T.unsafe(nil)); end

  def sentence(word_count=T.unsafe(nil)); end

  def sentences(sentence_count=T.unsafe(nil)); end

  def word(); end

  def words(num=T.unsafe(nil)); end
end

module FFaker::LoremAR
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::LoremAR
end

module FFaker::LoremCN
  def paragraph(sentence_count=T.unsafe(nil)); end

  def paragraphs(paragraph_count=T.unsafe(nil)); end

  def sentence(word_count=T.unsafe(nil)); end

  def sentences(sentence_count=T.unsafe(nil)); end

  def word(); end

  def words(num=T.unsafe(nil)); end
end

module FFaker::LoremCN
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::LoremCN
end

module FFaker::LoremFR
  def paragraph(sentence_count=T.unsafe(nil)); end

  def paragraphs(paragraph_count=T.unsafe(nil)); end

  def phrase(word_count=T.unsafe(nil)); end

  def phrases(sentence_count=T.unsafe(nil)); end

  def sentence(word_count=T.unsafe(nil)); end

  def sentences(sentence_count=T.unsafe(nil)); end

  def word(); end

  def words(num=T.unsafe(nil)); end
end

module FFaker::LoremFR
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::LoremFR
end

module FFaker::LoremIE
  def paragraph(); end

  def paragraphs(paragraph_count=T.unsafe(nil)); end

  def phrase(); end

  def phrases(sentence_count=T.unsafe(nil)); end

  def question(); end

  def sentence(); end

  def sentences(sentence_count=T.unsafe(nil)); end

  def word(); end

  def words(num=T.unsafe(nil)); end
end

module FFaker::LoremIE
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::LoremIE
end

module FFaker::LoremJA
  def character(); end

  def characters(count=T.unsafe(nil)); end

  def paragraph(sentence_count=T.unsafe(nil)); end

  def paragraphs(count=T.unsafe(nil)); end

  def sentence(); end

  def sentences(count=T.unsafe(nil)); end

  def word(); end

  def words(count=T.unsafe(nil)); end
end

module FFaker::LoremJA
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::LoremJA
end

module FFaker::LoremKR
  def paragraph(sentence_count=T.unsafe(nil)); end

  def paragraphs(paragraph_count=T.unsafe(nil)); end

  def phrase(word_count=T.unsafe(nil)); end

  def phrases(sentence_count=T.unsafe(nil)); end

  def sentence(word_count=T.unsafe(nil)); end

  def sentences(sentence_count=T.unsafe(nil)); end

  def word(); end

  def words(num=T.unsafe(nil)); end
end

module FFaker::LoremKR
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::LoremKR
end

module FFaker::LoremPL
  def character(); end

  def characters(count=T.unsafe(nil)); end

  def paragraph(count=T.unsafe(nil)); end

  def paragraphs(count=T.unsafe(nil)); end

  def phrase(count=T.unsafe(nil)); end

  def phrases(count=T.unsafe(nil)); end

  def sentence(count=T.unsafe(nil)); end

  def sentences(count=T.unsafe(nil)); end

  def word(); end

  def words(count=T.unsafe(nil)); end
end

module FFaker::LoremPL
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::LoremPL
end

module FFaker::LoremRU
  def paragraph(sentence_count=T.unsafe(nil)); end

  def paragraphs(paragraph_count=T.unsafe(nil)); end

  def phrase(word_count=T.unsafe(nil)); end

  def phrases(sentence_count=T.unsafe(nil)); end

  def sentence(word_count=T.unsafe(nil)); end

  def sentences(sentence_count=T.unsafe(nil)); end

  def word(); end

  def words(num=T.unsafe(nil)); end
end

module FFaker::LoremRU
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::LoremRU
end

module FFaker::LoremUA
  def paragraph(sentence_count=T.unsafe(nil)); end

  def paragraphs(paragraph_count=T.unsafe(nil)); end

  def phrase(word_count=T.unsafe(nil)); end

  def phrases(sentence_count=T.unsafe(nil)); end

  def sentence(word_count=T.unsafe(nil)); end

  def sentences(sentence_count=T.unsafe(nil)); end

  def word(); end

  def words(num=T.unsafe(nil)); end
end

module FFaker::LoremUA
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::LoremUA
end

module FFaker::Movie
  def rating(); end

  def title(); end
  COLORS = ::T.let(nil, ::T.untyped)
  RATINGS = ::T.let(nil, ::T.untyped)
  SUFFIXES = ::T.let(nil, ::T.untyped)
end

module FFaker::Movie
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Movie
end

module FFaker::Music
  def album(); end

  def artist(); end

  def genre(); end

  def song(); end
end

module FFaker::Music
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Music
end

module FFaker::Name
  def female_name_with_prefix(); end

  def female_name_with_prefix_suffix(); end

  def female_name_with_suffix(); end

  def female_prefix(); end

  def first_name(); end

  def first_name_female(); end

  def first_name_male(); end

  def html_safe_last_name(); end

  def html_safe_name(); end

  def last_name(); end

  def male_name_with_prefix(); end

  def male_name_with_prefix_suffix(); end

  def male_name_with_suffix(); end

  def male_prefix(); end

  def name(); end

  def name_with_prefix(); end

  def name_with_prefix_suffix(); end

  def name_with_suffix(); end

  def other_prefix(); end

  def prefix(); end

  def pronouns(); end

  def suffix(); end
  FEMALE_PREFIXES = ::T.let(nil, ::T.untyped)
  FIRST_NAMES = ::T.let(nil, ::T.untyped)
  FIRST_NAMES_FEMALE = ::T.let(nil, ::T.untyped)
  FIRST_NAMES_MALE = ::T.let(nil, ::T.untyped)
  MALE_PREFIXES = ::T.let(nil, ::T.untyped)
  OTHER_PREFIXES = ::T.let(nil, ::T.untyped)
  PREFIXES = ::T.let(nil, ::T.untyped)
  SUFFIXES = ::T.let(nil, ::T.untyped)
end

module FFaker::Name
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Name
end

module FFaker::NameAR
  def first_name_female(); end

  def first_name_male(); end

  def last_name(); end

  def name_female(); end

  def name_male(); end
end

module FFaker::NameAR
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameAR
end

module FFaker::NameBR
  def female_name_with_prefix(); end

  def female_prefix(); end

  def first_name(); end

  def first_name_female(); end

  def first_name_male(); end

  def last_name(); end

  def male_name_with_prefix(); end

  def male_prefix(); end

  def name(); end

  def name_with_prefix(); end

  def prefix(); end
  FEMALE_PREFIXES = ::T.let(nil, ::T.untyped)
  FIRST_NAMES = ::T.let(nil, ::T.untyped)
  FIRST_NAMES_FEMALE = ::T.let(nil, ::T.untyped)
  FIRST_NAMES_MALE = ::T.let(nil, ::T.untyped)
  MALE_PREFIXES = ::T.let(nil, ::T.untyped)
  PREFIXES = ::T.let(nil, ::T.untyped)
end

module FFaker::NameBR
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameBR
end

module FFaker::NameCN
  def first_name(); end

  def last_first(); end

  def last_name(); end

  def name(); end
end

module FFaker::NameCN
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameCN
end

module FFaker::NameCS
  include ::FFaker::Name
  def first_name(for_sex=T.unsafe(nil)); end

  def last_name(for_sex=T.unsafe(nil)); end

  def name(for_sex=T.unsafe(nil)); end

  def prefix(); end

  def suffix(); end

  def with_same_sex(sex=T.unsafe(nil)); end
  FEMALE_FIRST_NAMES = ::T.let(nil, ::T.untyped)
  FEMALE_LAST_NAMES = ::T.let(nil, ::T.untyped)
  FIRST_NAMES = ::T.let(nil, ::T.untyped)
  GENDERS = ::T.let(nil, ::T.untyped)
  LAST_NAMES = ::T.let(nil, ::T.untyped)
  MALE_FIRST_NAMES = ::T.let(nil, ::T.untyped)
  MALE_LAST_NAMES = ::T.let(nil, ::T.untyped)
  PREFIXES = ::T.let(nil, ::T.untyped)
  SUFFIXES = ::T.let(nil, ::T.untyped)
end

module FFaker::NameCS
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameCS
  extend ::FFaker::Name
end

module FFaker::NameDA
  include ::FFaker::Name
  def any_name(); end

  def female_name(); end

  def first_name(gender=T.unsafe(nil)); end

  def last_name(); end

  def male_name(); end

  def name(gender=T.unsafe(nil)); end

  def prefix(); end
  PREFIXES = ::T.let(nil, ::T.untyped)
end

module FFaker::NameDA
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameDA
  extend ::FFaker::Name
end

module FFaker::NameDE
  include ::FFaker::Name
  def first_name(); end

  def last_name(); end

  def name(); end

  def prefix(); end
  FIRST_NAMES = ::T.let(nil, ::T.untyped)
  PREFIXES = ::T.let(nil, ::T.untyped)
end

module FFaker::NameDE
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameDE
  extend ::FFaker::Name
end

module FFaker::NameES
  FEMALE_PREFIXES = ::T.let(nil, ::T.untyped)
  FIRST_NAMES = ::T.let(nil, ::T.untyped)
  FIRST_NAMES_FEMALE = ::T.let(nil, ::T.untyped)
  FIRST_NAMES_MALE = ::T.let(nil, ::T.untyped)
  MALE_PREFIXES = ::T.let(nil, ::T.untyped)
  PREFIXES = ::T.let(nil, ::T.untyped)
end

module FFaker::NameES
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  def self.female_name_with_prefix(); end

  def self.female_prefix(); end

  def self.first_name(); end

  def self.first_name_female(); end

  def self.first_name_male(); end

  def self.last_name(); end

  def self.male_name_with_prefix(); end

  def self.male_prefix(); end

  def self.name_with_prefix(); end

  def self.prefix(); end
end

module FFaker::NameFR
  def first_name(); end

  def last_name(); end

  def name(); end

  def prefix(); end
  PREFIX = ::T.let(nil, ::T.untyped)
end

module FFaker::NameFR
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameFR
end

module FFaker::NameGA
  def first_name_female(); end

  def first_name_male(); end

  def last_name(); end

  def name(); end

  def name_female(); end

  def name_male(); end
  LAST_NAMES = ::T.let(nil, ::T.untyped)
end

module FFaker::NameGA
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameGA
end

module FFaker::NameGR
  def female_first_name(); end

  def female_full_name(); end

  def female_last_name(); end

  def first_name(); end

  def full_name(gender=T.unsafe(nil)); end

  def last_name(); end

  def male_first_name(); end

  def male_full_name(); end

  def male_last_name(); end

  def name(gender=T.unsafe(nil)); end
end

module FFaker::NameGR
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameGR
end

module FFaker::NameID
  def female_name_with_prefix(); end

  def female_prefix(); end

  def first_name(); end

  def first_name_female(); end

  def first_name_male(); end

  def last_name(); end

  def male_name_with_prefix(); end

  def male_prefix(); end

  def name(); end

  def name_with_prefix(); end

  def prefix(); end
  FEMALE_PREFIXES = ::T.let(nil, ::T.untyped)
  FIRST_NAMES = ::T.let(nil, ::T.untyped)
  FIRST_NAMES_FEMALE = ::T.let(nil, ::T.untyped)
  FIRST_NAMES_MALE = ::T.let(nil, ::T.untyped)
  MALE_PREFIXES = ::T.let(nil, ::T.untyped)
  PREFIXES = ::T.let(nil, ::T.untyped)
end

module FFaker::NameID
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameID
end

module FFaker::NameIN
  def first_name_female(); end

  def first_name_male(); end

  def last_name(); end

  def name(); end

  def name_female(); end

  def name_male(); end
end

module FFaker::NameIN
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameIN
end

module FFaker::NameIT
  def first_name(); end

  def last_name(); end

  def name(); end

  def prefix(); end
  PREFIX = ::T.let(nil, ::T.untyped)
end

module FFaker::NameIT
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameIT
end

module FFaker::NameJA
  def first_name(); end

  def last_first(); end

  def last_name(); end

  def name(); end
end

module FFaker::NameJA
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameJA
end

module FFaker::NameKH
  def first_name(); end

  def last_name(); end

  def name(); end

  def nick_name(); end
end

module FFaker::NameKH
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameKH
end

module FFaker::NameKR
  def first_name(); end

  def last_first(); end

  def last_name(); end

  def name(); end

  def name_with_space(); end
end

module FFaker::NameKR
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameKR
end

module FFaker::NameMX
  include ::FFaker::Name
  def female_name(); end

  def female_prefix(); end

  def first_name(gender=T.unsafe(nil)); end

  def full_name(gender=T.unsafe(nil), prefix=T.unsafe(nil)); end

  def full_name_no_prefix(gender=T.unsafe(nil)); end

  def full_name_prefix(gender=T.unsafe(nil)); end

  def last_name(); end

  def male_name(); end

  def male_prefix(); end

  def middle_name(gender=T.unsafe(nil)); end

  def name(gender=T.unsafe(nil)); end

  def paternal_last_names(); end

  def prefix(); end
  FEMALE_PREFIXES = ::T.let(nil, ::T.untyped)
  MALE_PREFIXES = ::T.let(nil, ::T.untyped)
  PREFIXES = ::T.let(nil, ::T.untyped)
end

module FFaker::NameMX
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameMX
  extend ::FFaker::Name
end

module FFaker::NameNB
  include ::FFaker::Name
  def first_name(); end

  def first_name_female(); end

  def first_name_male(); end

  def last_name(); end

  def name(); end

  def prefix(); end
  FIRST_NAMES_FEMALE = ::T.let(nil, ::T.untyped)
  FIRST_NAMES_MALE = ::T.let(nil, ::T.untyped)
  PREFIXES = ::T.let(nil, ::T.untyped)
end

module FFaker::NameNB
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameNB
  extend ::FFaker::Name
end

module FFaker::NameNL
  include ::FFaker::Name
  def first_name(); end

  def first_name_female(); end

  def first_name_male(); end

  def last_name(); end

  def name(); end

  def prefix(); end
  FIRST_NAMES_FEMALE = ::T.let(nil, ::T.untyped)
  FIRST_NAMES_MALE = ::T.let(nil, ::T.untyped)
  PREFIXES = ::T.let(nil, ::T.untyped)
end

module FFaker::NameNL
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameNL
  extend ::FFaker::Name
end

module FFaker::NamePH
  include ::FFaker::Name
  def last_name(); end

  def name(); end
end

module FFaker::NamePH
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NamePH
  extend ::FFaker::Name
end

module FFaker::NamePL
  def academic_degree_prefix(); end

  def female_first_name(); end

  def female_full_name(); end

  def female_last_name(); end

  def female_name_with_prefix(); end

  def female_prefix(); end

  def first_name(gender=T.unsafe(nil)); end

  def full_name(gender=T.unsafe(nil)); end

  def last_name(gender=T.unsafe(nil)); end

  def male_first_name(); end

  def male_full_name(); end

  def male_last_name(); end

  def male_name_with_prefix(); end

  def male_prefix(); end

  def name(gender=T.unsafe(nil)); end

  def name_with_prefix(gender=T.unsafe(nil)); end

  def prefix(); end
  ACADEMIC_DEGREE_PREFIXES = ::T.let(nil, ::T.untyped)
  FEMALE_PREFIXES = ::T.let(nil, ::T.untyped)
  GENDERS = ::T.let(nil, ::T.untyped)
  MALE_PREFIXES = ::T.let(nil, ::T.untyped)
  PREFIXES = ::T.let(nil, ::T.untyped)
end

module FFaker::NamePL
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NamePL
end

module FFaker::NameRU
  def female_name(); end

  def first_name(); end

  def first_name_female(); end

  def first_name_male(); end

  def last_name(); end

  def last_name_female(); end

  def last_name_male(); end

  def male_name(); end

  def middle_name_female(); end

  def middle_name_male(); end

  def name(); end
  FIRST_NAMES = ::T.let(nil, ::T.untyped)
  FIRST_NAMES_FEMALE = ::T.let(nil, ::T.untyped)
  FIRST_NAMES_MALE = ::T.let(nil, ::T.untyped)
  LAST_NAMES = ::T.let(nil, ::T.untyped)
  LAST_NAMES_FEMALE = ::T.let(nil, ::T.untyped)
  LAST_NAMES_MALE = ::T.let(nil, ::T.untyped)
end

module FFaker::NameRU
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameRU
end

module FFaker::NameSE
  include ::FFaker::Name
  def first_name(); end

  def first_name_female(); end

  def first_name_male(); end

  def last_name(); end

  def name(); end

  def prefix(); end
  FIRST_NAMES_FEMALE = ::T.let(nil, ::T.untyped)
  FIRST_NAMES_MALE = ::T.let(nil, ::T.untyped)
  PREFIXES = ::T.let(nil, ::T.untyped)
end

module FFaker::NameSE
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameSE
  extend ::FFaker::Name
end

module FFaker::NameSN
  def first_name_female(); end

  def first_name_male(); end

  def last_name(); end

  def name_female(); end

  def name_male(); end

  def name_sn(); end

  def prefix_female(); end

  def prefix_male(); end
  PREFIX_FEMALE = ::T.let(nil, ::T.untyped)
  PREFIX_MALE = ::T.let(nil, ::T.untyped)
end

module FFaker::NameSN
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameSN
end

module FFaker::NameTH
  def first_name(); end

  def last_name(); end

  def name(); end

  def nick_name(); end
end

module FFaker::NameTH
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameTH
end

module FFaker::NameTHEN
  def first_name(); end

  def last_name(); end

  def name(); end

  def nick_name(); end
end

module FFaker::NameTHEN
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameTHEN
end

module FFaker::NameTW
  def first_name(); end

  def last_name(); end

  def name(); end
end

module FFaker::NameTW
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameTW
end

module FFaker::NameUA
  def first_name(); end

  def first_name_female(); end

  def first_name_male(); end

  def last_name(); end

  def last_name_female(); end

  def last_name_male(); end

  def middle_name_female(); end

  def middle_name_male(); end

  def name(); end
  FIRST_NAMES = ::T.let(nil, ::T.untyped)
  FIRST_NAMES_FEMALE = ::T.let(nil, ::T.untyped)
  FIRST_NAMES_MALE = ::T.let(nil, ::T.untyped)
  LAST_NAMES = ::T.let(nil, ::T.untyped)
  LAST_NAMES_FEMALE = ::T.let(nil, ::T.untyped)
  LAST_NAMES_MALE = ::T.let(nil, ::T.untyped)
  MIDDLE_NAMES = ::T.let(nil, ::T.untyped)
  MIDDLE_NAMES_FEMALE = ::T.let(nil, ::T.untyped)
  MIDDLE_NAMES_MALE = ::T.let(nil, ::T.untyped)
end

module FFaker::NameUA
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameUA
end

module FFaker::NameVN
  def first_name(); end

  def last_first(); end

  def last_name(); end

  def middle_name(); end

  def name(); end
end

module FFaker::NameVN
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NameVN
end

module FFaker::NatoAlphabet
  def alphabetic_code(); end

  def callsign(); end

  def code(); end

  def codify(masks); end

  def numeric_code(); end
  ALPHABET_CODES = ::T.let(nil, ::T.untyped)
  CODES = ::T.let(nil, ::T.untyped)
  NUMERIC_CODES = ::T.let(nil, ::T.untyped)
  STOP_CODE = ::T.let(nil, ::T.untyped)
end

module FFaker::NatoAlphabet
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::NatoAlphabet
end

module FFaker::PhoneNumber
  def area_code(); end

  def exchange_code(); end

  def imei(serial_number=T.unsafe(nil)); end

  def phone_calling_code(); end

  def phone_number(); end

  def short_phone_number(); end
end

module FFaker::PhoneNumber
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::PhoneNumber
end

module FFaker::PhoneNumberAU
  def country_code(); end

  def home_work_phone_number(); end

  def home_work_phone_prefix(); end

  def international_home_work_phone_number(); end

  def international_mobile_phone_number(); end

  def international_phone_number(); end

  def mobile_phone_number(); end

  def mobile_phone_prefix(); end

  def phone_number(); end

  def phone_prefix(); end
  HOME_WORK_OPERATORS_PREFIX = ::T.let(nil, ::T.untyped)
  MOBILE_OPERATORS_PREFIX = ::T.let(nil, ::T.untyped)
  OPERATORS_PREFIX = ::T.let(nil, ::T.untyped)
end

module FFaker::PhoneNumberAU
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::PhoneNumberAU
end

module FFaker::PhoneNumberBR
  def country_code(); end

  def home_work_phone_number(); end

  def international_home_work_phone_number(); end

  def international_mobile_phone_number(); end

  def international_phone_number(); end

  def mobile_phone_number(); end

  def phone_number(); end
  AREA_CODE = ::T.let(nil, ::T.untyped)
  COUNTRY_PREFIX = ::T.let(nil, ::T.untyped)
  HOME_WORK_PHONE_PREFIX = ::T.let(nil, ::T.untyped)
  MOBILE_PHONE_PREFIX = ::T.let(nil, ::T.untyped)
  PHONE_NUMBER = ::T.let(nil, ::T.untyped)
end

module FFaker::PhoneNumberBR
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::PhoneNumberBR
end

module FFaker::PhoneNumberCH
  def free_phone_number(); end

  def home_work_phone_number(); end

  def mobile_phone_number(); end

  def phone_number(); end

  def premium_rate_phone_number(); end

  def shared_cost_phone_number(); end
  AREA_PREFIX = ::T.let(nil, ::T.untyped)
  COUNTRY_PREFIX = ::T.let(nil, ::T.untyped)
  FREE_PHONE_PREFIX = ::T.let(nil, ::T.untyped)
  MOBILE_PREFIX = ::T.let(nil, ::T.untyped)
  PHONE_NUMBER = ::T.let(nil, ::T.untyped)
  PREMIUM_RATE_PREFIX = ::T.let(nil, ::T.untyped)
  SHARED_COST_PREFIX = ::T.let(nil, ::T.untyped)
end

module FFaker::PhoneNumberCH
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::PhoneNumberCH
end

module FFaker::PhoneNumberCU
  def country_code(); end

  def e164_country_code(); end

  def e164_home_work_phone_number(); end

  def e164_mobile_phone_number(); end

  def e164_phone_number(); end

  def general_phone_number(); end

  def home_work_phone_number(); end

  def home_work_phone_prefix(); end

  def international_country_code(); end

  def international_home_work_phone_number(); end

  def international_mobile_phone_number(); end

  def international_phone_number(); end

  def mobile_phone_number(); end

  def mobile_phone_prefix(); end

  def phone_number(); end

  def phone_prefix(); end
  HOME_WORK_OPERATORS_PREFIX = ::T.let(nil, ::T.untyped)
  MOBILE_OPERATORS_PREFIX = ::T.let(nil, ::T.untyped)
  OPERATORS_PREFIX = ::T.let(nil, ::T.untyped)
end

module FFaker::PhoneNumberCU
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::PhoneNumberCU
end

module FFaker::PhoneNumberDA
  def country_code(); end

  def home_work_phone_number(); end

  def international_home_work_phone_number(); end

  def international_mobile_phone_number(); end

  def international_phone_number(); end

  def mobile_phone_number(); end

  def phone_number(); end
end

module FFaker::PhoneNumberDA
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::PhoneNumberDA
end

module FFaker::PhoneNumberDE
  def country_code(); end

  def home_work_phone_number(leading_zero=T.unsafe(nil)); end

  def international_home_work_phone_number(); end

  def international_mobile_phone_number(); end

  def international_phone_number(); end

  def mobile_phone_number(leading_zero=T.unsafe(nil)); end

  def mobile_prefix(leading_zero=T.unsafe(nil)); end

  def phone_number(); end

  def region_prefix(leading_zero=T.unsafe(nil)); end
end

module FFaker::PhoneNumberDE
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::PhoneNumberDE
end

module FFaker::PhoneNumberFR
  def country_code(); end

  def home_work_phone_number(); end

  def international_home_work_phone_number(); end

  def international_mobile_phone_number(); end

  def international_phone_number(); end

  def mobile_phone_number(); end

  def phone_number(); end
  AREA_PREFIX = ::T.let(nil, ::T.untyped)
  COUNTRY_CODE = ::T.let(nil, ::T.untyped)
  HOME_WORK_PHONE_PREFIX = ::T.let(nil, ::T.untyped)
  MOBILE_PHONE_PREFIX = ::T.let(nil, ::T.untyped)
  NON_AREA_PREFIX = ::T.let(nil, ::T.untyped)
  PHONE_NUMBER = ::T.let(nil, ::T.untyped)
  PHONE_PREFIX = ::T.let(nil, ::T.untyped)
end

module FFaker::PhoneNumberFR
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::PhoneNumberFR
end

module FFaker::PhoneNumberID
  def home_phone_number(); end

  def international_home_phone_number(); end

  def international_mobile_phone_number(); end

  def international_phone_number(); end

  def mobile_phone_number(); end

  def phone_number(); end
  COUNTRY_CODE = ::T.let(nil, ::T.untyped)
end

module FFaker::PhoneNumberID
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::PhoneNumberID
end

module FFaker::PhoneNumberIT
  def home_phone_number(); end

  def mobile_phone_number(); end

  def number(prefixes); end

  def phone_number(); end

  def random_space(); end
  COUNTRY_PREFIX = ::T.let(nil, ::T.untyped)
  PHONE_NUMBER = ::T.let(nil, ::T.untyped)
end

module FFaker::PhoneNumberIT
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::PhoneNumberIT
end

module FFaker::PhoneNumberKR
  def contry_code(); end

  def home_work_phone_number(); end

  def international_home_work_phone_number(); end

  def international_mobile_phone_number(); end

  def international_phone_number(); end

  def mobile_phone_number(); end

  def phone_number(); end
  HOME_PHONE_PREFIXES = ::T.let(nil, ::T.untyped)
  MOBILE_PHONE_PREFIXES = ::T.let(nil, ::T.untyped)
end

module FFaker::PhoneNumberKR
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::PhoneNumberKR
end

module FFaker::PhoneNumberMX
  def country_code(); end

  def home_work_phone_number(); end

  def international_home_work_phone_number(); end

  def international_mobile_phone_number(); end

  def international_phone_number(); end

  def mobile_phone_number(); end

  def phone_number(); end

  def toll_free_number(); end
end

module FFaker::PhoneNumberMX
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::PhoneNumberMX
end

module FFaker::PhoneNumberNL
  def home_work_phone_number(); end

  def international_home_work_phone_number(); end

  def international_mobile_phone_number(); end

  def international_phone_number(); end

  def mobile_phone_number(); end

  def phone_number(); end
  AREA_CODE_PREFIX = ::T.let(nil, ::T.untyped)
  COUNTRY_CODE = ::T.let(nil, ::T.untyped)
  MOBILE_PHONE_NUMBER = ::T.let(nil, ::T.untyped)
  PHONE_NUMBER = ::T.let(nil, ::T.untyped)
end

module FFaker::PhoneNumberNL
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::PhoneNumberNL
end

module FFaker::PhoneNumberPL
  AREA_CODES = ::T.let(nil, ::T.untyped)
  COUNTRY_CODE = ::T.let(nil, ::T.untyped)
  MOBILE_PREFIXES = ::T.let(nil, ::T.untyped)
  PHONE_NUMBER_FORMAT = ::T.let(nil, ::T.untyped)
end

module FFaker::PhoneNumberPL
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  def self.area_code(); end

  def self.home_work_phone_number(); end

  def self.international_home_work_phone_number(); end

  def self.international_mobile_phone_number(); end

  def self.international_phone_number(); end

  def self.mobile_phone_number(); end

  def self.mobile_phone_number_format(); end

  def self.mobile_prefix(); end

  def self.phone_number(); end

  def self.phone_number_format(); end
end

module FFaker::PhoneNumberRU
  def country_code(); end

  def home_work_phone_number(); end

  def home_work_phone_prefix(); end

  def international_country_code(); end

  def international_home_work_phone_number(); end

  def international_mobile_phone_number(); end

  def international_phone_number(); end

  def international_toll_free_number(); end

  def mobile_phone_number(); end

  def mobile_phone_prefix(); end

  def phone_number(); end

  def toll_free_number(); end
  COUNTRY_PREFIX = ::T.let(nil, ::T.untyped)
  INTERNATIONAL_COUNTRY_PREFIX = ::T.let(nil, ::T.untyped)
  TOLL_FREE_PREFIX = ::T.let(nil, ::T.untyped)
end

module FFaker::PhoneNumberRU
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::PhoneNumberRU
end

module FFaker::PhoneNumberSE
  def area_prefix(); end

  def country_prefix(); end

  def home_work_phone_number(); end

  def international_home_work_phone_number(); end

  def international_mobile_phone_number(); end

  def international_phone_number(); end

  def mobile_phone_number(); end

  def mobile_phone_number_format(); end

  def mobile_prefix(); end

  def phone_number(); end

  def phone_number_format(); end
  COUNTRY_PREFIX = ::T.let(nil, ::T.untyped)
  MOBILE_PHONE_FORMAT = ::T.let(nil, ::T.untyped)
  MOBILE_PHONE_PREFIX = ::T.let(nil, ::T.untyped)
  PHONE_FORMAT_PREFIX_2 = ::T.let(nil, ::T.untyped)
  PHONE_FORMAT_PREFIX_3 = ::T.let(nil, ::T.untyped)
  PHONE_FORMAT_PREFIX_4 = ::T.let(nil, ::T.untyped)
end

module FFaker::PhoneNumberSE
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::PhoneNumberSE
end

module FFaker::PhoneNumberSG
  def country_code(); end

  def fixed_line_number(); end

  def international_toll_free_number(); end

  def mobile_number(); end

  def mobile_or_pager_number(); end

  def phone_number(); end

  def premium_service_number(); end

  def toll_free_number(); end

  def voip_number(); end
end

module FFaker::PhoneNumberSG
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::PhoneNumberSG
end

module FFaker::PhoneNumberSN
  def homework_number(); end

  def homework_phone_prefix(); end

  def mobile_number(); end

  def mobile_phone_prefix(); end

  def phone_number(); end

  def short_phone_number(); end
  HOME_WORK_OPERATORS_PREFIX = ::T.let(nil, ::T.untyped)
  MOBILE_OPERATORS_PREFIX = ::T.let(nil, ::T.untyped)
end

module FFaker::PhoneNumberSN
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::PhoneNumberSN
end

module FFaker::PhoneNumberTW
  def contry_code(); end

  def home_work_phone_number(); end

  def international_home_work_phone_number(); end

  def international_mobile_phone_number(); end

  def international_phone_number(); end

  def mobile_phone_number(); end

  def phone_number(); end
  HOME_PHONE_PREFIXES = ::T.let(nil, ::T.untyped)
  MOBILE_PHONE_PREFIX = ::T.let(nil, ::T.untyped)
end

module FFaker::PhoneNumberTW
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::PhoneNumberTW
end

module FFaker::PhoneNumberUA
  def home_phone_number(); end

  def international_home_phone_number(); end

  def international_mobile_phone_number(); end

  def mobile_phone_number(); end

  def phone_number(); end
  COUNTRY_PREFIX = ::T.let(nil, ::T.untyped)
  LOCAL_PREFIX = ::T.let(nil, ::T.untyped)
  PHONE_NUMBER = ::T.let(nil, ::T.untyped)
end

module FFaker::PhoneNumberUA
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::PhoneNumberUA
end

module FFaker::Product
  def brand(); end

  def letters(count); end

  def model(); end

  def product(); end

  def product_name(); end
  ADDON = ::T.let(nil, ::T.untyped)
  B2 = ::T.let(nil, ::T.untyped)
  START = ::T.let(nil, ::T.untyped)
  SUFFIX = ::T.let(nil, ::T.untyped)
  VOWELS = ::T.let(nil, ::T.untyped)
end

module FFaker::Product
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Product
end

module FFaker::SSN
  def ssn(); end
end

module FFaker::SSN
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::SSN
end

module FFaker::SSNMX
  def imss(); end

  def imss_undashed(); end

  def issste(); end

  def issste_undashed(); end

  def ssn(); end

  def ssn_undashed(); end
end

module FFaker::SSNMX
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::SSNMX
end

module FFaker::SSNSE
  def ssn(opts=T.unsafe(nil)); end
  GENDERS = ::T.let(nil, ::T.untyped)
end

module FFaker::SSNSE
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::SSNSE
end

module FFaker::SemVer
  def next(previous_version=T.unsafe(nil)); end
  UPDATE = ::T.let(nil, ::T.untyped)
end

module FFaker::SemVer
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::SemVer
end

module FFaker::Skill
  def specialties(num=T.unsafe(nil)); end

  def specialty(); end

  def tech_skill(); end

  def tech_skills(num=T.unsafe(nil)); end
end

module FFaker::Skill
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Skill
end

module FFaker::Sport
  def name(); end
end

module FFaker::Sport
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Sport
end

module FFaker::SportPL
  def name(); end

  def summer(); end

  def winter(); end
  ALL = ::T.let(nil, ::T.untyped)
  SUMMER = ::T.let(nil, ::T.untyped)
  WINTER = ::T.let(nil, ::T.untyped)
end

module FFaker::SportPL
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::SportPL
end

module FFaker::SportUS
  def name(); end
end

module FFaker::SportUS
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::SportUS
end

module FFaker::String
  def from_regexp(exp); end
  BACKSLASH = ::T.let(nil, ::T.untyped)
  DASH = ::T.let(nil, ::T.untyped)
  ESCAPEABLE_CHARS = ::T.let(nil, ::T.untyped)
  LETTERS = ::T.let(nil, ::T.untyped)
  LOWERS = ::T.let(nil, ::T.untyped)
  NUMBERS = ::T.let(nil, ::T.untyped)
  SPACES = ::T.let(nil, ::T.untyped)
  UPPERS = ::T.let(nil, ::T.untyped)
  WORD_CHARS = ::T.let(nil, ::T.untyped)
end

module FFaker::String
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::String
end

module FFaker::Time
  def between(from, to); end

  def date(params=T.unsafe(nil)); end

  def datetime(params=T.unsafe(nil)); end

  def day_of_week(options=T.unsafe(nil)); end

  def month(); end
  DAYS_OF_WEEK = ::T.let(nil, ::T.untyped)
  MONTHS = ::T.let(nil, ::T.untyped)
end

module FFaker::Time
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Time
end

module FFaker::Tweet
  def body(required_length=T.unsafe(nil)); end

  def mention(); end

  def mentions(num=T.unsafe(nil)); end

  def tags(num_tags=T.unsafe(nil)); end

  def tweet(args=T.unsafe(nil)); end
end

module FFaker::Tweet
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Tweet
end

module FFaker::Unit
  def temperature_abbr(); end

  def temperature_name(); end

  def time_abbr(); end

  def time_name(); end
  TEMPERATURE_UNITS = ::T.let(nil, ::T.untyped)
  TIME_UNITS = ::T.let(nil, ::T.untyped)
end

module FFaker::Unit
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Unit
end

module FFaker::UnitEnglish
  include ::FFaker::Unit
  def area_abbr(); end

  def area_name(); end

  def length_abbr(); end

  def length_name(); end

  def liquid_abbr(); end

  def liquid_name(); end

  def mass_abbr(); end

  def mass_name(); end

  def volume_abbr(); end

  def volume_name(); end
  AREA_UNITS = ::T.let(nil, ::T.untyped)
  LENGTH_UNITS = ::T.let(nil, ::T.untyped)
  LIQUID_UNITS = ::T.let(nil, ::T.untyped)
  MASS_UNITS = ::T.let(nil, ::T.untyped)
  VOLUME_UNITS = ::T.let(nil, ::T.untyped)
end

module FFaker::UnitEnglish
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::UnitEnglish
  extend ::FFaker::Unit
end

module FFaker::UnitMetric
  include ::FFaker::Unit
  def area_abbr(); end

  def area_name(); end

  def length_abbr(); end

  def length_name(); end

  def liquid_abbr(); end

  def liquid_name(); end

  def mass_abbr(); end

  def mass_name(); end

  def volume_abbr(); end

  def volume_name(); end
  AREA_UNITS = ::T.let(nil, ::T.untyped)
  LENGTH_UNITS = ::T.let(nil, ::T.untyped)
  LIQUID_UNITS = ::T.let(nil, ::T.untyped)
  MASS_UNITS = ::T.let(nil, ::T.untyped)
  VOLUME_UNITS = ::T.let(nil, ::T.untyped)
end

module FFaker::UnitMetric
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::UnitMetric
  extend ::FFaker::Unit
end

module FFaker::Vehicle
  def base_color(); end

  def drivetrain(); end

  def engine_cylinders(); end

  def engine_displacement(); end

  def fuel_type(); end

  def interior_upholstery(); end

  def make(); end

  def manufacturer_color(count=T.unsafe(nil)); end

  def mfg_color(count=T.unsafe(nil)); end

  def model(); end

  def transmission(); end

  def transmission_abbr(); end

  def trim(); end

  def vin(); end

  def year(); end
  CYLINDERS = ::T.let(nil, ::T.untyped)
  DRIVETRAINS = ::T.let(nil, ::T.untyped)
  TRANSMISSIONS_ABBR = ::T.let(nil, ::T.untyped)
  YEARS = ::T.let(nil, ::T.untyped)
end

module FFaker::Vehicle
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Vehicle
end

module FFaker::Venue
  def name(); end
end

module FFaker::Venue
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Venue
end

module FFaker::Youtube
  def embed_url(); end

  def share_url(); end

  def url(); end

  def video_id(); end
end

module FFaker::Youtube
  extend ::FFaker::ModuleUtils
  extend ::FFaker::RandomUtils
  extend ::FFaker::Youtube
end

class FSEvent
  VERSION = ::T.let(nil, ::T.untyped)
end

class FalseClass
  include ::JSON::Ext::Generator::GeneratorMethods::FalseClass
end

class Fiber
  def transfer(*_); end
end

class Fiber
  def self.current(); end
end

class File
  def self.atomic_write(file_name, temp_dir=T.unsafe(nil)); end

  def self.exists?(_); end

  def self.probe_stat_in(dir); end
end

FileList = Rake::FileList

module FileUtils
  include ::FileUtils::StreamUtils_
  LN_SUPPORTED = ::T.let(nil, ::T.untyped)
  RUBY = ::T.let(nil, ::T.untyped)
end

module FileUtils::DryRun
  include ::FileUtils
  include ::FileUtils::StreamUtils_
  include ::FileUtils::LowMethods
end

module FileUtils::DryRun
  extend ::FileUtils::DryRun
  extend ::FileUtils
  extend ::FileUtils::StreamUtils_
  extend ::FileUtils::LowMethods
end

module FileUtils::NoWrite
  include ::FileUtils
  include ::FileUtils::StreamUtils_
  include ::FileUtils::LowMethods
end

module FileUtils::NoWrite
  extend ::FileUtils::NoWrite
  extend ::FileUtils
  extend ::FileUtils::StreamUtils_
  extend ::FileUtils::LowMethods
end

module FileUtils::Verbose
  include ::FileUtils
  include ::FileUtils::StreamUtils_
end

module FileUtils::Verbose
  extend ::FileUtils::Verbose
  extend ::FileUtils
  extend ::FileUtils::StreamUtils_
end

module FileUtils
  extend ::FileUtils::StreamUtils_
end

class Float
  include ::JSON::Ext::Generator::GeneratorMethods::Float
end

module Forwardable
  VERSION = ::T.let(nil, ::T.untyped)
end

module Forwardable
  def self._compile_method(src, file, line); end

  def self._delegator_method(obj, accessor, method, ali); end

  def self._valid_method?(method); end

  def self.debug(); end

  def self.debug=(debug); end
end

module GC
  def garbage_collect(*_); end
end

module GC
  def self.verify_transient_heap_internal_consistency(); end
end

module Gem
  ConfigMap = ::T.let(nil, ::T.untyped)
  RbConfigPriorities = ::T.let(nil, ::T.untyped)
  RubyGemsVersion = ::T.let(nil, ::T.untyped)
  UNTAINT = ::T.let(nil, ::T.untyped)
end

class Gem::Exception
  extend ::Gem::Deprecate
end

class Gem::Ext::BuildError
end

class Gem::Ext::BuildError
end

class Gem::Ext::ExtConfBuilder
end

Gem::Ext::ExtConfBuilder::FileEntry = FileUtils::Entry_

class Gem::Ext::ExtConfBuilder
  def self.build(extension, dest_path, results, args=T.unsafe(nil), lib_dir=T.unsafe(nil)); end

  def self.get_relative_path(path); end
end

class Gem::Package
  def gem(); end
end

class Gem::Package::DigestIO
  def digests(); end

  def initialize(io, digests); end

  def write(data); end
end

class Gem::Package::DigestIO
  def self.wrap(io, digests); end
end

class Gem::Package::FileSource
  def initialize(path); end

  def path(); end

  def start(); end

  def with_read_io(&block); end

  def with_write_io(&block); end
end

class Gem::Package::FileSource
end

class Gem::Package::IOSource
  def initialize(io); end

  def io(); end

  def path(); end

  def start(); end

  def with_read_io(); end

  def with_write_io(); end
end

class Gem::Package::IOSource
end

class Gem::Package::Old
  def extract_files(destination_dir); end

  def file_list(io); end

  def read_until_dashes(io); end

  def skip_ruby(io); end
end

class Gem::Package::Old
end

class Gem::Package::Source
end

class Gem::Package::Source
end

class Gem::Package::TarHeader
  def ==(other); end

  def checksum(); end

  def devmajor(); end

  def devminor(); end

  def empty?(); end

  def gid(); end

  def gname(); end

  def initialize(vals); end

  def linkname(); end

  def magic(); end

  def mode(); end

  def mtime(); end

  def name(); end

  def prefix(); end

  def size(); end

  def typeflag(); end

  def uid(); end

  def uname(); end

  def update_checksum(); end

  def version(); end
  EMPTY_HEADER = ::T.let(nil, ::T.untyped)
  FIELDS = ::T.let(nil, ::T.untyped)
  PACK_FORMAT = ::T.let(nil, ::T.untyped)
  UNPACK_FORMAT = ::T.let(nil, ::T.untyped)
end

class Gem::Package::TarHeader
  def self.from(stream); end

  def self.oct_or_256based(str); end

  def self.strict_oct(str); end
end

class Gem::Package::TarReader::Entry
  def bytes_read(); end

  def check_closed(); end

  def close(); end

  def closed?(); end

  def directory?(); end

  def eof?(); end

  def file?(); end

  def full_name(); end

  def getc(); end

  def header(); end

  def initialize(header, io); end

  def length(); end

  def pos(); end

  def read(len=T.unsafe(nil)); end

  def readpartial(maxlen=T.unsafe(nil), outbuf=T.unsafe(nil)); end

  def rewind(); end

  def size(); end

  def symlink?(); end
end

class Gem::Package::TarReader::Entry
end

class Gem::Package::TarReader
  def self.new(io); end
end

class Gem::Package::TarWriter
  def self.new(io); end
end

class Gem::Package
  def self.new(gem, security_policy=T.unsafe(nil)); end

  def self.raw_spec(path, security_policy=T.unsafe(nil)); end
end

class Gem::PathSupport
  def home(); end

  def initialize(env); end

  def path(); end

  def spec_cache_dir(); end
end

class Gem::RemoteFetcher::FetchError
  include ::Gem::UriParsing
  def initialize(message, uri); end

  def uri(); end

  def uri=(uri); end
end

class Gem::RemoteFetcher::FetchError
end

class Gem::RemoteFetcher::UnknownHostError
end

class Gem::RemoteFetcher::UnknownHostError
end

class Gem::Request
  extend ::Gem::UserInteraction
  extend ::Gem::DefaultUserInteraction
  extend ::Gem::Text
end

class Gem::Resolver::CurrentSet
end

class Gem::Resolver::CurrentSet
end

class Gem::Resolver::LocalSpecification
end

class Gem::Resolver::LocalSpecification
end

class Gem::Resolver::Molinillo::DependencyGraph::Log
  def add_edge_no_circular(graph, origin, destination, requirement); end

  def add_vertex(graph, name, payload, root); end

  def delete_edge(graph, origin_name, destination_name, requirement); end

  def detach_vertex_named(graph, name); end

  def each(&blk); end

  def pop!(graph); end

  def reverse_each(); end

  def rewind_to(graph, tag); end

  def set_payload(graph, name, payload); end

  def tag(graph, tag); end
end

class Gem::Resolver::Molinillo::DependencyGraph::Log
  extend ::Enumerable
end

class Gem::RuntimeRequirementNotMetError
  def suggestion(); end

  def suggestion=(suggestion); end
end

class Gem::RuntimeRequirementNotMetError
end

class Gem::Security::Exception
end

class Gem::Security::Exception
end

Gem::Security::KEY_ALGORITHM = OpenSSL::PKey::RSA

class Gem::Security::Policy
  include ::Gem::UserInteraction
  include ::Gem::DefaultUserInteraction
  include ::Gem::Text
  def check_cert(signer, issuer, time); end

  def check_chain(chain, time); end

  def check_data(public_key, digest, signature, data); end

  def check_key(signer, key); end

  def check_root(chain, time); end

  def check_trust(chain, digester, trust_dir); end

  def initialize(name, policy=T.unsafe(nil), opt=T.unsafe(nil)); end

  def name(); end

  def only_signed(); end

  def only_signed=(only_signed); end

  def only_trusted(); end

  def only_trusted=(only_trusted); end

  def subject(certificate); end

  def verify(chain, key=T.unsafe(nil), digests=T.unsafe(nil), signatures=T.unsafe(nil), full_name=T.unsafe(nil)); end

  def verify_chain(); end

  def verify_chain=(verify_chain); end

  def verify_data(); end

  def verify_data=(verify_data); end

  def verify_root(); end

  def verify_root=(verify_root); end

  def verify_signatures(spec, digests, signatures); end

  def verify_signer(); end

  def verify_signer=(verify_signer); end
end

class Gem::Security::Policy
end

class Gem::Security::Signer
  include ::Gem::UserInteraction
  include ::Gem::DefaultUserInteraction
  include ::Gem::Text
  def cert_chain(); end

  def cert_chain=(cert_chain); end

  def digest_algorithm(); end

  def digest_name(); end

  def extract_name(cert); end

  def initialize(key, cert_chain, passphrase=T.unsafe(nil), options=T.unsafe(nil)); end

  def key(); end

  def key=(key); end

  def load_cert_chain(); end

  def options(); end

  def re_sign_key(expiration_length: T.unsafe(nil)); end

  def sign(data); end
end

class Gem::Security::Signer
  def self.re_sign_cert(expired_cert, expired_cert_path, private_key); end
end

class Gem::Security::TrustDir
  def cert_path(certificate); end

  def dir(); end

  def each_certificate(); end

  def initialize(dir, permissions=T.unsafe(nil)); end

  def issuer_of(certificate); end

  def load_certificate(certificate_file); end

  def name_path(name); end

  def trust_cert(certificate); end

  def verify(); end
end

module Gem::Security
  def self.alt_name_or_x509_entry(certificate, x509_entry); end

  def self.create_cert(subject, key, age=T.unsafe(nil), extensions=T.unsafe(nil), serial=T.unsafe(nil)); end

  def self.create_cert_email(email, key, age=T.unsafe(nil), extensions=T.unsafe(nil)); end

  def self.create_cert_self_signed(subject, key, age=T.unsafe(nil), extensions=T.unsafe(nil), serial=T.unsafe(nil)); end

  def self.create_key(length=T.unsafe(nil), algorithm=T.unsafe(nil)); end

  def self.email_to_name(email_address); end

  def self.re_sign(expired_certificate, private_key, age=T.unsafe(nil), extensions=T.unsafe(nil)); end

  def self.reset(); end

  def self.sign(certificate, signing_key, signing_cert, age=T.unsafe(nil), extensions=T.unsafe(nil), serial=T.unsafe(nil)); end

  def self.trust_dir(); end

  def self.trusted_certificates(&block); end

  def self.write(pemmable, path, permissions=T.unsafe(nil), passphrase=T.unsafe(nil), cipher=T.unsafe(nil)); end
end

class Gem::SpecFetcher
  include ::Gem::UserInteraction
  include ::Gem::DefaultUserInteraction
  include ::Gem::Text
  def available_specs(type); end

  def detect(type=T.unsafe(nil)); end

  def initialize(sources=T.unsafe(nil)); end

  def latest_specs(); end

  def prerelease_specs(); end

  def search_for_dependency(dependency, matching_platform=T.unsafe(nil)); end

  def sources(); end

  def spec_for_dependency(dependency, matching_platform=T.unsafe(nil)); end

  def specs(); end

  def suggest_gems_from_name(gem_name, type=T.unsafe(nil)); end

  def tuples_for(source, type, gracefully_ignore=T.unsafe(nil)); end
end

class Gem::SpecFetcher
  def self.fetcher(); end

  def self.fetcher=(fetcher); end
end

class Gem::Specification
  include ::Bundler::MatchPlatform
  include ::Bundler::GemHelpers
  def to_ruby(); end
end

class Gem::Specification
  extend ::Gem::Deprecate
  extend ::Enumerable
end

class Gem::SpecificationPolicy
  include ::Gem::UserInteraction
  include ::Gem::DefaultUserInteraction
  include ::Gem::Text
  def initialize(specification); end

  def packaging(); end

  def packaging=(packaging); end

  def validate(strict=T.unsafe(nil)); end

  def validate_dependencies(); end

  def validate_metadata(); end

  def validate_permissions(); end
  HOMEPAGE_URI_PATTERN = ::T.let(nil, ::T.untyped)
  LAZY = ::T.let(nil, ::T.untyped)
  LAZY_PATTERN = ::T.let(nil, ::T.untyped)
  METADATA_LINK_KEYS = ::T.let(nil, ::T.untyped)
  SPECIAL_CHARACTERS = ::T.let(nil, ::T.untyped)
  VALID_NAME_PATTERN = ::T.let(nil, ::T.untyped)
  VALID_URI_PATTERN = ::T.let(nil, ::T.untyped)
end

class Gem::SpecificationPolicy
end

class Gem::StreamUI
  def _deprecated_debug(statement); end
end

class Gem::StubSpecification
  def build_extensions(); end

  def extensions(); end

  def initialize(filename, base_dir, gems_dir, default_gem); end

  def missing_extensions?(); end

  def valid?(); end
end

class Gem::StubSpecification::StubLine
  def extensions(); end

  def full_name(); end

  def initialize(data, extensions); end

  def name(); end

  def platform(); end

  def require_paths(); end

  def version(); end
end

class Gem::StubSpecification
  def self.default_gemspec_stub(filename, base_dir, gems_dir); end

  def self.gemspec_stub(filename, base_dir, gems_dir); end
end

class Gem::UninstallError
  def spec(); end

  def spec=(spec); end
end

class Gem::UninstallError
end

Gem::UnsatisfiableDepedencyError = Gem::UnsatisfiableDependencyError

Gem::Version::Requirement = Gem::Requirement

module Guard::Deprecated::Dsl
  MORE_INFO_ON_UPGRADING_TO_GUARD_2 = ::T.let(nil, ::T.untyped)
end

module Guard::Deprecated::Dsl::ClassMethods
  EVALUATE_GUARDFILE = ::T.let(nil, ::T.untyped)
end

module Guard::Deprecated::Evaluator
  EVALUATE_GUARDFILE = ::T.let(nil, ::T.untyped)
  REEVALUATE_GUARDFILE = ::T.let(nil, ::T.untyped)
end

module Guard::Deprecated::Guard::ClassMethods
  ADD_GROUP = ::T.let(nil, ::T.untyped)
  ADD_GUARD = ::T.let(nil, ::T.untyped)
  ADD_PLUGIN = ::T.let(nil, ::T.untyped)
  EVALUATE_GUARDFILE = ::T.let(nil, ::T.untyped)
  EVALUATOR = ::T.let(nil, ::T.untyped)
  GET_GUARD_CLASS = ::T.let(nil, ::T.untyped)
  GROUP = ::T.let(nil, ::T.untyped)
  GROUPS = ::T.let(nil, ::T.untyped)
  GUARDS = ::T.let(nil, ::T.untyped)
  GUARD_GEM_NAMES = ::T.let(nil, ::T.untyped)
  LISTENER_ASSIGN = ::T.let(nil, ::T.untyped)
  LOCATE_GUARD = ::T.let(nil, ::T.untyped)
  LOCK = ::T.let(nil, ::T.untyped)
  MORE_INFO_ON_UPGRADING_TO_GUARD_2 = ::T.let(nil, ::T.untyped)
  OPTIONS = ::T.let(nil, ::T.untyped)
  PLUGIN = ::T.let(nil, ::T.untyped)
  PLUGINS = ::T.let(nil, ::T.untyped)
  RESET_EVALUATOR = ::T.let(nil, ::T.untyped)
  RUNNER = ::T.let(nil, ::T.untyped)
  RUNNING = ::T.let(nil, ::T.untyped)
  SCOPE = ::T.let(nil, ::T.untyped)
  SCOPE_ASSIGN = ::T.let(nil, ::T.untyped)
end

module Guard::Deprecated::Watcher::ClassMethods
  MATCH_GUARDFILE = ::T.let(nil, ::T.untyped)
end

class Guard::Dsl
  WARN_INVALID_LOG_LEVEL = ::T.let(nil, ::T.untyped)
  WARN_INVALID_LOG_OPTIONS = ::T.let(nil, ::T.untyped)
end

class Guard::Guardfile::Evaluator
  DEFAULT_GUARDFILES = ::T.let(nil, ::T.untyped)
  ERROR_NO_GUARDFILE = ::T.let(nil, ::T.untyped)
  ERROR_NO_PLUGINS = ::T.let(nil, ::T.untyped)
end

class Guard::Internals::Groups
  DEFAULT_GROUPS = ::T.let(nil, ::T.untyped)
end

class Guard::Internals::Session
  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
end

class Guard::Notifier
  DEPRECATED_IMPLICIT_CONNECT = ::T.let(nil, ::T.untyped)
end

class Guard::Plugin
  TEMPLATE_FORMAT = ::T.let(nil, ::T.untyped)
end

class Guard::PluginUtil
  ERROR_NO_GUARD_OR_CLASS = ::T.let(nil, ::T.untyped)
  INFO_ADDED_GUARD_TO_GUARDFILE = ::T.let(nil, ::T.untyped)
end

class Guard::Runner
  ADDITION_TASKS = ::T.let(nil, ::T.untyped)
  MODIFICATION_TASKS = ::T.let(nil, ::T.untyped)
  PLUGIN_FAILED = ::T.let(nil, ::T.untyped)
  REMOVAL_TASKS = ::T.let(nil, ::T.untyped)
end

module Guard::UI::Colors
  ANSI_ESCAPE_BGBLACK = ::T.let(nil, ::T.untyped)
  ANSI_ESCAPE_BGBLUE = ::T.let(nil, ::T.untyped)
  ANSI_ESCAPE_BGCYAN = ::T.let(nil, ::T.untyped)
  ANSI_ESCAPE_BGGREEN = ::T.let(nil, ::T.untyped)
  ANSI_ESCAPE_BGMAGENTA = ::T.let(nil, ::T.untyped)
  ANSI_ESCAPE_BGRED = ::T.let(nil, ::T.untyped)
  ANSI_ESCAPE_BGWHITE = ::T.let(nil, ::T.untyped)
  ANSI_ESCAPE_BGYELLOW = ::T.let(nil, ::T.untyped)
  ANSI_ESCAPE_BLACK = ::T.let(nil, ::T.untyped)
  ANSI_ESCAPE_BLUE = ::T.let(nil, ::T.untyped)
  ANSI_ESCAPE_BRIGHT = ::T.let(nil, ::T.untyped)
  ANSI_ESCAPE_CYAN = ::T.let(nil, ::T.untyped)
  ANSI_ESCAPE_GREEN = ::T.let(nil, ::T.untyped)
  ANSI_ESCAPE_MAGENTA = ::T.let(nil, ::T.untyped)
  ANSI_ESCAPE_RED = ::T.let(nil, ::T.untyped)
  ANSI_ESCAPE_WHITE = ::T.let(nil, ::T.untyped)
  ANSI_ESCAPE_YELLOW = ::T.let(nil, ::T.untyped)
end

class Guard::UI::Config
  DEFAULTS = ::T.let(nil, ::T.untyped)
  DEPRECATED_OPTS = ::T.let(nil, ::T.untyped)
end

class Guard::UI::Logger::Config
  DEFAULTS = ::T.let(nil, ::T.untyped)
end

module Guard
  extend ::Guard::Internals::Helpers
end

class HTTP::Parser::Error
end

class HTTP::Parser::Error
end

class HTTP::RequestParser
end

class HTTP::RequestParser
end

class HTTP::ResponseParser
end

class HTTP::ResponseParser
end

class Hash
  include ::JSON::Ext::Generator::GeneratorMethods::Hash
end

class Hash
  def self.try_convert(_); end
end

HashWithIndifferentAccess = ActiveSupport::HashWithIndifferentAccess

Http = HTTP

module I18n
  DEFAULT_INTERPOLATION_PATTERNS = ::T.let(nil, ::T.untyped)
  EMPTY_HASH = ::T.let(nil, ::T.untyped)
  INTERPOLATION_PATTERN = ::T.let(nil, ::T.untyped)
  RESERVED_KEYS = ::T.let(nil, ::T.untyped)
  RESERVED_KEYS_PATTERN = ::T.let(nil, ::T.untyped)
  VERSION = ::T.let(nil, ::T.untyped)
end

module I18n::Backend
end

module I18n::Backend::Base
  include ::I18n::Backend::Transliterator
  def available_locales(); end

  def deep_interpolate(locale, data, values=T.unsafe(nil)); end

  def default(locale, object, subject, options=T.unsafe(nil)); end

  def eager_load!(); end

  def eager_loaded?(); end

  def exists?(locale, key, options=T.unsafe(nil)); end

  def interpolate(locale, subject, values=T.unsafe(nil)); end

  def load_file(filename); end

  def load_json(filename); end

  def load_rb(filename); end

  def load_translations(*filenames); end

  def load_yaml(filename); end

  def load_yml(filename); end

  def localize(locale, object, format=T.unsafe(nil), options=T.unsafe(nil)); end

  def lookup(locale, key, scope=T.unsafe(nil), options=T.unsafe(nil)); end

  def pluralization_key(entry, count); end

  def pluralize(locale, entry, count); end

  def reload!(); end

  def resolve(locale, object, subject, options=T.unsafe(nil)); end

  def store_translations(locale, data, options=T.unsafe(nil)); end

  def subtrees?(); end

  def translate(locale, key, options=T.unsafe(nil)); end

  def translate_localization_format(locale, object, format, options); end
end

module I18n::Backend::Base
end

module I18n::Backend::Cache
  def _fetch(cache_key, &block); end

  def cache_key(locale, key, options); end

  def fetch(cache_key, &block); end

  def translate(locale, key, options=T.unsafe(nil)); end
end

module I18n::Backend::Cache
end

module I18n::Backend::CacheFile
  def load_file(filename); end

  def normalized_path(file); end

  def path_roots(); end

  def path_roots=(path_roots); end
end

module I18n::Backend::CacheFile
end

module I18n::Backend::Cascade
  def lookup(locale, key, scope=T.unsafe(nil), options=T.unsafe(nil)); end
end

module I18n::Backend::Cascade
end

module I18n::Backend::Fallbacks
  def exists?(locale, key, options=T.unsafe(nil)); end

  def extract_non_symbol_default!(options); end

  def translate(locale, key, options=T.unsafe(nil)); end
end

module I18n::Backend::Fallbacks
end

module I18n::Backend::Flatten
  def escape_default_separator(key); end

  def find_link(locale, key); end

  def flatten_keys(hash, escape, prev_key=T.unsafe(nil), &block); end

  def flatten_translations(locale, data, escape, subtree); end

  def links(); end

  def normalize_flat_keys(locale, key, scope, separator); end

  def resolve_link(locale, key); end

  def store_link(locale, key, link); end
  FLATTEN_SEPARATOR = ::T.let(nil, ::T.untyped)
  SEPARATOR_ESCAPE_CHAR = ::T.let(nil, ::T.untyped)
end

module I18n::Backend::Flatten
  def self.escape_default_separator(key); end

  def self.normalize_flat_keys(locale, key, scope, separator); end
end

module I18n::Backend::InterpolationCompiler
  def compile_all_strings_in(data); end

  def interpolate(locale, string, values); end

  def store_translations(locale, data, options=T.unsafe(nil)); end
end

module I18n::Backend::InterpolationCompiler::Compiler
  def compile_if_an_interpolation(string); end

  def compile_interpolation_token(key); end

  def compiled_interpolation_body(str); end

  def direct_key(key); end

  def escape_key_sym(key); end

  def escape_plain_str(str); end

  def handle_interpolation_token(interpolation, matchdata); end

  def interpolate_key(key); end

  def interpolate_or_raise_missing(key); end

  def interpolated_str?(str); end

  def missing_key(key); end

  def nil_key(key); end

  def reserved_key(key); end

  def tokenize(str); end
  INTERPOLATION_SYNTAX_PATTERN = ::T.let(nil, ::T.untyped)
  TOKENIZER = ::T.let(nil, ::T.untyped)
end

module I18n::Backend::InterpolationCompiler::Compiler
  extend ::I18n::Backend::InterpolationCompiler::Compiler
end

module I18n::Backend::InterpolationCompiler
end

class I18n::Backend::KeyValue
  include ::I18n::Backend::KeyValue::Implementation
  include ::I18n::Backend::Flatten
  include ::I18n::Backend::Base
  include ::I18n::Backend::Transliterator
end

module I18n::Backend::KeyValue::Implementation
  include ::I18n::Backend::Flatten
  include ::I18n::Backend::Base
  include ::I18n::Backend::Transliterator
  def available_locales(); end

  def init_translations(); end

  def initialize(store, subtrees=T.unsafe(nil)); end

  def initialized?(); end

  def lookup(locale, key, scope=T.unsafe(nil), options=T.unsafe(nil)); end

  def pluralize(locale, entry, count); end

  def store(); end

  def store=(store); end

  def store_translations(locale, data, options=T.unsafe(nil)); end

  def subtrees?(); end

  def translations(); end
end

module I18n::Backend::KeyValue::Implementation
end

class I18n::Backend::KeyValue::SubtreeProxy
  def [](key); end

  def has_key?(key); end

  def initialize(master_key, store); end

  def instance_of?(klass); end

  def is_a?(klass); end

  def kind_of?(klass); end
end

class I18n::Backend::KeyValue::SubtreeProxy
end

class I18n::Backend::KeyValue
end

module I18n::Backend::Memoize
  def available_locales(); end

  def eager_load!(); end

  def lookup(locale, key, scope=T.unsafe(nil), options=T.unsafe(nil)); end

  def memoized_lookup(); end

  def reload!(); end

  def reset_memoizations!(locale=T.unsafe(nil)); end

  def store_translations(locale, data, options=T.unsafe(nil)); end
end

module I18n::Backend::Memoize
end

module I18n::Backend::Metadata
  def interpolate(locale, entry, values=T.unsafe(nil)); end

  def pluralize(locale, entry, count); end

  def translate(locale, key, options=T.unsafe(nil)); end

  def with_metadata(metadata, &block); end
end

module I18n::Backend::Metadata
  def self.included(base); end
end

module I18n::Backend::Pluralization
  def pluralize(locale, entry, count); end

  def pluralizer(locale); end

  def pluralizers(); end
end

module I18n::Backend::Pluralization
end

class I18n::Backend::Simple
  include ::I18n::Backend::Simple::Implementation
  include ::I18n::Backend::Base
  include ::I18n::Backend::Transliterator
end

module I18n::Backend::Simple::Implementation
  include ::I18n::Backend::Base
  include ::I18n::Backend::Transliterator
  def available_locales(); end

  def eager_load!(); end

  def init_translations(); end

  def initialized?(); end

  def lookup(locale, key, scope=T.unsafe(nil), options=T.unsafe(nil)); end

  def reload!(); end

  def store_translations(locale, data, options=T.unsafe(nil)); end

  def translations(do_init: T.unsafe(nil)); end
end

module I18n::Backend::Simple::Implementation
end

class I18n::Backend::Simple
end

module I18n::Backend::Transliterator
  def transliterate(locale, string, replacement=T.unsafe(nil)); end
  DEFAULT_REPLACEMENT_CHAR = ::T.let(nil, ::T.untyped)
end

class I18n::Backend::Transliterator::HashTransliterator
  def initialize(rule=T.unsafe(nil)); end

  def transliterate(string, replacement=T.unsafe(nil)); end
  DEFAULT_APPROXIMATIONS = ::T.let(nil, ::T.untyped)
end

class I18n::Backend::Transliterator::HashTransliterator
end

class I18n::Backend::Transliterator::ProcTransliterator
  def initialize(rule); end

  def transliterate(string, replacement=T.unsafe(nil)); end
end

class I18n::Backend::Transliterator::ProcTransliterator
end

module I18n::Backend::Transliterator
  def self.get(rule=T.unsafe(nil)); end
end

module I18n::Backend
end

module I18n::Gettext
  CONTEXT_SEPARATOR = ::T.let(nil, ::T.untyped)
  PLURAL_SEPARATOR = ::T.let(nil, ::T.untyped)
end

module I18n::Gettext::Helpers
  def N_(msgsid); end

  def _(msgid, options=T.unsafe(nil)); end

  def gettext(msgid, options=T.unsafe(nil)); end

  def n_(msgid, msgid_plural, n=T.unsafe(nil)); end

  def ngettext(msgid, msgid_plural, n=T.unsafe(nil)); end

  def np_(msgctxt, msgid, msgid_plural, n=T.unsafe(nil)); end

  def npgettext(msgctxt, msgid, msgid_plural, n=T.unsafe(nil)); end

  def ns_(msgid, msgid_plural, n=T.unsafe(nil), separator=T.unsafe(nil)); end

  def nsgettext(msgid, msgid_plural, n=T.unsafe(nil), separator=T.unsafe(nil)); end

  def p_(msgctxt, msgid); end

  def pgettext(msgctxt, msgid); end

  def s_(msgid, separator=T.unsafe(nil)); end

  def sgettext(msgid, separator=T.unsafe(nil)); end
end

module I18n::Gettext::Helpers
end

module I18n::Gettext
  def self.extract_scope(msgid, separator); end

  def self.plural_keys(*args); end
end

module I18n::Locale
end

class I18n::Locale::Fallbacks
  def [](locale); end

  def compute(tags, include_defaults=T.unsafe(nil), exclude=T.unsafe(nil)); end

  def defaults(); end

  def defaults=(defaults); end

  def initialize(*mappings); end

  def map(mappings); end
end

class I18n::Locale::Fallbacks
end

module I18n::Locale::Tag
  RFC4646_FORMATS = ::T.let(nil, ::T.untyped)
  RFC4646_SUBTAGS = ::T.let(nil, ::T.untyped)
end

module I18n::Locale::Tag::Parents
  def parent(); end

  def parents(); end

  def self_and_parents(); end
end

module I18n::Locale::Tag::Parents
end

class I18n::Locale::Tag::Rfc4646
  include ::I18n::Locale::Tag::Parents
  def to_sym(); end
end

module I18n::Locale::Tag::Rfc4646::Parser
  PATTERN = ::T.let(nil, ::T.untyped)
end

module I18n::Locale::Tag::Rfc4646::Parser
  def self.match(tag); end
end

class I18n::Locale::Tag::Rfc4646
  def self.parser(); end

  def self.parser=(parser); end

  def self.tag(tag); end
end

class I18n::Locale::Tag::Simple
  include ::I18n::Locale::Tag::Parents
  def initialize(*tag); end

  def subtags(); end

  def tag(); end

  def to_a(); end

  def to_sym(); end
end

class I18n::Locale::Tag::Simple
  def self.tag(tag); end
end

module I18n::Locale::Tag
  def self.implementation(); end

  def self.implementation=(implementation); end

  def self.tag(tag); end
end

module I18n::Locale
end

class I18n::Middleware
  def call(env); end

  def initialize(app); end
end

class I18n::Middleware
end

module I18n::Tests
end

module I18n::Tests::Localization
end

module I18n::Tests::Localization
  def self.included(base); end
end

module I18n::Tests
end

module I18n
  def self.cache_key_digest(); end

  def self.cache_key_digest=(key_digest); end

  def self.cache_namespace(); end

  def self.cache_namespace=(namespace); end

  def self.cache_store(); end

  def self.cache_store=(store); end

  def self.fallbacks(); end

  def self.fallbacks=(fallbacks); end

  def self.perform_caching?(); end
end

class IO
  def beep(); end

  def cooked(); end

  def cooked!(); end

  def cursor(); end

  def cursor=(); end

  def echo=(echo); end

  def echo?(); end

  def getch(*_); end

  def getpass(*_); end

  def goto(); end

  def iflush(); end

  def ioflush(); end

  def noecho(); end

  def nonblock(*_); end

  def nonblock=(nonblock); end

  def nonblock?(); end

  def nread(); end

  def oflush(); end

  def pathconf(_); end

  def pressed?(); end

  def raw(*_); end

  def raw!(*_); end

  def ready?(); end

  def wait(*_); end

  def wait_readable(*_); end

  def wait_writable(*_); end

  def winsize(); end

  def winsize=(winsize); end
end

IO::EWOULDBLOCKWaitReadable = IO::EAGAINWaitReadable

IO::EWOULDBLOCKWaitWritable = IO::EAGAINWaitWritable

class IO
  def self.console(*_); end
end

class IPAddr
  def ==(other); end

  def initialize(addr=T.unsafe(nil), family=T.unsafe(nil)); end
end

module IRB
  IRBRC_EXT = ::T.let(nil, ::T.untyped)
  MagicFile = ::T.let(nil, ::T.untyped)
  STDIN_FILE_NAME = ::T.let(nil, ::T.untyped)
  VERSION = ::T.let(nil, ::T.untyped)
end

class IRB::Context
  def __exit__(*_); end

  def __inspect__(); end

  def __to_s__(); end

  def evaluate(line, line_no, exception: T.unsafe(nil)); end

  def initialize(irb, workspace=T.unsafe(nil), input_method=T.unsafe(nil), output_method=T.unsafe(nil)); end

  def inspect_last_value(); end
  IDNAME_IVARS = ::T.let(nil, ::T.untyped)
  NOPRINTING_IVARS = ::T.let(nil, ::T.untyped)
  NO_INSPECTING_IVARS = ::T.let(nil, ::T.untyped)
end

class IRB::DefaultEncodings
  def external(); end

  def external=(_); end

  def internal(); end

  def internal=(_); end
end

class IRB::DefaultEncodings
  def self.[](*_); end

  def self.members(); end
end

module IRB::ExtendCommandBundle
  def irb(*opts, &b); end

  def irb_change_workspace(*opts, &b); end

  def irb_current_working_workspace(*opts, &b); end

  def irb_fg(*opts, &b); end

  def irb_help(*opts, &b); end

  def irb_jobs(*opts, &b); end

  def irb_kill(*opts, &b); end

  def irb_pop_workspace(*opts, &b); end

  def irb_push_workspace(*opts, &b); end

  def irb_source(*opts, &b); end

  def irb_workspaces(*opts, &b); end
end

IRB::ExtendCommandBundle::EXCB = IRB::ExtendCommandBundle

module IRB::ExtendCommandBundle
  def self.irb_original_method_name(method_name); end
end

class IRB::FileInputMethod
  def initialize(file); end
end

class IRB::InputMethod
  def initialize(file=T.unsafe(nil)); end
end

class IRB::Inspector
  def initialize(inspect_proc, init_proc=T.unsafe(nil)); end
end

class IRB::Irb
  def handle_exception(exc); end

  def initialize(workspace=T.unsafe(nil), input_method=T.unsafe(nil), output_method=T.unsafe(nil)); end

  def output_value(); end

  def prompt(prompt, ltype, indent, line_no); end
end

class IRB::Locale
  def String(mes); end

  def encoding(); end

  def find(file, paths=T.unsafe(nil)); end

  def format(*opts); end

  def gets(*rs); end

  def initialize(locale=T.unsafe(nil)); end

  def lang(); end

  def load(file, priv=T.unsafe(nil)); end

  def modifier(); end

  def print(*opts); end

  def printf(*opts); end

  def puts(*opts); end

  def readline(*rs); end

  def require(file, priv=T.unsafe(nil)); end

  def territory(); end
  LOCALE_DIR = ::T.let(nil, ::T.untyped)
  LOCALE_NAME_RE = ::T.let(nil, ::T.untyped)
end

class IRB::Locale
end

class IRB::Notifier::AbstractNotifier
  def initialize(prefix, base_notifier); end
end

class IRB::Notifier::LeveledNotifier
  def initialize(base, level, prefix); end
end

class IRB::Notifier::NoMsgNotifier
  def initialize(); end
end

class IRB::ReadlineInputMethod
  include ::RbReadline
  def initialize(); end
end

class IRB::SLex
  def Fail(err=T.unsafe(nil), *rest); end

  def Raise(err=T.unsafe(nil), *rest); end

  def create(token, preproc=T.unsafe(nil), postproc=T.unsafe(nil)); end

  def def_rule(token, preproc=T.unsafe(nil), postproc=T.unsafe(nil), &block); end

  def def_rules(*tokens, &block); end

  def match(token); end

  def postproc(token); end

  def preproc(token, proc); end

  def search(token); end
  DOUT = ::T.let(nil, ::T.untyped)
  D_DEBUG = ::T.let(nil, ::T.untyped)
  D_DETAIL = ::T.let(nil, ::T.untyped)
  D_WARN = ::T.let(nil, ::T.untyped)
end

class IRB::SLex::ErrNodeAlreadyExists
end

class IRB::SLex::ErrNodeAlreadyExists
end

class IRB::SLex::ErrNodeNothing
end

class IRB::SLex::ErrNodeNothing
end

class IRB::SLex::Node
  def create_subnode(chrs, preproc=T.unsafe(nil), postproc=T.unsafe(nil)); end

  def initialize(preproc=T.unsafe(nil), postproc=T.unsafe(nil)); end

  def match(chrs, op=T.unsafe(nil)); end

  def match_io(io, op=T.unsafe(nil)); end

  def postproc(); end

  def postproc=(postproc); end

  def preproc(); end

  def preproc=(preproc); end

  def search(chrs, opt=T.unsafe(nil)); end
end

class IRB::SLex::Node
end

class IRB::SLex
  extend ::Exception2MessageMapper
  def self.included(mod); end
end

class IRB::StdioInputMethod
  def initialize(); end
end

class IRB::WorkSpace
  def initialize(*main); end

  def local_variable_get(name); end

  def local_variable_set(name, value); end
end

module IRB
  def self.Inspector(inspect, init=T.unsafe(nil)); end

  def self.delete_caller(); end

  def self.init_config(ap_path); end

  def self.init_error(); end

  def self.load_modules(); end

  def self.parse_opts(argv: T.unsafe(nil)); end

  def self.rc_file(ext=T.unsafe(nil)); end

  def self.rc_file_generators(); end

  def self.run_config(); end

  def self.setup(ap_path, argv: T.unsafe(nil)); end
end

class Integer
  include ::JSON::Ext::Generator::GeneratorMethods::Integer
  def to_bn(); end
end

class JSON::Ext::Generator::State
  def self.from_state(_); end
end

class JSON::Ext::Parser
  def initialize(*_); end
end

JSON::Parser = JSON::Ext::Parser

JSON::State = JSON::Ext::Generator::State

JSON::UnparserError = JSON::GeneratorError

module Kernel
  def itself(); end

  def object_id(); end

  def pretty_inspect(); end

  def then(); end

  def yield_self(); end
end

module Kernel
  def self.at_exit(); end

  def self.load(*_); end

  def self.require(_); end
end

class KeyError
  include ::DidYouMean::Correctable
end

module Kwalify
  META_VALIDATOR = ::T.let(nil, ::T.untyped)
  RELEASE = ::T.let(nil, ::T.untyped)
end

class Kwalify::BaseParser
  CHAR_TABLE = ::T.let(nil, ::T.untyped)
end

class Kwalify::MetaValidator
  META_SCHEMA = ::T.let(nil, ::T.untyped)
end

module Kwalify::Types
  DEFAULT_TYPE = ::T.let(nil, ::T.untyped)
end

module Kwalify::Util::HashLike
  def [](key); end

  def []=(key, val); end

  def each(&blk); end

  def key?(key); end
end

module Kwalify::Util::HashLike
end

class Kwalify::Yaml::Parser
  MAPKEY_PATTERN = ::T.let(nil, ::T.untyped)
  PRECEDING_ALIAS_PLACEHOLDER = ::T.let(nil, ::T.untyped)
end

module Listen
  VERSION = ::T.let(nil, ::T.untyped)
end

module Listen::Adapter
  OPTIMIZED_ADAPTERS = ::T.let(nil, ::T.untyped)
  POLLING_FALLBACK_MESSAGE = ::T.let(nil, ::T.untyped)
end

class Listen::Adapter::BSD
  BUNDLER_DECLARE_GEM = ::T.let(nil, ::T.untyped)
  DEFAULTS = ::T.let(nil, ::T.untyped)
  OS_REGEXP = ::T.let(nil, ::T.untyped)
end

class Listen::Adapter::Base
  DEFAULTS = ::T.let(nil, ::T.untyped)
end

class Listen::Adapter::Darwin
  DEFAULTS = ::T.let(nil, ::T.untyped)
  INCOMPATIBLE_GEM_VERSION = ::T.let(nil, ::T.untyped)
  OS_REGEXP = ::T.let(nil, ::T.untyped)
end

class Listen::Adapter::Linux
  DEFAULTS = ::T.let(nil, ::T.untyped)
  INOTIFY_LIMIT_MESSAGE = ::T.let(nil, ::T.untyped)
  OS_REGEXP = ::T.let(nil, ::T.untyped)
  WIKI_URL = ::T.let(nil, ::T.untyped)
end

class Listen::Adapter::Polling
  DEFAULTS = ::T.let(nil, ::T.untyped)
  OS_REGEXP = ::T.let(nil, ::T.untyped)
end

class Listen::Adapter::Windows
  BUNDLER_DECLARE_GEM = ::T.let(nil, ::T.untyped)
  OS_REGEXP = ::T.let(nil, ::T.untyped)
end

module Listen::FSM
  DEFAULT_STATE = ::T.let(nil, ::T.untyped)
end

class Listen::Listener::Config
  DEFAULTS = ::T.let(nil, ::T.untyped)
end

class Listen::Record::SymlinkDetector
  SYMLINK_LOOP_ERROR = ::T.let(nil, ::T.untyped)
  WIKI = ::T.let(nil, ::T.untyped)
end

class Listen::Silencer
  DEFAULT_IGNORED_DIRECTORIES = ::T.let(nil, ::T.untyped)
  DEFAULT_IGNORED_EXTENSIONS = ::T.let(nil, ::T.untyped)
end

class Logger
  SEV_LABEL = ::T.let(nil, ::T.untyped)
end

class Logger::Formatter
  Format = ::T.let(nil, ::T.untyped)
end

class Logger::LogDevice
  include ::MonitorMixin
end

module Logger::Period
  SiD = ::T.let(nil, ::T.untyped)
end

module Lumberjack
  LINE_SEPARATOR = ::T.let(nil, ::T.untyped)
end

class Lumberjack::Device::LogFile
  EXTERNAL_ENCODING = ::T.let(nil, ::T.untyped)
end

class Lumberjack::Device::Writer
  DEFAULT_ADDITIONAL_LINES_TEMPLATE = ::T.let(nil, ::T.untyped)
  DEFAULT_FIRST_LINE_TEMPLATE = ::T.let(nil, ::T.untyped)
end

class Lumberjack::LogEntry
  TIME_FORMAT = ::T.let(nil, ::T.untyped)
  UNIT_OF_WORK_ID = ::T.let(nil, ::T.untyped)
end

class Lumberjack::Rack::RequestId
  REQUEST_ID = ::T.let(nil, ::T.untyped)
end

module Lumberjack::Severity
  DEBUG = ::T.let(nil, ::T.untyped)
  ERROR = ::T.let(nil, ::T.untyped)
  FATAL = ::T.let(nil, ::T.untyped)
  INFO = ::T.let(nil, ::T.untyped)
  SEVERITY_LABELS = ::T.let(nil, ::T.untyped)
  UNKNOWN = ::T.let(nil, ::T.untyped)
  WARN = ::T.let(nil, ::T.untyped)
end

class Lumberjack::TaggedLoggerSupport::Formatter
  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
end

class Lumberjack::Template
  MICROSECOND_TIME_FORMAT = ::T.let(nil, ::T.untyped)
  MILLISECOND_TIME_FORMAT = ::T.let(nil, ::T.untyped)
  PLACEHOLDER_PATTERN = ::T.let(nil, ::T.untyped)
  TEMPLATE_ARGUMENT_ORDER = ::T.let(nil, ::T.untyped)
end

module Marshal
  extend ::ActiveSupport::MarshalWithAutoloading
end

module MethodSource
  VERSION = ::T.let(nil, ::T.untyped)
end

module MethodSource::CodeHelpers::IncompleteExpression
  GENERIC_REGEXPS = ::T.let(nil, ::T.untyped)
  RBX_ONLY_REGEXPS = ::T.let(nil, ::T.untyped)
end

module Minitest::Assertions
  def _synchronize(); end

  def assert_in_delta(exp, act, delta=T.unsafe(nil), msg=T.unsafe(nil)); end

  def assert_in_epsilon(exp, act, epsilon=T.unsafe(nil), msg=T.unsafe(nil)); end

  def assert_instance_of(cls, obj, msg=T.unsafe(nil)); end

  def assert_kind_of(cls, obj, msg=T.unsafe(nil)); end

  def assert_match(matcher, obj, msg=T.unsafe(nil)); end

  def assert_operator(o1, op, o2=T.unsafe(nil), msg=T.unsafe(nil)); end

  def assert_output(stdout=T.unsafe(nil), stderr=T.unsafe(nil)); end

  def assert_path_exists(path, msg=T.unsafe(nil)); end

  def assert_predicate(o1, op, msg=T.unsafe(nil)); end

  def assert_respond_to(obj, meth, msg=T.unsafe(nil)); end

  def assert_same(exp, act, msg=T.unsafe(nil)); end

  def assert_send(send_ary, m=T.unsafe(nil)); end

  def assert_silent(); end

  def assert_throws(sym, msg=T.unsafe(nil)); end

  def capture_io(); end

  def capture_subprocess_io(); end

  def diff(exp, act); end

  def exception_details(e, msg); end

  def fail_after(y, m, d, msg); end

  def flunk(msg=T.unsafe(nil)); end

  def message(msg=T.unsafe(nil), ending=T.unsafe(nil), &default); end

  def mu_pp(obj); end

  def mu_pp_for_diff(obj); end

  def pass(_msg=T.unsafe(nil)); end

  def refute_in_delta(exp, act, delta=T.unsafe(nil), msg=T.unsafe(nil)); end

  def refute_in_epsilon(a, b, epsilon=T.unsafe(nil), msg=T.unsafe(nil)); end

  def refute_instance_of(cls, obj, msg=T.unsafe(nil)); end

  def refute_kind_of(cls, obj, msg=T.unsafe(nil)); end

  def refute_match(matcher, obj, msg=T.unsafe(nil)); end

  def refute_operator(o1, op, o2=T.unsafe(nil), msg=T.unsafe(nil)); end

  def refute_path_exists(path, msg=T.unsafe(nil)); end

  def refute_predicate(o1, op, msg=T.unsafe(nil)); end

  def refute_respond_to(obj, meth, msg=T.unsafe(nil)); end

  def refute_same(exp, act, msg=T.unsafe(nil)); end

  def skip(msg=T.unsafe(nil), bt=T.unsafe(nil)); end

  def skip_until(y, m, d, msg); end

  def skipped?(); end

  def things_to_diff(exp, act); end
  E = ::T.let(nil, ::T.untyped)
  UNDEFINED = ::T.let(nil, ::T.untyped)
end

module Minitest::Assertions
  def self.diff(); end

  def self.diff=(o); end
end

module Minitest::Guard
  def jruby?(platform=T.unsafe(nil)); end

  def maglev?(platform=T.unsafe(nil)); end

  def mri?(platform=T.unsafe(nil)); end

  def osx?(platform=T.unsafe(nil)); end

  def rubinius?(platform=T.unsafe(nil)); end

  def windows?(platform=T.unsafe(nil)); end
end

module Minitest::Guard
end

module Minitest::Reportable
  def class_name(); end

  def error?(); end

  def location(); end

  def passed?(); end

  def result_code(); end

  def skipped?(); end
end

module Minitest::Reportable
end

class Minitest::Runnable
  def assertions(); end

  def assertions=(assertions); end

  def failure(); end

  def failures(); end

  def failures=(failures); end

  def initialize(name); end

  def marshal_dump(); end

  def marshal_load(ary); end

  def name(); end

  def name=(o); end

  def passed?(); end

  def result_code(); end

  def run(); end

  def skipped?(); end

  def time(); end

  def time=(time); end

  def time_it(); end
  SIGNALS = ::T.let(nil, ::T.untyped)
end

class Minitest::Runnable
  def self.inherited(klass); end

  def self.methods_matching(re); end

  def self.on_signal(name, action); end

  def self.reset(); end

  def self.run(reporter, options=T.unsafe(nil)); end

  def self.run_one_method(klass, method_name, reporter); end

  def self.runnable_methods(); end

  def self.runnables(); end

  def self.with_info_handler(reporter, &block); end
end

class Minitest::Test
  include ::Minitest::Reportable
  include ::Minitest::Test::LifecycleHooks
  include ::Minitest::Guard
  def capture_exceptions(); end

  def with_info_handler(&block); end
  PASSTHROUGH_EXCEPTIONS = ::T.let(nil, ::T.untyped)
  TEARDOWN_METHODS = ::T.let(nil, ::T.untyped)
end

module Minitest::Test::LifecycleHooks
  def after_setup(); end

  def after_teardown(); end

  def before_setup(); end

  def before_teardown(); end

  def setup(); end

  def teardown(); end
end

module Minitest::Test::LifecycleHooks
end

class Minitest::Test
  extend ::Minitest::Guard
  def self.i_suck_and_my_tests_are_order_dependent!(); end

  def self.io_lock(); end

  def self.io_lock=(io_lock); end

  def self.make_my_diffs_pretty!(); end

  def self.parallelize_me!(); end

  def self.test_order(); end
end

class Module
  DELEGATION_RESERVED_KEYWORDS = ::T.let(nil, ::T.untyped)
  DELEGATION_RESERVED_METHOD_NAMES = ::T.let(nil, ::T.untyped)
  RUBY_RESERVED_KEYWORDS = ::T.let(nil, ::T.untyped)
end

class Monitor
  def enter(); end

  def exit(); end

  def try_enter(); end
end

module MonitorMixin
  def initialize(*args); end
  EXCEPTION_IMMEDIATE = ::T.let(nil, ::T.untyped)
  EXCEPTION_NEVER = ::T.let(nil, ::T.untyped)
end

class MonitorMixin::ConditionVariable
  def initialize(monitor); end
end

module MultiJson
  ALIASES = ::T.let(nil, ::T.untyped)
  REQUIREMENT_MAP = ::T.let(nil, ::T.untyped)
  VERSION = ::T.let(nil, ::T.untyped)
end

MultiJson::DecodeError = MultiJson::ParseError

MultiJson::LoadError = MultiJson::ParseError

module MultiJson::OptionsCache
  MAX_CACHE_SIZE = ::T.let(nil, ::T.untyped)
end

class MultiJson::Version
  MAJOR = ::T.let(nil, ::T.untyped)
  MINOR = ::T.let(nil, ::T.untyped)
  PATCH = ::T.let(nil, ::T.untyped)
  PRE = ::T.let(nil, ::T.untyped)
end

module Mutex_m
  VERSION = ::T.let(nil, ::T.untyped)
end

class NameError
  include ::DidYouMean::Correctable
end

module Nenv
  VERSION = ::T.let(nil, ::T.untyped)
end

class Net::BufferedIO
  def write_timeout(); end

  def write_timeout=(write_timeout); end
end

class Net::HTTP
  def max_retries(); end

  def max_retries=(retries); end

  def max_version(); end

  def max_version=(max_version); end

  def min_version(); end

  def min_version=(min_version); end

  def write_timeout(); end

  def write_timeout=(sec); end
  ENVIRONMENT_VARIABLE_IS_MULTIUSER_SAFE = ::T.let(nil, ::T.untyped)
end

class Net::HTTPAlreadyReported
  HAS_BODY = ::T.let(nil, ::T.untyped)
end

class Net::HTTPAlreadyReported
end

Net::HTTPClientError::EXCEPTION_TYPE = Net::HTTPServerException

Net::HTTPClientErrorCode = Net::HTTPClientError

Net::HTTPClientException = Net::HTTPServerException

class Net::HTTPEarlyHints
  HAS_BODY = ::T.let(nil, ::T.untyped)
end

class Net::HTTPEarlyHints
end

Net::HTTPFatalErrorCode = Net::HTTPClientError

class Net::HTTPGatewayTimeout
  HAS_BODY = ::T.let(nil, ::T.untyped)
end

class Net::HTTPGatewayTimeout
end

class Net::HTTPInformation
end

Net::HTTPInformationCode::EXCEPTION_TYPE = Net::HTTPError

class Net::HTTPInformation
end

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

class Net::HTTPRequestTimeout
  HAS_BODY = ::T.let(nil, ::T.untyped)
end

class Net::HTTPRequestTimeout
end

Net::HTTPRequestURITooLarge = Net::HTTPURITooLong

Net::HTTPResponceReceiver = Net::HTTPResponse

Net::HTTPRetriableCode = Net::HTTPRedirection

Net::HTTPServerError::EXCEPTION_TYPE = Net::HTTPFatalError

Net::HTTPServerErrorCode = Net::HTTPServerError

Net::HTTPSession = Net::HTTP

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::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
  def to_d(); end
end

class Notiffany::Notifier
  NOTIFICATIONS_DISABLED = ::T.let(nil, ::T.untyped)
  ONLY_NOTIFY = ::T.let(nil, ::T.untyped)
  SUPPORTED = ::T.let(nil, ::T.untyped)
  USING_NOTIFIER = ::T.let(nil, ::T.untyped)
end

class Notiffany::Notifier::Base
  ERROR_ADD_GEM_AND_RUN_BUNDLE = ::T.let(nil, ::T.untyped)
  HOSTS = ::T.let(nil, ::T.untyped)
end

class Notiffany::Notifier::Config
  DEFAULTS = ::T.let(nil, ::T.untyped)
end

class Notiffany::Notifier::Detected
  NO_SUPPORTED_NOTIFIERS = ::T.let(nil, ::T.untyped)
end

class Notiffany::Notifier::Emacs
  DEFAULTS = ::T.let(nil, ::T.untyped)
  DEFAULT_ELISP_ERB = ::T.let(nil, ::T.untyped)
end

class Notiffany::Notifier::File
  DEFAULTS = ::T.let(nil, ::T.untyped)
end

class Notiffany::Notifier::GNTP
  CLIENT_DEFAULTS = ::T.let(nil, ::T.untyped)
  DEFAULTS = ::T.let(nil, ::T.untyped)
end

class Notiffany::Notifier::Growl
  DEFAULTS = ::T.let(nil, ::T.untyped)
  INSTALL_GROWLNOTIFY = ::T.let(nil, ::T.untyped)
end

class Notiffany::Notifier::Libnotify
  DEFAULTS = ::T.let(nil, ::T.untyped)
end

class Notiffany::Notifier::Notifu
  DEFAULTS = ::T.let(nil, ::T.untyped)
end

class Notiffany::Notifier::NotifySend
  DEFAULTS = ::T.let(nil, ::T.untyped)
  SUPPORTED = ::T.let(nil, ::T.untyped)
end

class Notiffany::Notifier::TerminalNotifier
  DEFAULTS = ::T.let(nil, ::T.untyped)
  ERROR_ONLY_OSX10 = ::T.let(nil, ::T.untyped)
end

class Notiffany::Notifier::TerminalTitle
  DEFAULTS = ::T.let(nil, ::T.untyped)
end

class Notiffany::Notifier::Tmux
  DEFAULTS = ::T.let(nil, ::T.untyped)
  ERROR_ANCIENT_TMUX = ::T.let(nil, ::T.untyped)
  ERROR_NOT_INSIDE_TMUX = ::T.let(nil, ::T.untyped)
end

class Notiffany::Notifier::Tmux::Client
  CLIENT = ::T.let(nil, ::T.untyped)
end

class Object
  include ::JSON::Ext::Generator::GeneratorMethods::Object
  include ::PP::ObjectMixin
  include ::ActiveSupport::ToJsonWithActiveSupportEncoder
  def as_json(options=T.unsafe(nil)); end

  def html_safe?(); end

  def to_yaml(options=T.unsafe(nil)); end
  ARGF = ::T.let(nil, ::T.untyped)
  ARGV = ::T.let(nil, ::T.untyped)
  CROSS_COMPILING = ::T.let(nil, ::T.untyped)
  ENV = ::T.let(nil, ::T.untyped)
  RUBY_COPYRIGHT = ::T.let(nil, ::T.untyped)
  RUBY_DESCRIPTION = ::T.let(nil, ::T.untyped)
  RUBY_ENGINE = ::T.let(nil, ::T.untyped)
  RUBY_ENGINE_VERSION = ::T.let(nil, ::T.untyped)
  RUBY_PATCHLEVEL = ::T.let(nil, ::T.untyped)
  RUBY_PLATFORM = ::T.let(nil, ::T.untyped)
  RUBY_RELEASE_DATE = ::T.let(nil, ::T.untyped)
  RUBY_REVISION = ::T.let(nil, ::T.untyped)
  RUBY_VERSION = ::T.let(nil, ::T.untyped)
  STDERR = ::T.let(nil, ::T.untyped)
  STDIN = ::T.let(nil, ::T.untyped)
  STDOUT = ::T.let(nil, ::T.untyped)
  TOPLEVEL_BINDING = ::T.let(nil, ::T.untyped)
end

class Object
  def self.yaml_tag(url); end
end

class OpenSSL::ASN1::ASN1Data
  def indefinite_length(); end

  def indefinite_length=(indefinite_length); end
end

class OpenSSL::BN
  def +@(); end

  def -@(); end

  def /(_); end

  def negative?(); end
end

module OpenSSL::Buffering
  include ::ActiveSupport::ToJsonWithActiveSupportEncoder
end

module OpenSSL::KDF
end

class OpenSSL::KDF::KDFError
end

class OpenSSL::KDF::KDFError
end

module OpenSSL::KDF
  def self.hkdf(*_); end

  def self.pbkdf2_hmac(*_); end

  def self.scrypt(*_); end
end

class OpenSSL::OCSP::Request
  def signed?(); end
end

OpenSSL::PKCS7::Signer = OpenSSL::PKCS7::SignerInfo

class OpenSSL::PKey::EC
  EXPLICIT_CURVE = ::T.let(nil, ::T.untyped)
end

class OpenSSL::PKey::EC::Point
  def to_octet_string(_); end
end

module OpenSSL::SSL
  OP_ALLOW_NO_DHE_KEX = ::T.let(nil, ::T.untyped)
  OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION = ::T.let(nil, ::T.untyped)
  OP_CRYPTOPRO_TLSEXT_BUG = ::T.let(nil, ::T.untyped)
  OP_LEGACY_SERVER_CONNECT = ::T.let(nil, ::T.untyped)
  OP_NO_ENCRYPT_THEN_MAC = ::T.let(nil, ::T.untyped)
  OP_NO_RENEGOTIATION = ::T.let(nil, ::T.untyped)
  OP_NO_TLSv1_3 = ::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 add_certificate(*_); end

  def alpn_protocols(); end

  def alpn_protocols=(alpn_protocols); end

  def alpn_select_cb(); end

  def alpn_select_cb=(alpn_select_cb); end

  def enable_fallback_scsv(); end

  def max_version=(version); end

  def min_version=(version); end
  DEFAULT_TMP_DH_CALLBACK = ::T.let(nil, ::T.untyped)
end

class OpenSSL::SSL::SSLSocket
  def alpn_protocol(); end

  def tmp_key(); end
end

module OpenSSL::X509
  V_FLAG_NO_CHECK_TIME = ::T.let(nil, ::T.untyped)
  V_FLAG_TRUSTED_FIRST = ::T.let(nil, ::T.untyped)
end

class OpenSSL::X509::Attribute
  def ==(other); end
end

class OpenSSL::X509::CRL
  def ==(other); end
end

class OpenSSL::X509::Extension
  def ==(other); end
end

class OpenSSL::X509::Name
  def to_utf8(); end
end

class OpenSSL::X509::Request
  def ==(other); end
end

class OpenSSL::X509::Revoked
  def ==(other); end

  def to_der(); end
end

module OpenSSL
  def self.fips_mode(); end
end

module Parallel
  Stop = ::T.let(nil, ::T.untyped)
  VERSION = ::T.let(nil, ::T.untyped)
  Version = ::T.let(nil, ::T.untyped)
end

class Parallel::UserInterruptHandler
  INTERRUPT_SIGNAL = ::T.let(nil, ::T.untyped)
end

ParseError = Racc::ParseError

module Parser
  MESSAGES = ::T.let(nil, ::T.untyped)
  VERSION = ::T.let(nil, ::T.untyped)
end

Parser::CurrentRuby = Parser::Ruby26

class Parser::Diagnostic
  LEVELS = ::T.let(nil, ::T.untyped)
end

class Parser::Lexer
  ESCAPES = ::T.let(nil, ::T.untyped)
  KEYWORDS = ::T.let(nil, ::T.untyped)
  KEYWORDS_BEGIN = ::T.let(nil, ::T.untyped)
  LEX_STATES = ::T.let(nil, ::T.untyped)
  PUNCTUATION = ::T.let(nil, ::T.untyped)
  PUNCTUATION_BEGIN = ::T.let(nil, ::T.untyped)
  REGEXP_META_CHARACTERS = ::T.let(nil, ::T.untyped)
end

class Parser::Lexer::Dedenter
  TAB_WIDTH = ::T.let(nil, ::T.untyped)
end

class Parser::Lexer::Literal
  DELIMITERS = ::T.let(nil, ::T.untyped)
  TYPES = ::T.let(nil, ::T.untyped)
end

module Parser::Meta
  NODE_TYPES = ::T.let(nil, ::T.untyped)
end

class Parser::Rewriter
  DEPRECATION_WARNING = ::T.let(nil, ::T.untyped)
end

class Parser::Ruby24
  Racc_arg = ::T.let(nil, ::T.untyped)
  Racc_debug_parser = ::T.let(nil, ::T.untyped)
  Racc_token_to_s_table = ::T.let(nil, ::T.untyped)
end

class Parser::Ruby26
  Racc_arg = ::T.let(nil, ::T.untyped)
  Racc_debug_parser = ::T.let(nil, ::T.untyped)
  Racc_token_to_s_table = ::T.let(nil, ::T.untyped)
end

class Parser::Source::Buffer
  ENCODING_RE = ::T.let(nil, ::T.untyped)
end

class Parser::Source::Comment::Associator
  MAGIC_COMMENT_RE = ::T.let(nil, ::T.untyped)
  POSTFIX_TYPES = ::T.let(nil, ::T.untyped)
end

class Parser::Source::Rewriter
  DEPRECATION_WARNING = ::T.let(nil, ::T.untyped)
end

class Parser::Source::TreeRewriter
  ACTIONS = ::T.let(nil, ::T.untyped)
  DEPRECATION_WARNING = ::T.let(nil, ::T.untyped)
  POLICY_TO_LEVEL = ::T.let(nil, ::T.untyped)
end

class Parser::StaticEnvironment
  FORWARD_ARGS = ::T.let(nil, ::T.untyped)
end

class Pathname
  def fnmatch?(*_); end

  def glob(*_); end

  def make_symlink(_); end
end

class Proc
  def <<(_); end

  def >>(_); end

  def clone(); end
end

class ProgressBar::Components::Bar
  DEFAULT_PROGRESS_MARK = ::T.let(nil, ::T.untyped)
  DEFAULT_REMAINDER_MARK = ::T.let(nil, ::T.untyped)
  DEFAULT_UPA_STEPS = ::T.let(nil, ::T.untyped)
end

class ProgressBar::Components::Time
  ELAPSED_LABEL = ::T.let(nil, ::T.untyped)
  ESTIMATED_LABEL = ::T.let(nil, ::T.untyped)
  NO_TIME_ELAPSED_TEXT = ::T.let(nil, ::T.untyped)
  OOB_FRIENDLY_TIME_TEXT = ::T.let(nil, ::T.untyped)
  OOB_LIMIT_IN_HOURS = ::T.let(nil, ::T.untyped)
  OOB_TIME_FORMATS = ::T.let(nil, ::T.untyped)
  OOB_UNKNOWN_TIME_TEXT = ::T.let(nil, ::T.untyped)
  TIME_FORMAT = ::T.let(nil, ::T.untyped)
end

class ProgressBar::Components::Title
  DEFAULT_TITLE = ::T.let(nil, ::T.untyped)
end

class ProgressBar::Format::Molecule
  BAR_MOLECULES = ::T.let(nil, ::T.untyped)
  MOLECULES = ::T.let(nil, ::T.untyped)
end

class ProgressBar::Format::String
  ANSI_SGR_PATTERN = ::T.let(nil, ::T.untyped)
  MOLECULE_PATTERN = ::T.let(nil, ::T.untyped)
end

class ProgressBar::Output
  DEFAULT_OUTPUT_STREAM = ::T.let(nil, ::T.untyped)
end

class ProgressBar::Outputs::NonTty
  DEFAULT_FORMAT_STRING = ::T.let(nil, ::T.untyped)
end

class ProgressBar::Outputs::Tty
  DEFAULT_FORMAT_STRING = ::T.let(nil, ::T.untyped)
end

class ProgressBar::Progress
  DEFAULT_BEGINNING_POSITION = ::T.let(nil, ::T.untyped)
  DEFAULT_SMOOTHING = ::T.let(nil, ::T.untyped)
  DEFAULT_TOTAL = ::T.let(nil, ::T.untyped)
end

class ProgressBar::Time
  TIME_MOCKING_LIBRARY_METHODS = ::T.let(nil, ::T.untyped)
end

class Pry
  BINDING_METHOD_IMPL = ::T.let(nil, ::T.untyped)
  Commands = ::T.let(nil, ::T.untyped)
  EMPTY_COMPLETIONS = ::T.let(nil, ::T.untyped)
  HAS_SAFE_LEVEL = ::T.let(nil, ::T.untyped)
  LOCAL_RC_FILE = ::T.let(nil, ::T.untyped)
  VERSION = ::T.let(nil, ::T.untyped)
end

class Pry::BasicObject
  ENV = ::T.let(nil, ::T.untyped)
end

Pry::BasicObject::Dir = Dir

Pry::BasicObject::File = File

Pry::BasicObject::Kernel = Kernel

Pry::BasicObject::LoadError = LoadError

Pry::BasicObject::Pry = Pry

class Pry::Byebug::Breakpoints::FileBreakpoint
  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
end

class Pry::Byebug::Breakpoints::MethodBreakpoint
  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
end

class Pry::Code
  extend ::MethodSource::CodeHelpers
end

class Pry::CodeFile
  DEFAULT_EXT = ::T.let(nil, ::T.untyped)
  EXTENSIONS = ::T.let(nil, ::T.untyped)
  FILES = ::T.let(nil, ::T.untyped)
  INITIAL_PWD = ::T.let(nil, ::T.untyped)
end

class Pry::Command
  VOID_VALUE = ::T.let(nil, ::T.untyped)
end

class Pry::Command::Ls
  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
end

class Pry::Command::Ls::Constants
  DEPRECATED_CONSTANTS = ::T.let(nil, ::T.untyped)
end

class Pry::Command::Ls::Globals
  BUILTIN_GLOBALS = ::T.let(nil, ::T.untyped)
  PSEUDO_GLOBALS = ::T.let(nil, ::T.untyped)
end

class Pry::Command::Wtf
  RUBY_FRAME_PATTERN = ::T.let(nil, ::T.untyped)
end

module Pry::Helpers::DocumentationHelpers
  YARD_TAGS = ::T.let(nil, ::T.untyped)
end

module Pry::Helpers::Text
  COLORS = ::T.let(nil, ::T.untyped)
end

class Pry::Indent
  IGNORE_TOKENS = ::T.let(nil, ::T.untyped)
  MIDWAY_TOKENS = ::T.let(nil, ::T.untyped)
  OPEN_TOKENS = ::T.let(nil, ::T.untyped)
  OPTIONAL_DO_TOKENS = ::T.let(nil, ::T.untyped)
  SINGLELINE_TOKENS = ::T.let(nil, ::T.untyped)
  SPACES = ::T.let(nil, ::T.untyped)
  STATEMENT_END_TOKENS = ::T.let(nil, ::T.untyped)
end

class Pry::InputCompleter
  ARRAY_REGEXP = ::T.let(nil, ::T.untyped)
  CONSTANT_OR_METHOD_REGEXP = ::T.let(nil, ::T.untyped)
  CONSTANT_REGEXP = ::T.let(nil, ::T.untyped)
  GLOBALVARIABLE_REGEXP = ::T.let(nil, ::T.untyped)
  HEX_REGEXP = ::T.let(nil, ::T.untyped)
  NUMERIC_REGEXP = ::T.let(nil, ::T.untyped)
  PROC_OR_HASH_REGEXP = ::T.let(nil, ::T.untyped)
  REGEX_REGEXP = ::T.let(nil, ::T.untyped)
  RESERVED_WORDS = ::T.let(nil, ::T.untyped)
  SYMBOL_METHOD_CALL_REGEXP = ::T.let(nil, ::T.untyped)
  SYMBOL_REGEXP = ::T.let(nil, ::T.untyped)
  TOPLEVEL_LOOKUP_REGEXP = ::T.let(nil, ::T.untyped)
  VARIABLE_REGEXP = ::T.let(nil, ::T.untyped)
  WORD_ESCAPE_STR = ::T.let(nil, ::T.untyped)
end

class Pry::Inspector
  MAP = ::T.let(nil, ::T.untyped)
end

class Pry::ObjectPath
  SPECIAL_TERMS = ::T.let(nil, ::T.untyped)
end

class Pry::Output
  DEFAULT_SIZE = ::T.let(nil, ::T.untyped)
end

class Pry::PluginManager
  PRY_PLUGIN_PREFIX = ::T.let(nil, ::T.untyped)
end

class Pry::Slop
  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
  VERSION = ::T.let(nil, ::T.untyped)
end

class Pry::Slop::Option
  DEFAULT_OPTIONS = ::T.let(nil, ::T.untyped)
end

module Psych
  VERSION = ::T.let(nil, ::T.untyped)
end

module Psych
  def self.add_builtin_type(type_tag, &block); end

  def self.add_domain_type(domain, type_tag, &block); end

  def self.add_tag(tag, klass); end

  def self.domain_types(); end

  def self.domain_types=(domain_types); end

  def self.dump_tags(); end

  def self.dump_tags=(dump_tags); end

  def self.libyaml_version(); end

  def self.load_tags(); end

  def self.load_tags=(load_tags); end

  def self.remove_type(type_tag); end
end

class REXML::Parsers::BaseParser
  QNAME = ::T.let(nil, ::T.untyped)
  QNAME_STR = ::T.let(nil, ::T.untyped)
end

class REXML::Parsers::XPathParser
  LOCAL_NAME_WILDCARD = ::T.let(nil, ::T.untyped)
  PREFIX_WILDCARD = ::T.let(nil, ::T.untyped)
end

class REXML::XPathParser
  DEBUG = ::T.let(nil, ::T.untyped)
end

module RSpec
  MODULES_TO_AUTOLOAD = ::T.let(nil, ::T.untyped)
end

class RSpec::CallerFilter
  ADDITIONAL_TOP_LEVEL_FILES = ::T.let(nil, ::T.untyped)
  IGNORE_REGEX = ::T.let(nil, ::T.untyped)
  LIB_REGEX = ::T.let(nil, ::T.untyped)
  RSPEC_LIBS = ::T.let(nil, ::T.untyped)
end

class RSpec::Core::Configuration
  DEFAULT_FORMATTER = ::T.let(nil, ::T.untyped)
  FAILED_STATUS = ::T.let(nil, ::T.untyped)
  MOCKING_ADAPTERS = ::T.let(nil, ::T.untyped)
  PASSED_STATUS = ::T.let(nil, ::T.untyped)
  PENDING_STATUS = ::T.let(nil, ::T.untyped)
  RAISE_ERROR_WARNING_NOTIFIER = ::T.let(nil, ::T.untyped)
  UNKNOWN_STATUS = ::T.let(nil, ::T.untyped)
  VALID_STATUSES = ::T.let(nil, ::T.untyped)
end

class RSpec::Core::ConfigurationOptions
  OPTIONS_ORDER = ::T.let(nil, ::T.untyped)
  UNFORCED_OPTIONS = ::T.let(nil, ::T.untyped)
  UNPROCESSABLE_OPTIONS = ::T.let(nil, ::T.untyped)
end

RSpec::Core::Example::AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt = RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue

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
  INSTANCE_VARIABLE_TO_IGNORE = ::T.let(nil, ::T.untyped)
end

RSpec::Core::ExclusionRules = RSpec::Core::FilterRules

class RSpec::Core::FilterRules
  PROC_HEX_NUMBER = ::T.let(nil, ::T.untyped)
  PROJECT_DIR = ::T.let(nil, ::T.untyped)
end

module RSpec::Core::Formatters::ConsoleCodes
  VT100_CODES = ::T.let(nil, ::T.untyped)
  VT100_CODE_VALUES = ::T.let(nil, ::T.untyped)
end

class RSpec::Core::Formatters::DeprecationFormatter
  DEPRECATION_STREAM_NOTICE = ::T.let(nil, ::T.untyped)
  RAISE_ERROR_CONFIG_NOTICE = ::T.let(nil, ::T.untyped)
  TOO_MANY_WARNINGS_NOTICE = ::T.let(nil, ::T.untyped)
end

class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter
  TOO_MANY_USES_LIMIT = ::T.let(nil, ::T.untyped)
end

class RSpec::Core::Formatters::ExceptionPresenter
  PENDING_DETAIL_FORMATTER = ::T.let(nil, ::T.untyped)
end

module RSpec::Core::Formatters::Helpers
  DEFAULT_PRECISION = ::T.let(nil, ::T.untyped)
  SUB_SECOND_PRECISION = ::T.let(nil, ::T.untyped)
end

class RSpec::Core::Formatters::HtmlPrinter
  GLOBAL_SCRIPTS = ::T.let(nil, ::T.untyped)
  GLOBAL_STYLES = ::T.let(nil, ::T.untyped)
  HTML_HEADER = ::T.let(nil, ::T.untyped)
  REPORT_HEADER = ::T.let(nil, ::T.untyped)
end

module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation
  RESET_CODE = ::T.let(nil, ::T.untyped)
end

RSpec::Core::Formatters::SyntaxHighlighter::WindowsImplementation = RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation

class RSpec::Core::Hooks::HookCollections
  EMPTY_HOOK_ARRAY = ::T.let(nil, ::T.untyped)
  HOOK_TYPES = ::T.let(nil, ::T.untyped)
  SCOPES = ::T.let(nil, ::T.untyped)
  SCOPE_ALIASES = ::T.let(nil, ::T.untyped)
end

module RSpec::Core::Metadata
  RESERVED_KEYS = ::T.let(nil, ::T.untyped)
end

class RSpec::Core::Ordering::Random
  MAX_32_BIT = ::T.let(nil, ::T.untyped)
end

module RSpec::Core::Pending
  NOT_YET_IMPLEMENTED = ::T.let(nil, ::T.untyped)
  NO_REASON_GIVEN = ::T.let(nil, ::T.untyped)
end

class RSpec::Core::Profiler
  NOTIFICATIONS = ::T.let(nil, ::T.untyped)
end

class RSpec::Core::Reporter
  RSPEC_NOTIFICATIONS = ::T.let(nil, ::T.untyped)
end

module RSpec::Core::ShellEscape
  SHELLS_ALLOWING_UNQUOTED_IDS = ::T.let(nil, ::T.untyped)
end

module RSpec::Core::Version
  STRING = ::T.let(nil, ::T.untyped)
end

class RSpec::Expectations::Configuration
  FALSE_POSITIVE_BEHAVIOURS = ::T.let(nil, ::T.untyped)
end

RSpec::Expectations::LegacyMacherAdapter = RSpec::Expectations::LegacyMatcherAdapter

class RSpec::Expectations::MultipleExpectationsNotMetError
  include ::RSpec::Core::MultipleExceptionError::InterfaceTag
end

module RSpec::Expectations::Version
  STRING = ::T.let(nil, ::T.untyped)
end

module RSpec::Matchers
  BE_PREDICATE_REGEX = ::T.let(nil, ::T.untyped)
  DYNAMIC_MATCHER_REGEX = ::T.let(nil, ::T.untyped)
  HAS_REGEX = ::T.let(nil, ::T.untyped)
end

RSpec::Matchers::AliasedNegatedMatcher::DefaultFailureMessages = RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages

class RSpec::Matchers::BuiltIn::BaseMatcher
  UNDEFINED = ::T.let(nil, ::T.untyped)
end

class RSpec::Matchers::BuiltIn::Equal
  LITERAL_SINGLETONS = ::T.let(nil, ::T.untyped)
end

RSpec::Matchers::BuiltIn::SpecificValuesChange::MATCH_ANYTHING = BasicObject

RSpec::Matchers::BuiltIn::StartAndEndWith = RSpec::Matchers::BuiltIn::StartOrEndWith

module RSpec::Matchers::DSL::Macros
  RAISE_NOTIFIER = ::T.let(nil, ::T.untyped)
end

class RSpec::Matchers::ExpectedsForMultipleDiffs
  DEFAULT_DIFF_LABEL = ::T.let(nil, ::T.untyped)
  DESCRIPTION_MAX_LENGTH = ::T.let(nil, ::T.untyped)
end

module RSpec::Mocks
  DEFAULT_CALLBACK_INVOCATION_STRATEGY = ::T.let(nil, ::T.untyped)
  IGNORED_BACKTRACE_LINE = ::T.let(nil, ::T.untyped)
end

class RSpec::Mocks::AnyInstance::PositiveExpectationChain
  ExpectationInvocationOrder = ::T.let(nil, ::T.untyped)
end

class RSpec::Mocks::AnyInstance::StubChain
  EmptyInvocationOrder = ::T.let(nil, ::T.untyped)
  InvocationOrder = ::T.let(nil, ::T.untyped)
end

class RSpec::Mocks::ArgumentListMatcher
  MATCH_ALL = ::T.let(nil, ::T.untyped)
end

class RSpec::Mocks::Matchers::HaveReceived
  ARGS_CONSTRAINTS = ::T.let(nil, ::T.untyped)
  CONSTRAINTS = ::T.let(nil, ::T.untyped)
  COUNT_CONSTRAINTS = ::T.let(nil, ::T.untyped)
end

class RSpec::Mocks::ObjectReference
  MODULE_NAME_METHOD = ::T.let(nil, ::T.untyped)
end

class RSpec::Mocks::Proxy
  DEFAULT_MESSAGE_EXPECTATION_OPTS = ::T.let(nil, ::T.untyped)
end

module RSpec::Mocks::Version
  STRING = ::T.let(nil, ::T.untyped)
end

RSpec::SharedContext = RSpec::Core::SharedContext

module RSpec::Support
  DEFAULT_FAILURE_NOTIFIER = ::T.let(nil, ::T.untyped)
  DEFAULT_WARNING_NOTIFIER = ::T.let(nil, ::T.untyped)
  KERNEL_METHOD_METHOD = ::T.let(nil, ::T.untyped)
end

module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
  AVOID_RESCUING = ::T.let(nil, ::T.untyped)
end

class RSpec::Support::Differ
  def color?(); end

  def diff(actual, expected); end

  def diff_as_object(actual, expected); end

  def diff_as_string(actual, expected); end

  def initialize(opts=T.unsafe(nil)); end
end

class RSpec::Support::Differ
end

class RSpec::Support::EncodedString
  REPLACE = ::T.let(nil, ::T.untyped)
  US_ASCII = ::T.let(nil, ::T.untyped)
  UTF_8 = ::T.let(nil, ::T.untyped)
end

class RSpec::Support::MethodSignature
  INFINITY = ::T.let(nil, ::T.untyped)
end

class RSpec::Support::Mutex
  NEW_MUTEX_METHOD = ::T.let(nil, ::T.untyped)
end

class RSpec::Support::ObjectFormatter
  ELLIPSIS = ::T.let(nil, ::T.untyped)
  INSPECTOR_CLASSES = ::T.let(nil, ::T.untyped)
end

class RSpec::Support::ObjectFormatter::DateTimeInspector
  FORMAT = ::T.let(nil, ::T.untyped)
end

class RSpec::Support::ObjectFormatter::TimeInspector
  FORMAT = ::T.let(nil, ::T.untyped)
end

class RSpec::Support::ObjectFormatter::UninspectableObjectInspector
  OBJECT_ID_FORMAT = ::T.let(nil, ::T.untyped)
end

RSpec::Support::StrictSignatureVerifier = RSpec::Support::MethodSignatureVerifier

module RSpec::Support::Version
  STRING = ::T.let(nil, ::T.untyped)
end

module RSpec::Version
  STRING = ::T.let(nil, ::T.untyped)
end

module Racc
  Racc_No_Extensions = ::T.let(nil, ::T.untyped)
end

class Racc::CparseParams
end

class Racc::CparseParams
end

class Racc::Parser
  Racc_Main_Parsing_Routine = ::T.let(nil, ::T.untyped)
  Racc_Runtime_Core_Id_C = ::T.let(nil, ::T.untyped)
  Racc_Runtime_Core_Revision = ::T.let(nil, ::T.untyped)
  Racc_Runtime_Core_Revision_C = ::T.let(nil, ::T.untyped)
  Racc_Runtime_Core_Revision_R = ::T.let(nil, ::T.untyped)
  Racc_Runtime_Core_Version = ::T.let(nil, ::T.untyped)
  Racc_Runtime_Core_Version_C = ::T.let(nil, ::T.untyped)
  Racc_Runtime_Core_Version_R = ::T.let(nil, ::T.untyped)
  Racc_Runtime_Revision = ::T.let(nil, ::T.untyped)
  Racc_Runtime_Type = ::T.let(nil, ::T.untyped)
  Racc_Runtime_Version = ::T.let(nil, ::T.untyped)
  Racc_YY_Parse_Method = ::T.let(nil, ::T.untyped)
end

module Rake
  EARLY = ::T.let(nil, ::T.untyped)
  EMPTY_TASK_ARGS = ::T.let(nil, ::T.untyped)
  LATE = ::T.let(nil, ::T.untyped)
  VERSION = ::T.let(nil, ::T.untyped)
end

class Rake::Application
  DEFAULT_RAKEFILES = ::T.let(nil, ::T.untyped)
end

module Rake::Backtrace
  SUPPRESSED_PATHS = ::T.let(nil, ::T.untyped)
  SUPPRESSED_PATHS_RE = ::T.let(nil, ::T.untyped)
  SUPPRESS_PATTERN = ::T.let(nil, ::T.untyped)
  SYS_KEYS = ::T.let(nil, ::T.untyped)
  SYS_PATHS = ::T.let(nil, ::T.untyped)
end

module Rake::DSL
  include ::FileUtils::StreamUtils_
end

class Rake::FileList
  ARRAY_METHODS = ::T.let(nil, ::T.untyped)
  DEFAULT_IGNORE_PATTERNS = ::T.let(nil, ::T.untyped)
  DEFAULT_IGNORE_PROCS = ::T.let(nil, ::T.untyped)
  DELEGATING_METHODS = ::T.let(nil, ::T.untyped)
  GLOB_PATTERN = ::T.let(nil, ::T.untyped)
  MUST_DEFINE = ::T.let(nil, ::T.untyped)
  MUST_NOT_DEFINE = ::T.let(nil, ::T.untyped)
  SPECIAL_RETURN = ::T.let(nil, ::T.untyped)
end

module Rake::FileUtilsExt
  include ::FileUtils::StreamUtils_
  DEFAULT = ::T.let(nil, ::T.untyped)
end

module Rake::FileUtilsExt
  extend ::FileUtils::StreamUtils_
end

class Rake::InvocationChain
  EMPTY = ::T.let(nil, ::T.untyped)
end

class Rake::LinkedList
  EMPTY = ::T.let(nil, ::T.untyped)
end

class Rake::Promise
  NOT_SET = ::T.let(nil, ::T.untyped)
end

class Rake::Scope
  EMPTY = ::T.let(nil, ::T.untyped)
end

module Rake::Version
  BUILD = ::T.let(nil, ::T.untyped)
  MAJOR = ::T.let(nil, ::T.untyped)
  MINOR = ::T.let(nil, ::T.untyped)
  NUMBERS = ::T.let(nil, ::T.untyped)
  OTHER = ::T.let(nil, ::T.untyped)
end

module Rake
  extend ::FileUtils::StreamUtils_
end

RakeFileUtils = Rake::FileUtilsExt

class Random
  def self.bytes(_); end
end

class Range
  def %(_); end

  def entries(); end

  def to_a(); end
end

module RbConfig
  def self.expand(val, config=T.unsafe(nil)); end

  def self.fire_update!(key, val, mkconf=T.unsafe(nil), conf=T.unsafe(nil)); end

  def self.ruby(); end
end

module RbReadline
  ABORT_CHAR = ::T.let(nil, ::T.untyped)
  ANCHORED_SEARCH = ::T.let(nil, ::T.untyped)
  ANYOTHERKEY = ::T.let(nil, ::T.untyped)
  AUDIBLE_BELL = ::T.let(nil, ::T.untyped)
  BAD_MODIFIER = ::T.let(nil, ::T.untyped)
  BAD_WORD_SPEC = ::T.let(nil, ::T.untyped)
  BFIND = ::T.let(nil, ::T.untyped)
  BTO = ::T.let(nil, ::T.untyped)
  CapCase = ::T.let(nil, ::T.untyped)
  DEFAULT_BUFFER_SIZE = ::T.let(nil, ::T.untyped)
  DEFAULT_INPUTRC = ::T.let(nil, ::T.untyped)
  DEFAULT_MAX_KILLS = ::T.let(nil, ::T.untyped)
  DownCase = ::T.let(nil, ::T.untyped)
  EOF = ::T.let(nil, ::T.untyped)
  ESC = ::T.let(nil, ::T.untyped)
  EVENT_NOT_FOUND = ::T.let(nil, ::T.untyped)
  FFIND = ::T.let(nil, ::T.untyped)
  FTO = ::T.let(nil, ::T.untyped)
  HISTORY_APPEND = ::T.let(nil, ::T.untyped)
  HISTORY_OVERWRITE = ::T.let(nil, ::T.untyped)
  HISTORY_QUOTE_CHARACTERS = ::T.let(nil, ::T.untyped)
  HISTORY_WORD_DELIMITERS = ::T.let(nil, ::T.untyped)
  ISFUNC = ::T.let(nil, ::T.untyped)
  ISKMAP = ::T.let(nil, ::T.untyped)
  ISMACR = ::T.let(nil, ::T.untyped)
  KEYMAP_SIZE = ::T.let(nil, ::T.untyped)
  KSEQ_DISPATCHED = ::T.let(nil, ::T.untyped)
  KSEQ_RECURSIVE = ::T.let(nil, ::T.untyped)
  KSEQ_SUBSEQ = ::T.let(nil, ::T.untyped)
  MB_FIND_ANY = ::T.let(nil, ::T.untyped)
  MB_FIND_NONZERO = ::T.let(nil, ::T.untyped)
  MB_LEN_MAX = ::T.let(nil, ::T.untyped)
  MULT_MATCH = ::T.let(nil, ::T.untyped)
  NEWLINE = ::T.let(nil, ::T.untyped)
  NON_ANCHORED_SEARCH = ::T.let(nil, ::T.untyped)
  NO_BELL = ::T.let(nil, ::T.untyped)
  NO_MATCH = ::T.let(nil, ::T.untyped)
  NO_PREV_SUBST = ::T.let(nil, ::T.untyped)
  NUM_READONE = ::T.let(nil, ::T.untyped)
  NUM_SAWDIGITS = ::T.let(nil, ::T.untyped)
  NUM_SAWMINUS = ::T.let(nil, ::T.untyped)
  PAGE = ::T.let(nil, ::T.untyped)
  RB_READLINE_VERSION = ::T.let(nil, ::T.untyped)
  READERR = ::T.let(nil, ::T.untyped)
  RETURN = ::T.let(nil, ::T.untyped)
  RL_IM_DEFAULT = ::T.let(nil, ::T.untyped)
  RL_IM_INSERT = ::T.let(nil, ::T.untyped)
  RL_IM_OVERWRITE = ::T.let(nil, ::T.untyped)
  RL_LIBRARY_VERSION = ::T.let(nil, ::T.untyped)
  RL_PROMPT_END_IGNORE = ::T.let(nil, ::T.untyped)
  RL_PROMPT_START_IGNORE = ::T.let(nil, ::T.untyped)
  RL_QF_BACKSLASH = ::T.let(nil, ::T.untyped)
  RL_QF_DOUBLE_QUOTE = ::T.let(nil, ::T.untyped)
  RL_QF_OTHER_QUOTE = ::T.let(nil, ::T.untyped)
  RL_QF_SINGLE_QUOTE = ::T.let(nil, ::T.untyped)
  RL_READLINE_VERSION = ::T.let(nil, ::T.untyped)
  RL_SEARCH_CSEARCH = ::T.let(nil, ::T.untyped)
  RL_SEARCH_ISEARCH = ::T.let(nil, ::T.untyped)
  RL_SEARCH_NSEARCH = ::T.let(nil, ::T.untyped)
  RL_STATE_CALLBACK = ::T.let(nil, ::T.untyped)
  RL_STATE_COMPLETING = ::T.let(nil, ::T.untyped)
  RL_STATE_DISPATCHING = ::T.let(nil, ::T.untyped)
  RL_STATE_DONE = ::T.let(nil, ::T.untyped)
  RL_STATE_INITIALIZED = ::T.let(nil, ::T.untyped)
  RL_STATE_INITIALIZING = ::T.let(nil, ::T.untyped)
  RL_STATE_INPUTPENDING = ::T.let(nil, ::T.untyped)
  RL_STATE_ISEARCH = ::T.let(nil, ::T.untyped)
  RL_STATE_MACRODEF = ::T.let(nil, ::T.untyped)
  RL_STATE_MACROINPUT = ::T.let(nil, ::T.untyped)
  RL_STATE_METANEXT = ::T.let(nil, ::T.untyped)
  RL_STATE_MOREINPUT = ::T.let(nil, ::T.untyped)
  RL_STATE_MULTIKEY = ::T.let(nil, ::T.untyped)
  RL_STATE_NONE = ::T.let(nil, ::T.untyped)
  RL_STATE_NSEARCH = ::T.let(nil, ::T.untyped)
  RL_STATE_NUMERICARG = ::T.let(nil, ::T.untyped)
  RL_STATE_OVERWRITE = ::T.let(nil, ::T.untyped)
  RL_STATE_READCMD = ::T.let(nil, ::T.untyped)
  RL_STATE_SEARCH = ::T.let(nil, ::T.untyped)
  RL_STATE_SIGHANDLER = ::T.let(nil, ::T.untyped)
  RL_STATE_TERMPREPPED = ::T.let(nil, ::T.untyped)
  RL_STATE_TTYCSAVED = ::T.let(nil, ::T.untyped)
  RL_STATE_UNDOING = ::T.let(nil, ::T.untyped)
  RL_STATE_VICMDONCE = ::T.let(nil, ::T.untyped)
  RL_STATE_VIMOTION = ::T.let(nil, ::T.untyped)
  RUBOUT = ::T.let(nil, ::T.untyped)
  SF_FAILED = ::T.let(nil, ::T.untyped)
  SF_FOUND = ::T.let(nil, ::T.untyped)
  SF_REVERSE = ::T.let(nil, ::T.untyped)
  SINGLE_MATCH = ::T.let(nil, ::T.untyped)
  SPACE = ::T.let(nil, ::T.untyped)
  SUBST_FAILED = ::T.let(nil, ::T.untyped)
  SYS_INPUTRC = ::T.let(nil, ::T.untyped)
  TAB = ::T.let(nil, ::T.untyped)
  UNDO_BEGIN = ::T.let(nil, ::T.untyped)
  UNDO_DELETE = ::T.let(nil, ::T.untyped)
  UNDO_END = ::T.let(nil, ::T.untyped)
  UNDO_INSERT = ::T.let(nil, ::T.untyped)
  UpCase = ::T.let(nil, ::T.untyped)
  VISIBLE_BELL = ::T.let(nil, ::T.untyped)
  XOK = ::T.let(nil, ::T.untyped)
end

module Reek
  DEFAULT_CONFIGURATION_FILE_NAME = ::T.let(nil, ::T.untyped)
  DETECTORS_KEY = ::T.let(nil, ::T.untyped)
  DIRECTORIES_KEY = ::T.let(nil, ::T.untyped)
  EXCLUDE_PATHS_KEY = ::T.let(nil, ::T.untyped)
end

Reek::AST::SexpExtensions::CSendNode = Reek::AST::SexpExtensions::SendNode

Reek::AST::SexpExtensions::CvasgnNode = Reek::AST::SexpExtensions::CvarNode

Reek::AST::SexpExtensions::CvdeclNode = Reek::AST::SexpExtensions::CvarNode

Reek::AST::SexpExtensions::LvasgnNode = Reek::AST::SexpExtensions::LvarNode

Reek::AST::SexpExtensions::Op_AsgnNode = Reek::AST::SexpExtensions::SendNode

module Reek::AST::SexpExtensions::SendNode
  ATTR_DEFN_METHODS = ::T.let(nil, ::T.untyped)
end

Reek::AST::SexpExtensions::ZsuperNode = Reek::AST::SexpExtensions::SuperNode

class Reek::CodeComment
  CONFIGURATION_REGEX = ::T.let(nil, ::T.untyped)
  DISABLE_DETECTOR_CONFIGURATION = ::T.let(nil, ::T.untyped)
  MINIMUM_CONTENT_LENGTH = ::T.let(nil, ::T.untyped)
  SANITIZE_REGEX = ::T.let(nil, ::T.untyped)
end

class Reek::Configuration::ConfigurationConverter
  REGEXABLE_ATTRIBUTES = ::T.let(nil, ::T.untyped)
end

module Reek::Configuration::ConfigurationFileFinder
  DEFAULT_FILE_NAME = ::T.let(nil, ::T.untyped)
end

module Reek::Configuration::ConfigurationFileFinder
  extend ::Reek::Configuration::ConfigurationValidator
end

class Reek::Configuration::SchemaValidator
  SCHEMA_FILE_PATH = ::T.let(nil, ::T.untyped)
end

class Reek::Context::VisibilityTracker
  VISIBILITY_MAP = ::T.let(nil, ::T.untyped)
  VISIBILITY_MODIFIERS = ::T.let(nil, ::T.untyped)
end

module Reek::DocumentationLink
  HELP_LINK_TEMPLATE = ::T.let(nil, ::T.untyped)
end

class Reek::Errors::BadDetectorConfigurationKeyInCommentError
  UNKNOWN_SMELL_DETECTOR_MESSAGE = ::T.let(nil, ::T.untyped)
end

class Reek::Errors::BadDetectorInCommentError
  UNKNOWN_SMELL_DETECTOR_MESSAGE = ::T.let(nil, ::T.untyped)
end

class Reek::Errors::EncodingError
  LONG_TEMPLATE = ::T.let(nil, ::T.untyped)
  TEMPLATE = ::T.let(nil, ::T.untyped)
end

class Reek::Errors::GarbageDetectorConfigurationInCommentError
  BAD_DETECTOR_CONFIGURATION_MESSAGE = ::T.let(nil, ::T.untyped)
end

class Reek::Errors::IncomprehensibleSourceError
  LONG_TEMPLATE = ::T.let(nil, ::T.untyped)
  TEMPLATE = ::T.let(nil, ::T.untyped)
end

class Reek::Errors::LegacyCommentSeparatorError
  MESSAGE = ::T.let(nil, ::T.untyped)
end

class Reek::Errors::SyntaxError
  LONG_TEMPLATE = ::T.let(nil, ::T.untyped)
  TEMPLATE = ::T.let(nil, ::T.untyped)
end

module Reek::Report
  HEADING_FORMATTERS = ::T.let(nil, ::T.untyped)
  LOCATION_FORMATTERS = ::T.let(nil, ::T.untyped)
  PROGRESS_FORMATTERS = ::T.let(nil, ::T.untyped)
  REPORT_CLASSES = ::T.let(nil, ::T.untyped)
  WARNING_FORMATTER_CLASSES = ::T.let(nil, ::T.untyped)
end

class Reek::Report::BaseReport
  NO_WARNINGS_COLOR = ::T.let(nil, ::T.untyped)
  WARNINGS_COLOR = ::T.let(nil, ::T.untyped)
end

class Reek::Report::ProgressFormatter::Dots
  NO_WARNINGS_COLOR = ::T.let(nil, ::T.untyped)
  WARNINGS_COLOR = ::T.let(nil, ::T.untyped)
end

class Reek::SmellConfiguration
  ENABLED_KEY = ::T.let(nil, ::T.untyped)
  OVERRIDES_KEY = ::T.let(nil, ::T.untyped)
end

class Reek::SmellDetectors::BaseDetector
  DEFAULT_EXCLUDE_SET = ::T.let(nil, ::T.untyped)
  EXCLUDE_KEY = ::T.let(nil, ::T.untyped)
end

class Reek::SmellDetectors::ControlParameterHelpers::CallInConditionFinder
  COMPARISON_METHOD_NAMES = ::T.let(nil, ::T.untyped)
end

class Reek::SmellDetectors::ControlParameterHelpers::ControlParameterFinder
  CONDITIONAL_NODE_TYPES = ::T.let(nil, ::T.untyped)
end

class Reek::SmellDetectors::DataClump
  DEFAULT_MAX_COPIES = ::T.let(nil, ::T.untyped)
  DEFAULT_MIN_CLUMP_SIZE = ::T.let(nil, ::T.untyped)
  MAX_COPIES_KEY = ::T.let(nil, ::T.untyped)
  MIN_CLUMP_SIZE_KEY = ::T.let(nil, ::T.untyped)
end

class Reek::SmellDetectors::DuplicateMethodCall
  ALLOW_CALLS_KEY = ::T.let(nil, ::T.untyped)
  DEFAULT_ALLOW_CALLS = ::T.let(nil, ::T.untyped)
  DEFAULT_MAX_CALLS = ::T.let(nil, ::T.untyped)
  MAX_ALLOWED_CALLS_KEY = ::T.let(nil, ::T.untyped)
end

class Reek::SmellDetectors::LongParameterList
  DEFAULT_MAX_ALLOWED_PARAMS = ::T.let(nil, ::T.untyped)
  MAX_ALLOWED_PARAMS_KEY = ::T.let(nil, ::T.untyped)
end

class Reek::SmellDetectors::LongYieldList
  DEFAULT_MAX_ALLOWED_PARAMS = ::T.let(nil, ::T.untyped)
  MAX_ALLOWED_PARAMS_KEY = ::T.let(nil, ::T.untyped)
end

class Reek::SmellDetectors::ManualDispatch
  MESSAGE = ::T.let(nil, ::T.untyped)
end

class Reek::SmellDetectors::NestedIterators
  DEFAULT_IGNORE_ITERATORS = ::T.let(nil, ::T.untyped)
  DEFAULT_MAX_ALLOWED_NESTING = ::T.let(nil, ::T.untyped)
  IGNORE_ITERATORS_KEY = ::T.let(nil, ::T.untyped)
  MAX_ALLOWED_NESTING_KEY = ::T.let(nil, ::T.untyped)
end

class Reek::SmellDetectors::RepeatedConditional
  BLOCK_GIVEN_CONDITION = ::T.let(nil, ::T.untyped)
  DEFAULT_MAX_IFS = ::T.let(nil, ::T.untyped)
  MAX_IDENTICAL_IFS_KEY = ::T.let(nil, ::T.untyped)
end

class Reek::SmellDetectors::SubclassedFromCoreClass
  CORE_CLASSES = ::T.let(nil, ::T.untyped)
end

class Reek::SmellDetectors::TooManyConstants
  DEFAULT_MAX_CONSTANTS = ::T.let(nil, ::T.untyped)
  IGNORED_NODES = ::T.let(nil, ::T.untyped)
  MAX_ALLOWED_CONSTANTS_KEY = ::T.let(nil, ::T.untyped)
end

class Reek::SmellDetectors::TooManyInstanceVariables
  DEFAULT_MAX_IVARS = ::T.let(nil, ::T.untyped)
  MAX_ALLOWED_IVARS_KEY = ::T.let(nil, ::T.untyped)
end

class Reek::SmellDetectors::TooManyMethods
  DEFAULT_MAX_METHODS = ::T.let(nil, ::T.untyped)
  MAX_ALLOWED_METHODS_KEY = ::T.let(nil, ::T.untyped)
end

class Reek::SmellDetectors::TooManyStatements
  DEFAULT_MAX_STATEMENTS = ::T.let(nil, ::T.untyped)
  MAX_ALLOWED_STATEMENTS_KEY = ::T.let(nil, ::T.untyped)
end

class Reek::SmellDetectors::UncommunicativeMethodName
  ACCEPT_KEY = ::T.let(nil, ::T.untyped)
  DEFAULT_ACCEPT_PATTERNS = ::T.let(nil, ::T.untyped)
  DEFAULT_REJECT_PATTERNS = ::T.let(nil, ::T.untyped)
  REJECT_KEY = ::T.let(nil, ::T.untyped)
end

class Reek::SmellDetectors::UncommunicativeModuleName
  ACCEPT_KEY = ::T.let(nil, ::T.untyped)
  DEFAULT_ACCEPT_PATTERNS = ::T.let(nil, ::T.untyped)
  DEFAULT_REJECT_PATTERNS = ::T.let(nil, ::T.untyped)
  REJECT_KEY = ::T.let(nil, ::T.untyped)
end

class Reek::SmellDetectors::UncommunicativeParameterName
  ACCEPT_KEY = ::T.let(nil, ::T.untyped)
  DEFAULT_ACCEPT_PATTERNS = ::T.let(nil, ::T.untyped)
  DEFAULT_REJECT_PATTERNS = ::T.let(nil, ::T.untyped)
  REJECT_KEY = ::T.let(nil, ::T.untyped)
end

class Reek::SmellDetectors::UncommunicativeVariableName
  ACCEPT_KEY = ::T.let(nil, ::T.untyped)
  DEFAULT_ACCEPT_SET = ::T.let(nil, ::T.untyped)
  DEFAULT_REJECT_SET = ::T.let(nil, ::T.untyped)
  REJECT_KEY = ::T.let(nil, ::T.untyped)
end

class Reek::SmellDetectors::UtilityFunction
  PUBLIC_METHODS_ONLY_DEFAULT = ::T.let(nil, ::T.untyped)
  PUBLIC_METHODS_ONLY_KEY = ::T.let(nil, ::T.untyped)
end

class Reek::Source::SourceCode
  IO_IDENTIFIER = ::T.let(nil, ::T.untyped)
  STRING_IDENTIFIER = ::T.let(nil, ::T.untyped)
end

module Reek::Version
  STRING = ::T.let(nil, ::T.untyped)
end

class Regexp
  TOKEN_KEYS = ::T.let(nil, ::T.untyped)
end

Regexp::Expression::Alternation::OPERAND = Regexp::Expression::Alternative

Regexp::Expression::Anchor::BOL = Regexp::Expression::Anchor::BeginningOfLine

Regexp::Expression::Anchor::BOS = Regexp::Expression::Anchor::BeginningOfString

Regexp::Expression::Anchor::EOL = Regexp::Expression::Anchor::EndOfLine

Regexp::Expression::Anchor::EOS = Regexp::Expression::Anchor::EndOfString

Regexp::Expression::Anchor::EOSobEOL = Regexp::Expression::Anchor::EndOfStringOrBeforeEndOfLine

Regexp::Expression::CharacterSet::Intersection::OPERAND = Regexp::Expression::CharacterSet::IntersectedSequence

Regexp::Expression::MatchLength = Regexp::MatchLength

class Regexp::Expression::Quantifier
  MODES = ::T.let(nil, ::T.untyped)
end

class Regexp::Lexer
  CLOSING_TOKENS = ::T.let(nil, ::T.untyped)
  OPENING_TOKENS = ::T.let(nil, ::T.untyped)
end

class Regexp::Parser
  ENC_FLAGS = ::T.let(nil, ::T.untyped)
  MOD_FLAGS = ::T.let(nil, ::T.untyped)
  VERSION = ::T.let(nil, ::T.untyped)
end

class Regexp::Scanner
  PROP_MAPS_DIR = ::T.let(nil, ::T.untyped)
end

module Regexp::Syntax
  VERSION_CONST_REGEXP = ::T.let(nil, ::T.untyped)
  VERSION_FORMAT = ::T.let(nil, ::T.untyped)
  VERSION_REGEXP = ::T.let(nil, ::T.untyped)
end

module Regexp::Syntax::Token
  All = ::T.let(nil, ::T.untyped)
  Map = ::T.let(nil, ::T.untyped)
  Types = ::T.let(nil, ::T.untyped)
end

module Regexp::Syntax::Token::Anchor
  All = ::T.let(nil, ::T.untyped)
  Basic = ::T.let(nil, ::T.untyped)
  Extended = ::T.let(nil, ::T.untyped)
  MatchStart = ::T.let(nil, ::T.untyped)
  String = ::T.let(nil, ::T.untyped)
  Type = ::T.let(nil, ::T.untyped)
end

module Regexp::Syntax::Token::Assertion
  All = ::T.let(nil, ::T.untyped)
  Lookahead = ::T.let(nil, ::T.untyped)
  Lookbehind = ::T.let(nil, ::T.untyped)
  Type = ::T.let(nil, ::T.untyped)
end

module Regexp::Syntax::Token::Backreference
  All = ::T.let(nil, ::T.untyped)
  Name = ::T.let(nil, ::T.untyped)
  Number = ::T.let(nil, ::T.untyped)
  RecursionLevel = ::T.let(nil, ::T.untyped)
  Type = ::T.let(nil, ::T.untyped)
end

module Regexp::Syntax::Token::CharacterSet
  All = ::T.let(nil, ::T.untyped)
  Basic = ::T.let(nil, ::T.untyped)
  Extended = ::T.let(nil, ::T.untyped)
  Type = ::T.let(nil, ::T.untyped)
end

module Regexp::Syntax::Token::CharacterType
  All = ::T.let(nil, ::T.untyped)
  Basic = ::T.let(nil, ::T.untyped)
  Clustered = ::T.let(nil, ::T.untyped)
  Extended = ::T.let(nil, ::T.untyped)
  Hex = ::T.let(nil, ::T.untyped)
  Type = ::T.let(nil, ::T.untyped)
end

module Regexp::Syntax::Token::Conditional
  All = ::T.let(nil, ::T.untyped)
  Condition = ::T.let(nil, ::T.untyped)
  Delimiters = ::T.let(nil, ::T.untyped)
  Separator = ::T.let(nil, ::T.untyped)
  Type = ::T.let(nil, ::T.untyped)
end

module Regexp::Syntax::Token::Escape
  ASCII = ::T.let(nil, ::T.untyped)
  All = ::T.let(nil, ::T.untyped)
  Basic = ::T.let(nil, ::T.untyped)
  Control = ::T.let(nil, ::T.untyped)
  Hex = ::T.let(nil, ::T.untyped)
  Meta = ::T.let(nil, ::T.untyped)
  Octal = ::T.let(nil, ::T.untyped)
  Type = ::T.let(nil, ::T.untyped)
  Unicode = ::T.let(nil, ::T.untyped)
end

module Regexp::Syntax::Token::FreeSpace
  All = ::T.let(nil, ::T.untyped)
  Type = ::T.let(nil, ::T.untyped)
end

module Regexp::Syntax::Token::Group
  All = ::T.let(nil, ::T.untyped)
  Atomic = ::T.let(nil, ::T.untyped)
  Basic = ::T.let(nil, ::T.untyped)
  Comment = ::T.let(nil, ::T.untyped)
  Extended = ::T.let(nil, ::T.untyped)
  Named = ::T.let(nil, ::T.untyped)
  Passive = ::T.let(nil, ::T.untyped)
  Type = ::T.let(nil, ::T.untyped)
  V1_8_6 = ::T.let(nil, ::T.untyped)
  V2_4_1 = ::T.let(nil, ::T.untyped)
end

module Regexp::Syntax::Token::Keep
  All = ::T.let(nil, ::T.untyped)
  Mark = ::T.let(nil, ::T.untyped)
  Type = ::T.let(nil, ::T.untyped)
end

module Regexp::Syntax::Token::Literal
  All = ::T.let(nil, ::T.untyped)
  Type = ::T.let(nil, ::T.untyped)
end

module Regexp::Syntax::Token::Meta
  All = ::T.let(nil, ::T.untyped)
  Basic = ::T.let(nil, ::T.untyped)
  Extended = ::T.let(nil, ::T.untyped)
  Type = ::T.let(nil, ::T.untyped)
end

module Regexp::Syntax::Token::PosixClass
  All = ::T.let(nil, ::T.untyped)
  Extensions = ::T.let(nil, ::T.untyped)
  NonType = ::T.let(nil, ::T.untyped)
  Standard = ::T.let(nil, ::T.untyped)
  Type = ::T.let(nil, ::T.untyped)
end

module Regexp::Syntax::Token::Quantifier
  All = ::T.let(nil, ::T.untyped)
  Greedy = ::T.let(nil, ::T.untyped)
  Interval = ::T.let(nil, ::T.untyped)
  IntervalAll = ::T.let(nil, ::T.untyped)
  IntervalPossessive = ::T.let(nil, ::T.untyped)
  IntervalReluctant = ::T.let(nil, ::T.untyped)
  Possessive = ::T.let(nil, ::T.untyped)
  Reluctant = ::T.let(nil, ::T.untyped)
  Type = ::T.let(nil, ::T.untyped)
end

module Regexp::Syntax::Token::SubexpressionCall
  All = ::T.let(nil, ::T.untyped)
  Name = ::T.let(nil, ::T.untyped)
  Number = ::T.let(nil, ::T.untyped)
end

module Regexp::Syntax::Token::UnicodeProperty
  Age = ::T.let(nil, ::T.untyped)
  Age_V1_9_3 = ::T.let(nil, ::T.untyped)
  Age_V2_0_0 = ::T.let(nil, ::T.untyped)
  Age_V2_2_0 = ::T.let(nil, ::T.untyped)
  Age_V2_3_0 = ::T.let(nil, ::T.untyped)
  Age_V2_4_0 = ::T.let(nil, ::T.untyped)
  Age_V2_5_0 = ::T.let(nil, ::T.untyped)
  Age_V2_6_0 = ::T.let(nil, ::T.untyped)
  Age_V2_6_2 = ::T.let(nil, ::T.untyped)
  Age_V2_6_3 = ::T.let(nil, ::T.untyped)
  All = ::T.let(nil, ::T.untyped)
  CharType_V1_9_0 = ::T.let(nil, ::T.untyped)
  CharType_V2_5_0 = ::T.let(nil, ::T.untyped)
  Derived = ::T.let(nil, ::T.untyped)
  Derived_V1_9_0 = ::T.let(nil, ::T.untyped)
  Derived_V2_0_0 = ::T.let(nil, ::T.untyped)
  Derived_V2_4_0 = ::T.let(nil, ::T.untyped)
  Derived_V2_5_0 = ::T.let(nil, ::T.untyped)
  Emoji = ::T.let(nil, ::T.untyped)
  Emoji_V2_5_0 = ::T.let(nil, ::T.untyped)
  NonType = ::T.let(nil, ::T.untyped)
  POSIX = ::T.let(nil, ::T.untyped)
  Script = ::T.let(nil, ::T.untyped)
  Script_V1_9_0 = ::T.let(nil, ::T.untyped)
  Script_V1_9_3 = ::T.let(nil, ::T.untyped)
  Script_V2_0_0 = ::T.let(nil, ::T.untyped)
  Script_V2_2_0 = ::T.let(nil, ::T.untyped)
  Script_V2_3_0 = ::T.let(nil, ::T.untyped)
  Script_V2_4_0 = ::T.let(nil, ::T.untyped)
  Script_V2_5_0 = ::T.let(nil, ::T.untyped)
  Script_V2_6_0 = ::T.let(nil, ::T.untyped)
  Script_V2_6_2 = ::T.let(nil, ::T.untyped)
  Type = ::T.let(nil, ::T.untyped)
  UnicodeBlock = ::T.let(nil, ::T.untyped)
  UnicodeBlock_V1_9_0 = ::T.let(nil, ::T.untyped)
  UnicodeBlock_V2_0_0 = ::T.let(nil, ::T.untyped)
  UnicodeBlock_V2_2_0 = ::T.let(nil, ::T.untyped)
  UnicodeBlock_V2_3_0 = ::T.let(nil, ::T.untyped)
  UnicodeBlock_V2_4_0 = ::T.let(nil, ::T.untyped)
  UnicodeBlock_V2_5_0 = ::T.let(nil, ::T.untyped)
  UnicodeBlock_V2_6_0 = ::T.let(nil, ::T.untyped)
  UnicodeBlock_V2_6_2 = ::T.let(nil, ::T.untyped)
  V1_9_0 = ::T.let(nil, ::T.untyped)
  V1_9_3 = ::T.let(nil, ::T.untyped)
  V2_0_0 = ::T.let(nil, ::T.untyped)
  V2_2_0 = ::T.let(nil, ::T.untyped)
  V2_3_0 = ::T.let(nil, ::T.untyped)
  V2_4_0 = ::T.let(nil, ::T.untyped)
  V2_5_0 = ::T.let(nil, ::T.untyped)
  V2_6_0 = ::T.let(nil, ::T.untyped)
  V2_6_2 = ::T.let(nil, ::T.untyped)
  V2_6_3 = ::T.let(nil, ::T.untyped)
end

module Regexp::Syntax::Token::UnicodeProperty::Category
  All = ::T.let(nil, ::T.untyped)
  Codepoint = ::T.let(nil, ::T.untyped)
  Letter = ::T.let(nil, ::T.untyped)
  Mark = ::T.let(nil, ::T.untyped)
  Number = ::T.let(nil, ::T.untyped)
  Punctuation = ::T.let(nil, ::T.untyped)
  Separator = ::T.let(nil, ::T.untyped)
  Symbol = ::T.let(nil, ::T.untyped)
end

class Resolv::DNS
  def extract_resources(msg, name, typeclass); end

  def getname(address); 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 RuboCop::AST::ArrayNode
  PERCENT_LITERAL_TYPES = ::T.let(nil, ::T.untyped)
end

class RuboCop::AST::BlockNode
  VOID_CONTEXT_METHODS = ::T.let(nil, ::T.untyped)
end

class RuboCop::AST::Builder
  NODE_MAP = ::T.let(nil, ::T.untyped)
end

module RuboCop::AST::CollectionNode
  ARRAY_METHODS = ::T.let(nil, ::T.untyped)
end

class RuboCop::AST::KeywordSplatNode
  DOUBLE_SPLAT = ::T.let(nil, ::T.untyped)
end

module RuboCop::AST::MethodDispatchNode
  ARITHMETIC_OPERATORS = ::T.let(nil, ::T.untyped)
  SPECIAL_MODIFIERS = ::T.let(nil, ::T.untyped)
end

module RuboCop::AST::MethodIdentifierPredicates
  ENUMERABLE_METHODS = ::T.let(nil, ::T.untyped)
  ENUMERATOR_METHODS = ::T.let(nil, ::T.untyped)
  NONMUTATING_ARRAY_METHODS = ::T.let(nil, ::T.untyped)
  NONMUTATING_BINARY_OPERATOR_METHODS = ::T.let(nil, ::T.untyped)
  NONMUTATING_HASH_METHODS = ::T.let(nil, ::T.untyped)
  NONMUTATING_OPERATOR_METHODS = ::T.let(nil, ::T.untyped)
  NONMUTATING_STRING_METHODS = ::T.let(nil, ::T.untyped)
  NONMUTATING_UNARY_OPERATOR_METHODS = ::T.let(nil, ::T.untyped)
  OPERATOR_METHODS = ::T.let(nil, ::T.untyped)
end

class RuboCop::AST::Node
  ARGUMENT_TYPES = ::T.let(nil, ::T.untyped)
  ASSIGNMENTS = ::T.let(nil, ::T.untyped)
  BASIC_CONDITIONALS = ::T.let(nil, ::T.untyped)
  BASIC_LITERALS = ::T.let(nil, ::T.untyped)
  COMPARISON_OPERATORS = ::T.let(nil, ::T.untyped)
  COMPOSITE_LITERALS = ::T.let(nil, ::T.untyped)
  CONDITIONALS = ::T.let(nil, ::T.untyped)
  EQUALS_ASSIGNMENTS = ::T.let(nil, ::T.untyped)
  FALSEY_LITERALS = ::T.let(nil, ::T.untyped)
  IMMUTABLE_LITERALS = ::T.let(nil, ::T.untyped)
  KEYWORDS = ::T.let(nil, ::T.untyped)
  LITERALS = ::T.let(nil, ::T.untyped)
  LOOP_TYPES = ::T.let(nil, ::T.untyped)
  MUTABLE_LITERALS = ::T.let(nil, ::T.untyped)
  OPERATOR_KEYWORDS = ::T.let(nil, ::T.untyped)
  POST_CONDITION_LOOP_TYPES = ::T.let(nil, ::T.untyped)
  REFERENCES = ::T.let(nil, ::T.untyped)
  SHORTHAND_ASSIGNMENTS = ::T.let(nil, ::T.untyped)
  SPECIAL_KEYWORDS = ::T.let(nil, ::T.untyped)
  TRUTHY_LITERALS = ::T.let(nil, ::T.untyped)
  VARIABLES = ::T.let(nil, ::T.untyped)
end

module RuboCop::AST::NumericNode
  SIGN_REGEX = ::T.let(nil, ::T.untyped)
end

class RuboCop::AST::PairNode
  COLON = ::T.let(nil, ::T.untyped)
  HASH_ROCKET = ::T.let(nil, ::T.untyped)
  SPACED_COLON = ::T.let(nil, ::T.untyped)
  SPACED_HASH_ROCKET = ::T.let(nil, ::T.untyped)
end

module RuboCop::AST::PredicateOperatorNode
  LOGICAL_AND = ::T.let(nil, ::T.untyped)
  LOGICAL_OR = ::T.let(nil, ::T.untyped)
  SEMANTIC_AND = ::T.let(nil, ::T.untyped)
  SEMANTIC_OR = ::T.let(nil, ::T.untyped)
end

class RuboCop::AST::ProcessedSource
  STRING_SOURCE_NAME = ::T.let(nil, ::T.untyped)
end

class RuboCop::AST::RegexpNode
  OPTIONS = ::T.let(nil, ::T.untyped)
end

module RuboCop::AST::Traversal
  MANY_CHILD_NODES = ::T.let(nil, ::T.untyped)
  NO_CHILD_NODES = ::T.let(nil, ::T.untyped)
  ONE_CHILD_NODE = ::T.let(nil, ::T.untyped)
  SECOND_CHILD_ONLY = ::T.let(nil, ::T.untyped)
end

module RuboCop::AST::Version
  STRING = ::T.let(nil, ::T.untyped)
end

class RuboCop::CLI::Command::AutoGenerateConfig
  AUTO_GENERATED_FILE = ::T.let(nil, ::T.untyped)
end

class RuboCop::Config
  DEFAULT_RAILS_VERSION = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::Layout::SpaceAroundMethodCallOperator
  SPACES_REGEXP = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::Lint::ConstantResolution
  MSG = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::Lint::DuplicateElsifCondition
  MSG = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::Lint::FormatParameterMismatch
  MSG_INVALID = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::Metrics::Utils::CodeLengthCalculator
  CLASSISH_TYPES = ::T.let(nil, ::T.untyped)
  FOLDABLE_TYPES = ::T.let(nil, ::T.untyped)
end

module RuboCop::Cop::Metrics::Utils::IteratingBlock
  KNOWN_ITERATING_METHODS = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::Naming::AsciiIdentifiers
  CONSTANT_MSG = ::T.let(nil, ::T.untyped)
  IDENTIFIER_MSG = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::Naming::BinaryOperatorParameterName
  EXCLUDED = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::Offense
  NO_LOCATION = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::RSpec::Capybara::VisibilityMatcher
  CAPYBARA_MATCHER_METHODS = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::RSpec::VariableDefinition
  MSG = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::RSpec::VariableName
  MSG = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::Style::AccessorGrouping
  ACCESSOR_METHODS = ::T.let(nil, ::T.untyped)
  GROUPED_MSG = ::T.let(nil, ::T.untyped)
  SEPARATED_MSG = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::Style::ArrayCoercion
  CHECK_MSG = ::T.let(nil, ::T.untyped)
  SPLAT_MSG = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::Style::BisectedAttrAccessor
  MSG = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::Style::CaseLikeIf
  MSG = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::Style::CommentedKeyword
  ALLOWED_COMMENT_REGEXES = ::T.let(nil, ::T.untyped)
  KEYWORD_REGEXES = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::Style::ExponentialNotation
  MESSAGES = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::Style::FloatDivision
  MESSAGES = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::Style::HashLikeCase
  MSG = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::Style::RedundantAssignment
  MSG = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::Style::RedundantConditional
  COMPARISON_OPERATOR_MATCHER = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::Style::RedundantFetchBlock
  MSG = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::Style::RedundantFileExtensionInRequire
  MSG = ::T.let(nil, ::T.untyped)
end

class RuboCop::Cop::Style::RedundantSelf
  KEYWORDS = ::T.let(nil, ::T.untyped)
end

module RuboCop::Cop::VisibilityHelp
  VISIBILITY_SCOPES = ::T.let(nil, ::T.untyped)
end

RuboCop::NodePattern = RuboCop::AST::NodePattern

RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource

RuboCop::Token = RuboCop::AST::Token

class RubyLex
  include ::RubyToken
  def Fail(err=T.unsafe(nil), *rest); end

  def Raise(err=T.unsafe(nil), *rest); end

  def char_no(); end

  def each_top_level_statement(); end

  def eof?(); end

  def exception_on_syntax_error(); end

  def exception_on_syntax_error=(exception_on_syntax_error); end

  def get_readed(); end

  def getc(); end

  def getc_of_rests(); end

  def gets(); end

  def identify_comment(); end

  def identify_gvar(); end

  def identify_here_document(); end

  def identify_identifier(); end

  def identify_number(); end

  def identify_quotation(); end

  def identify_string(ltype, quoted=T.unsafe(nil)); end

  def identify_string_dvar(); end

  def indent(); end

  def initialize_input(); end

  def lex(); end

  def lex_init(); end

  def lex_int2(); end

  def line_no(); end

  def peek(i=T.unsafe(nil)); end

  def peek_equal?(str); end

  def peek_match?(regexp); end

  def prompt(); end

  def read_escape(); end

  def readed_auto_clean_up(); end

  def readed_auto_clean_up=(readed_auto_clean_up); end

  def seek(); end

  def set_input(io, p=T.unsafe(nil), &block); end

  def set_prompt(p=T.unsafe(nil), &block); end

  def skip_space(); end

  def skip_space=(skip_space); end

  def token(); end

  def ungetc(c=T.unsafe(nil)); end
  DEINDENT_CLAUSE = ::T.let(nil, ::T.untyped)
  DLtype2Token = ::T.let(nil, ::T.untyped)
  ENINDENT_CLAUSE = ::T.let(nil, ::T.untyped)
  Ltype2Token = ::T.let(nil, ::T.untyped)
  PERCENT_LTYPE = ::T.let(nil, ::T.untyped)
  PERCENT_PAREN = ::T.let(nil, ::T.untyped)
end

class RubyLex::AlreadyDefinedToken
end

class RubyLex::AlreadyDefinedToken
end

class RubyLex::SyntaxError
end

class RubyLex::SyntaxError
end

class RubyLex::TerminateLineInput
end

class RubyLex::TerminateLineInput
end

class RubyLex::TkReading2TokenDuplicateError
end

class RubyLex::TkReading2TokenDuplicateError
end

class RubyLex::TkReading2TokenNoKey
end

class RubyLex::TkReading2TokenNoKey
end

class RubyLex::TkSymbol2TokenNoKey
end

class RubyLex::TkSymbol2TokenNoKey
end

class RubyLex
  extend ::Exception2MessageMapper
  def self.debug?(); end

  def self.debug_level(); end

  def self.debug_level=(debug_level); end

  def self.included(mod); end
end

module RubyToken
  def Token(token, value=T.unsafe(nil)); end
  EXPR_ARG = ::T.let(nil, ::T.untyped)
  EXPR_BEG = ::T.let(nil, ::T.untyped)
  EXPR_CLASS = ::T.let(nil, ::T.untyped)
  EXPR_DOT = ::T.let(nil, ::T.untyped)
  EXPR_END = ::T.let(nil, ::T.untyped)
  EXPR_FNAME = ::T.let(nil, ::T.untyped)
  EXPR_MID = ::T.let(nil, ::T.untyped)
  TkReading2Token = ::T.let(nil, ::T.untyped)
  TkSymbol2Token = ::T.let(nil, ::T.untyped)
  TokenDefinitions = ::T.let(nil, ::T.untyped)
end

class RubyToken::TkALIAS
end

class RubyToken::TkALIAS
end

class RubyToken::TkAMPER
end

class RubyToken::TkAMPER
end

class RubyToken::TkAND
end

class RubyToken::TkAND
end

class RubyToken::TkANDOP
end

class RubyToken::TkANDOP
end

class RubyToken::TkAREF
end

class RubyToken::TkAREF
end

class RubyToken::TkASET
end

class RubyToken::TkASET
end

class RubyToken::TkASSIGN
end

class RubyToken::TkASSIGN
end

class RubyToken::TkASSOC
end

class RubyToken::TkASSOC
end

class RubyToken::TkAT
end

class RubyToken::TkAT
end

class RubyToken::TkBACKQUOTE
end

class RubyToken::TkBACKQUOTE
end

class RubyToken::TkBACKSLASH
end

class RubyToken::TkBACKSLASH
end

class RubyToken::TkBACK_REF
end

class RubyToken::TkBACK_REF
end

class RubyToken::TkBEGIN
end

class RubyToken::TkBEGIN
end

class RubyToken::TkBITAND
end

class RubyToken::TkBITAND
end

class RubyToken::TkBITNOT
end

class RubyToken::TkBITNOT
end

class RubyToken::TkBITOR
end

class RubyToken::TkBITOR
end

class RubyToken::TkBITXOR
end

class RubyToken::TkBITXOR
end

class RubyToken::TkBREAK
end

class RubyToken::TkBREAK
end

class RubyToken::TkCASE
end

class RubyToken::TkCASE
end

class RubyToken::TkCLASS
end

class RubyToken::TkCLASS
end

class RubyToken::TkCMP
end

class RubyToken::TkCMP
end

class RubyToken::TkCOLON
end

class RubyToken::TkCOLON
end

class RubyToken::TkCOLON2
end

class RubyToken::TkCOLON2
end

class RubyToken::TkCOLON3
end

class RubyToken::TkCOLON3
end

class RubyToken::TkCOMMA
end

class RubyToken::TkCOMMA
end

class RubyToken::TkCOMMENT
end

class RubyToken::TkCOMMENT
end

class RubyToken::TkCONSTANT
end

class RubyToken::TkCONSTANT
end

class RubyToken::TkCVAR
end

class RubyToken::TkCVAR
end

class RubyToken::TkDEF
end

class RubyToken::TkDEF
end

class RubyToken::TkDEFINED
end

class RubyToken::TkDEFINED
end

class RubyToken::TkDIV
end

class RubyToken::TkDIV
end

class RubyToken::TkDO
end

class RubyToken::TkDO
end

class RubyToken::TkDOLLAR
end

class RubyToken::TkDOLLAR
end

class RubyToken::TkDOT
end

class RubyToken::TkDOT
end

class RubyToken::TkDOT2
end

class RubyToken::TkDOT2
end

class RubyToken::TkDOT3
end

class RubyToken::TkDOT3
end

class RubyToken::TkDREGEXP
end

class RubyToken::TkDREGEXP
end

class RubyToken::TkDSTRING
end

class RubyToken::TkDSTRING
end

class RubyToken::TkDXSTRING
end

class RubyToken::TkDXSTRING
end

class RubyToken::TkELSE
end

class RubyToken::TkELSE
end

class RubyToken::TkELSIF
end

class RubyToken::TkELSIF
end

class RubyToken::TkEND
end

class RubyToken::TkEND
end

class RubyToken::TkEND_OF_SCRIPT
end

class RubyToken::TkEND_OF_SCRIPT
end

class RubyToken::TkENSURE
end

class RubyToken::TkENSURE
end

class RubyToken::TkEQ
end

class RubyToken::TkEQ
end

class RubyToken::TkEQQ
end

class RubyToken::TkEQQ
end

class RubyToken::TkError
end

class RubyToken::TkError
end

class RubyToken::TkFALSE
end

class RubyToken::TkFALSE
end

class RubyToken::TkFID
end

class RubyToken::TkFID
end

class RubyToken::TkFLOAT
end

class RubyToken::TkFLOAT
end

class RubyToken::TkFOR
end

class RubyToken::TkFOR
end

class RubyToken::TkGEQ
end

class RubyToken::TkGEQ
end

class RubyToken::TkGT
end

class RubyToken::TkGT
end

class RubyToken::TkGVAR
end

class RubyToken::TkGVAR
end

class RubyToken::TkIDENTIFIER
end

class RubyToken::TkIDENTIFIER
end

class RubyToken::TkIF
end

class RubyToken::TkIF
end

class RubyToken::TkIF_MOD
end

class RubyToken::TkIF_MOD
end

class RubyToken::TkIN
end

class RubyToken::TkIN
end

class RubyToken::TkINTEGER
end

class RubyToken::TkINTEGER
end

class RubyToken::TkIVAR
end

class RubyToken::TkIVAR
end

class RubyToken::TkId
  def initialize(seek, line_no, char_no, name); end

  def name(); end
end

class RubyToken::TkId
end

class RubyToken::TkLBRACE
end

class RubyToken::TkLBRACE
end

class RubyToken::TkLBRACK
end

class RubyToken::TkLBRACK
end

class RubyToken::TkLEQ
end

class RubyToken::TkLEQ
end

class RubyToken::TkLPAREN
end

class RubyToken::TkLPAREN
end

class RubyToken::TkLSHFT
end

class RubyToken::TkLSHFT
end

class RubyToken::TkLT
end

class RubyToken::TkLT
end

class RubyToken::TkMATCH
end

class RubyToken::TkMATCH
end

class RubyToken::TkMINUS
end

class RubyToken::TkMINUS
end

class RubyToken::TkMOD
end

class RubyToken::TkMOD
end

class RubyToken::TkMODULE
end

class RubyToken::TkMODULE
end

class RubyToken::TkMULT
end

class RubyToken::TkMULT
end

class RubyToken::TkNEQ
end

class RubyToken::TkNEQ
end

class RubyToken::TkNEXT
end

class RubyToken::TkNEXT
end

class RubyToken::TkNIL
end

class RubyToken::TkNIL
end

class RubyToken::TkNL
end

class RubyToken::TkNL
end

class RubyToken::TkNMATCH
end

class RubyToken::TkNMATCH
end

class RubyToken::TkNOT
end

class RubyToken::TkNOT
end

class RubyToken::TkNOTOP
end

class RubyToken::TkNOTOP
end

class RubyToken::TkNTH_REF
end

class RubyToken::TkNTH_REF
end

class RubyToken::TkNode
  def node(); end
end

class RubyToken::TkNode
end

class RubyToken::TkOPASGN
  def initialize(seek, line_no, char_no, op); end

  def op(); end
end

class RubyToken::TkOPASGN
end

class RubyToken::TkOR
end

class RubyToken::TkOR
end

class RubyToken::TkOROP
end

class RubyToken::TkOROP
end

class RubyToken::TkOp
  def name(); end

  def name=(name); end
end

class RubyToken::TkOp
end

class RubyToken::TkPLUS
end

class RubyToken::TkPLUS
end

class RubyToken::TkPOW
end

class RubyToken::TkPOW
end

class RubyToken::TkQUESTION
end

class RubyToken::TkQUESTION
end

class RubyToken::TkRBRACE
end

class RubyToken::TkRBRACE
end

class RubyToken::TkRBRACK
end

class RubyToken::TkRBRACK
end

class RubyToken::TkRD_COMMENT
end

class RubyToken::TkRD_COMMENT
end

class RubyToken::TkREDO
end

class RubyToken::TkREDO
end

class RubyToken::TkREGEXP
end

class RubyToken::TkREGEXP
end

class RubyToken::TkRESCUE
end

class RubyToken::TkRESCUE
end

class RubyToken::TkRETRY
end

class RubyToken::TkRETRY
end

class RubyToken::TkRETURN
end

class RubyToken::TkRETURN
end

class RubyToken::TkRPAREN
end

class RubyToken::TkRPAREN
end

class RubyToken::TkRSHFT
end

class RubyToken::TkRSHFT
end

class RubyToken::TkSELF
end

class RubyToken::TkSELF
end

class RubyToken::TkSEMICOLON
end

class RubyToken::TkSEMICOLON
end

class RubyToken::TkSPACE
end

class RubyToken::TkSPACE
end

class RubyToken::TkSTAR
end

class RubyToken::TkSTAR
end

class RubyToken::TkSTRING
end

class RubyToken::TkSTRING
end

class RubyToken::TkSUPER
end

class RubyToken::TkSUPER
end

class RubyToken::TkSYMBEG
end

class RubyToken::TkSYMBEG
end

class RubyToken::TkSYMBOL
end

class RubyToken::TkSYMBOL
end

class RubyToken::TkTHEN
end

class RubyToken::TkTHEN
end

class RubyToken::TkTRUE
end

class RubyToken::TkTRUE
end

class RubyToken::TkUMINUS
end

class RubyToken::TkUMINUS
end

class RubyToken::TkUNDEF
end

class RubyToken::TkUNDEF
end

class RubyToken::TkUNLESS
end

class RubyToken::TkUNLESS
end

class RubyToken::TkUNLESS_MOD
end

class RubyToken::TkUNLESS_MOD
end

class RubyToken::TkUNTIL
end

class RubyToken::TkUNTIL
end

class RubyToken::TkUNTIL_MOD
end

class RubyToken::TkUNTIL_MOD
end

class RubyToken::TkUPLUS
end

class RubyToken::TkUPLUS
end

class RubyToken::TkUnknownChar
  def initialize(seek, line_no, char_no, id); end

  def name(); end
end

class RubyToken::TkUnknownChar
end

class RubyToken::TkVal
  def initialize(seek, line_no, char_no, value=T.unsafe(nil)); end

  def value(); end
end

class RubyToken::TkVal
end

class RubyToken::TkWHEN
end

class RubyToken::TkWHEN
end

class RubyToken::TkWHILE
end

class RubyToken::TkWHILE
end

class RubyToken::TkWHILE_MOD
end

class RubyToken::TkWHILE_MOD
end

class RubyToken::TkXSTRING
end

class RubyToken::TkXSTRING
end

class RubyToken::TkYIELD
end

class RubyToken::TkYIELD
end

class RubyToken::Tk__FILE__
end

class RubyToken::Tk__FILE__
end

class RubyToken::Tk__LINE__
end

class RubyToken::Tk__LINE__
end

class RubyToken::TkfLBRACE
end

class RubyToken::TkfLBRACE
end

class RubyToken::TkfLBRACK
end

class RubyToken::TkfLBRACK
end

class RubyToken::TkfLPAREN
end

class RubyToken::TkfLPAREN
end

class RubyToken::TklBEGIN
end

class RubyToken::TklBEGIN
end

class RubyToken::TklEND
end

class RubyToken::TklEND
end

class RubyToken::Token
  def char_no(); end

  def initialize(seek, line_no, char_no); end

  def line_no(); end

  def seek(); end
end

class RubyToken::Token
end

module RubyToken
  def self.def_token(token_n, super_token=T.unsafe(nil), reading=T.unsafe(nil), *opts); end
end

module RubyVM::AbstractSyntaxTree
end

class RubyVM::AbstractSyntaxTree::Node
  def children(); end

  def first_column(); end

  def first_lineno(); end

  def last_column(); end

  def last_lineno(); end

  def pretty_print_children(q, names=T.unsafe(nil)); end

  def type(); end
end

class RubyVM::AbstractSyntaxTree::Node
end

module RubyVM::AbstractSyntaxTree
  def self.of(_); end

  def self.parse(_); end

  def self.parse_file(_); end
end

module RubyVM::MJIT
end

module RubyVM::MJIT
  def self.enabled?(); end

  def self.pause(*_); end

  def self.resume(); end
end

class RubyVM
  def self.resolve_feature_path(_); end
end

module SQLite3
  SQLITE_VERSION = ::T.let(nil, ::T.untyped)
  SQLITE_VERSION_NUMBER = ::T.let(nil, ::T.untyped)
  VERSION = ::T.let(nil, ::T.untyped)
end

class SQLite3::Blob
end

class SQLite3::Blob
end

module SQLite3::Constants::ColumnType
  BLOB = ::T.let(nil, ::T.untyped)
  FLOAT = ::T.let(nil, ::T.untyped)
  INTEGER = ::T.let(nil, ::T.untyped)
  NULL = ::T.let(nil, ::T.untyped)
  TEXT = ::T.let(nil, ::T.untyped)
end

module SQLite3::Constants::ErrorCode
  ABORT = ::T.let(nil, ::T.untyped)
  AUTH = ::T.let(nil, ::T.untyped)
  BUSY = ::T.let(nil, ::T.untyped)
  CANTOPEN = ::T.let(nil, ::T.untyped)
  CONSTRAINT = ::T.let(nil, ::T.untyped)
  CORRUPT = ::T.let(nil, ::T.untyped)
  DONE = ::T.let(nil, ::T.untyped)
  EMPTY = ::T.let(nil, ::T.untyped)
  ERROR = ::T.let(nil, ::T.untyped)
  FULL = ::T.let(nil, ::T.untyped)
  INTERNAL = ::T.let(nil, ::T.untyped)
  INTERRUPT = ::T.let(nil, ::T.untyped)
  IOERR = ::T.let(nil, ::T.untyped)
  LOCKED = ::T.let(nil, ::T.untyped)
  MISMATCH = ::T.let(nil, ::T.untyped)
  MISUSE = ::T.let(nil, ::T.untyped)
  NOLFS = ::T.let(nil, ::T.untyped)
  NOMEM = ::T.let(nil, ::T.untyped)
  NOTFOUND = ::T.let(nil, ::T.untyped)
  OK = ::T.let(nil, ::T.untyped)
  PERM = ::T.let(nil, ::T.untyped)
  PROTOCOL = ::T.let(nil, ::T.untyped)
  READONLY = ::T.let(nil, ::T.untyped)
  ROW = ::T.let(nil, ::T.untyped)
  SCHEMA = ::T.let(nil, ::T.untyped)
  TOOBIG = ::T.let(nil, ::T.untyped)
end

module SQLite3::Constants::Open
  AUTOPROXY = ::T.let(nil, ::T.untyped)
  CREATE = ::T.let(nil, ::T.untyped)
  DELETEONCLOSE = ::T.let(nil, ::T.untyped)
  EXCLUSIVE = ::T.let(nil, ::T.untyped)
  FULLMUTEX = ::T.let(nil, ::T.untyped)
  MAIN_DB = ::T.let(nil, ::T.untyped)
  MAIN_JOURNAL = ::T.let(nil, ::T.untyped)
  MASTER_JOURNAL = ::T.let(nil, ::T.untyped)
  MEMORY = ::T.let(nil, ::T.untyped)
  NOMUTEX = ::T.let(nil, ::T.untyped)
  PRIVATECACHE = ::T.let(nil, ::T.untyped)
  READONLY = ::T.let(nil, ::T.untyped)
  READWRITE = ::T.let(nil, ::T.untyped)
  SHAREDCACHE = ::T.let(nil, ::T.untyped)
  SUBJOURNAL = ::T.let(nil, ::T.untyped)
  TEMP_DB = ::T.let(nil, ::T.untyped)
  TEMP_JOURNAL = ::T.let(nil, ::T.untyped)
  TRANSIENT_DB = ::T.let(nil, ::T.untyped)
  URI = ::T.let(nil, ::T.untyped)
  WAL = ::T.let(nil, ::T.untyped)
end

module SQLite3::Constants::Open
end

module SQLite3::Constants::TextRep
  ANY = ::T.let(nil, ::T.untyped)
  DETERMINISTIC = ::T.let(nil, ::T.untyped)
  UTF16 = ::T.let(nil, ::T.untyped)
  UTF16BE = ::T.let(nil, ::T.untyped)
  UTF16LE = ::T.let(nil, ::T.untyped)
  UTF8 = ::T.let(nil, ::T.untyped)
end

class SQLite3::Database
  NULL_TRANSLATOR = ::T.let(nil, ::T.untyped)
end

module SQLite3::Pragmas
  AUTO_VACUUM_MODES = ::T.let(nil, ::T.untyped)
  ENCODINGS = ::T.let(nil, ::T.untyped)
  JOURNAL_MODES = ::T.let(nil, ::T.untyped)
  LOCKING_MODES = ::T.let(nil, ::T.untyped)
  SYNCHRONOUS_MODES = ::T.let(nil, ::T.untyped)
  TEMP_STORE_MODES = ::T.let(nil, ::T.untyped)
  WAL_CHECKPOINTS = ::T.let(nil, ::T.untyped)
end

module SQLite3::VersionProxy
  BUILD = ::T.let(nil, ::T.untyped)
  MAJOR = ::T.let(nil, ::T.untyped)
  MINOR = ::T.let(nil, ::T.untyped)
  STRING = ::T.let(nil, ::T.untyped)
  TINY = ::T.let(nil, ::T.untyped)
  VERSION = ::T.let(nil, ::T.untyped)
end

ScanError = StringScanner::Error

class Set
  def ==(other); end

  def ===(o); end

  def compare_by_identity(); end

  def compare_by_identity?(); end

  def divide(&func); end

  def eql?(o); end

  def flatten_merge(set, seen=T.unsafe(nil)); end

  def pretty_print(pp); end

  def pretty_print_cycle(pp); end

  def reset(); end
  InspectKey = ::T.let(nil, ::T.untyped)
end

module Shoulda::Matchers
  TERMINAL_MAX_WIDTH = ::T.let(nil, ::T.untyped)
  VERSION = ::T.let(nil, ::T.untyped)
end

class Shoulda::Matchers::ActionController::PermitMatcher::ParametersDoubleRegistry
  TOP_LEVEL = ::T.let(nil, ::T.untyped)
end

class Shoulda::Matchers::ActionController::RouteParams
  PARAMS_TO_SYMBOLIZE = ::T.let(nil, ::T.untyped)
end

class Shoulda::Matchers::ActiveModel::HaveSecurePasswordMatcher
  CORRECT_PASSWORD = ::T.let(nil, ::T.untyped)
  EXPECTED_METHODS = ::T.let(nil, ::T.untyped)
  INCORRECT_PASSWORD = ::T.let(nil, ::T.untyped)
  MESSAGES = ::T.let(nil, ::T.untyped)
end

class Shoulda::Matchers::ActiveModel::NumericalityMatchers::ComparisonMatcher
  ERROR_MESSAGES = ::T.let(nil, ::T.untyped)
end

class Shoulda::Matchers::ActiveModel::NumericalityMatchers::EvenNumberMatcher
  NON_EVEN_NUMBER_VALUE = ::T.let(nil, ::T.untyped)
end

class Shoulda::Matchers::ActiveModel::NumericalityMatchers::OddNumberMatcher
  NON_ODD_NUMBER_VALUE = ::T.let(nil, ::T.untyped)
end

class Shoulda::Matchers::ActiveModel::NumericalityMatchers::OnlyIntegerMatcher
  NON_INTEGER_VALUE = ::T.let(nil, ::T.untyped)
end

class Shoulda::Matchers::ActiveModel::ValidateInclusionOfMatcher
  ARBITRARY_OUTSIDE_DATE = ::T.let(nil, ::T.untyped)
  ARBITRARY_OUTSIDE_DATETIME = ::T.let(nil, ::T.untyped)
  ARBITRARY_OUTSIDE_DECIMAL = ::T.let(nil, ::T.untyped)
  ARBITRARY_OUTSIDE_INTEGER = ::T.let(nil, ::T.untyped)
  ARBITRARY_OUTSIDE_STRING = ::T.let(nil, ::T.untyped)
  ARBITRARY_OUTSIDE_TIME = ::T.let(nil, ::T.untyped)
  BLANK_VALUES = ::T.let(nil, ::T.untyped)
  BOOLEAN_ALLOWS_BOOLEAN_MESSAGE = ::T.let(nil, ::T.untyped)
  BOOLEAN_ALLOWS_NIL_MESSAGE = ::T.let(nil, ::T.untyped)
end

class Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher
  DEFAULT_DIFF_TO_COMPARE = ::T.let(nil, ::T.untyped)
  NON_NUMERIC_VALUE = ::T.let(nil, ::T.untyped)
  NUMERIC_NAME = ::T.let(nil, ::T.untyped)
end

class Shoulda::Matchers::ActiveRecord::AssociationMatchers::ModelReflection
  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
end

class Shoulda::Matchers::ActiveRecord::AssociationMatchers::OptionVerifier
  RELATION_OPTIONS = ::T.let(nil, ::T.untyped)
end

class Shoulda::Matchers::ActiveRecord::HaveDbColumnMatcher::DecoratedColumn
  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
end

class Shoulda::Matchers::Integrations::Libraries::Rails
  SUB_LIBRARIES = ::T.let(nil, ::T.untyped)
end

class Shoulda::Matchers::Line
  OFFSETS = ::T.let(nil, ::T.untyped)
end

class Shoulda::Matchers::Text
  LIST_ITEM_REGEXP = ::T.let(nil, ::T.untyped)
end

module Shoulda::Matchers::WordWrap
  TERMINAL_WIDTH = ::T.let(nil, ::T.untyped)
end

module SimpleCov
  VERSION = ::T.let(nil, ::T.untyped)
end

module SimpleCov::Configuration
  DEFAULT_COVERAGE_CRITERION = ::T.let(nil, ::T.untyped)
  SUPPORTED_COVERAGE_CRITERIA = ::T.let(nil, ::T.untyped)
end

module SimpleCov::ExitCodes
  EXCEPTION = ::T.let(nil, ::T.untyped)
  MAXIMUM_COVERAGE_DROP = ::T.let(nil, ::T.untyped)
  MINIMUM_COVERAGE = ::T.let(nil, ::T.untyped)
  SUCCESS = ::T.let(nil, ::T.untyped)
end

class SimpleCov::Formatter::HTMLFormatter
  VERSION = ::T.let(nil, ::T.untyped)
end

class SimpleCov::LinesClassifier
  COMMENT_LINE = ::T.let(nil, ::T.untyped)
  NOT_RELEVANT = ::T.let(nil, ::T.untyped)
  RELEVANT = ::T.let(nil, ::T.untyped)
  WHITESPACE_LINE = ::T.let(nil, ::T.untyped)
  WHITESPACE_OR_COMMENT_LINE = ::T.let(nil, ::T.untyped)
end

class SimpleCov::SourceFile
  RUBY_FILE_ENCODING_MAGIC_COMMENT_REGEX = ::T.let(nil, ::T.untyped)
  SHEBANG_REGEX = ::T.let(nil, ::T.untyped)
end

module SimpleCov::UselessResultsRemover
  ROOT_REGX = ::T.let(nil, ::T.untyped)
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
end

module Singleton::SingletonClassMethods
  def _load(str); end

  def clone(); end
end

module Singleton
  def self.__init__(klass); end
end

class Socket
  AF_CCITT = ::T.let(nil, ::T.untyped)
  AF_CHAOS = ::T.let(nil, ::T.untyped)
  AF_CNT = ::T.let(nil, ::T.untyped)
  AF_COIP = ::T.let(nil, ::T.untyped)
  AF_DATAKIT = ::T.let(nil, ::T.untyped)
  AF_DLI = ::T.let(nil, ::T.untyped)
  AF_E164 = ::T.let(nil, ::T.untyped)
  AF_ECMA = ::T.let(nil, ::T.untyped)
  AF_HYLINK = ::T.let(nil, ::T.untyped)
  AF_IMPLINK = ::T.let(nil, ::T.untyped)
  AF_ISO = ::T.let(nil, ::T.untyped)
  AF_LAT = ::T.let(nil, ::T.untyped)
  AF_LINK = ::T.let(nil, ::T.untyped)
  AF_NATM = ::T.let(nil, ::T.untyped)
  AF_NDRV = ::T.let(nil, ::T.untyped)
  AF_NETBIOS = ::T.let(nil, ::T.untyped)
  AF_NS = ::T.let(nil, ::T.untyped)
  AF_OSI = ::T.let(nil, ::T.untyped)
  AF_PPP = ::T.let(nil, ::T.untyped)
  AF_PUP = ::T.let(nil, ::T.untyped)
  AF_SIP = ::T.let(nil, ::T.untyped)
  AF_SYSTEM = ::T.let(nil, ::T.untyped)
  AI_DEFAULT = ::T.let(nil, ::T.untyped)
  AI_MASK = ::T.let(nil, ::T.untyped)
  AI_V4MAPPED_CFG = ::T.let(nil, ::T.untyped)
  EAI_BADHINTS = ::T.let(nil, ::T.untyped)
  EAI_MAX = ::T.let(nil, ::T.untyped)
  EAI_PROTOCOL = ::T.let(nil, ::T.untyped)
  IFF_ALTPHYS = ::T.let(nil, ::T.untyped)
  IFF_LINK0 = ::T.let(nil, ::T.untyped)
  IFF_LINK1 = ::T.let(nil, ::T.untyped)
  IFF_LINK2 = ::T.let(nil, ::T.untyped)
  IFF_OACTIVE = ::T.let(nil, ::T.untyped)
  IFF_SIMPLEX = ::T.let(nil, ::T.untyped)
  IPPROTO_EON = ::T.let(nil, ::T.untyped)
  IPPROTO_GGP = ::T.let(nil, ::T.untyped)
  IPPROTO_HELLO = ::T.let(nil, ::T.untyped)
  IPPROTO_MAX = ::T.let(nil, ::T.untyped)
  IPPROTO_ND = ::T.let(nil, ::T.untyped)
  IPPROTO_XTP = ::T.let(nil, ::T.untyped)
  IPV6_DONTFRAG = ::T.let(nil, ::T.untyped)
  IPV6_PATHMTU = ::T.let(nil, ::T.untyped)
  IPV6_RECVPATHMTU = ::T.let(nil, ::T.untyped)
  IPV6_USE_MIN_MTU = ::T.let(nil, ::T.untyped)
  IP_PORTRANGE = ::T.let(nil, ::T.untyped)
  IP_RECVDSTADDR = ::T.let(nil, ::T.untyped)
  IP_RECVIF = ::T.let(nil, ::T.untyped)
  LOCAL_PEERCRED = ::T.let(nil, ::T.untyped)
  MSG_EOF = ::T.let(nil, ::T.untyped)
  MSG_FLUSH = ::T.let(nil, ::T.untyped)
  MSG_HAVEMORE = ::T.let(nil, ::T.untyped)
  MSG_HOLD = ::T.let(nil, ::T.untyped)
  MSG_RCVMORE = ::T.let(nil, ::T.untyped)
  MSG_SEND = ::T.let(nil, ::T.untyped)
  PF_CCITT = ::T.let(nil, ::T.untyped)
  PF_CHAOS = ::T.let(nil, ::T.untyped)
  PF_CNT = ::T.let(nil, ::T.untyped)
  PF_COIP = ::T.let(nil, ::T.untyped)
  PF_DATAKIT = ::T.let(nil, ::T.untyped)
  PF_DLI = ::T.let(nil, ::T.untyped)
  PF_ECMA = ::T.let(nil, ::T.untyped)
  PF_HYLINK = ::T.let(nil, ::T.untyped)
  PF_IMPLINK = ::T.let(nil, ::T.untyped)
  PF_ISO = ::T.let(nil, ::T.untyped)
  PF_LAT = ::T.let(nil, ::T.untyped)
  PF_LINK = ::T.let(nil, ::T.untyped)
  PF_NATM = ::T.let(nil, ::T.untyped)
  PF_NDRV = ::T.let(nil, ::T.untyped)
  PF_NETBIOS = ::T.let(nil, ::T.untyped)
  PF_NS = ::T.let(nil, ::T.untyped)
  PF_OSI = ::T.let(nil, ::T.untyped)
  PF_PIP = ::T.let(nil, ::T.untyped)
  PF_PPP = ::T.let(nil, ::T.untyped)
  PF_PUP = ::T.let(nil, ::T.untyped)
  PF_RTIP = ::T.let(nil, ::T.untyped)
  PF_SIP = ::T.let(nil, ::T.untyped)
  PF_SYSTEM = ::T.let(nil, ::T.untyped)
  PF_XTP = ::T.let(nil, ::T.untyped)
  SCM_CREDS = ::T.let(nil, ::T.untyped)
  SO_DONTTRUNC = ::T.let(nil, ::T.untyped)
  SO_NKE = ::T.let(nil, ::T.untyped)
  SO_NOSIGPIPE = ::T.let(nil, ::T.untyped)
  SO_NREAD = ::T.let(nil, ::T.untyped)
  SO_USELOOPBACK = ::T.let(nil, ::T.untyped)
  SO_WANTMORE = ::T.let(nil, ::T.untyped)
  SO_WANTOOBFLAG = ::T.let(nil, ::T.untyped)
  TCP_NOOPT = ::T.let(nil, ::T.untyped)
  TCP_NOPUSH = ::T.let(nil, ::T.untyped)
end

module Socket::Constants
  AF_CCITT = ::T.let(nil, ::T.untyped)
  AF_CHAOS = ::T.let(nil, ::T.untyped)
  AF_CNT = ::T.let(nil, ::T.untyped)
  AF_COIP = ::T.let(nil, ::T.untyped)
  AF_DATAKIT = ::T.let(nil, ::T.untyped)
  AF_DLI = ::T.let(nil, ::T.untyped)
  AF_E164 = ::T.let(nil, ::T.untyped)
  AF_ECMA = ::T.let(nil, ::T.untyped)
  AF_HYLINK = ::T.let(nil, ::T.untyped)
  AF_IMPLINK = ::T.let(nil, ::T.untyped)
  AF_ISO = ::T.let(nil, ::T.untyped)
  AF_LAT = ::T.let(nil, ::T.untyped)
  AF_LINK = ::T.let(nil, ::T.untyped)
  AF_NATM = ::T.let(nil, ::T.untyped)
  AF_NDRV = ::T.let(nil, ::T.untyped)
  AF_NETBIOS = ::T.let(nil, ::T.untyped)
  AF_NS = ::T.let(nil, ::T.untyped)
  AF_OSI = ::T.let(nil, ::T.untyped)
  AF_PPP = ::T.let(nil, ::T.untyped)
  AF_PUP = ::T.let(nil, ::T.untyped)
  AF_SIP = ::T.let(nil, ::T.untyped)
  AF_SYSTEM = ::T.let(nil, ::T.untyped)
  AI_DEFAULT = ::T.let(nil, ::T.untyped)
  AI_MASK = ::T.let(nil, ::T.untyped)
  AI_V4MAPPED_CFG = ::T.let(nil, ::T.untyped)
  EAI_BADHINTS = ::T.let(nil, ::T.untyped)
  EAI_MAX = ::T.let(nil, ::T.untyped)
  EAI_PROTOCOL = ::T.let(nil, ::T.untyped)
  IFF_ALTPHYS = ::T.let(nil, ::T.untyped)
  IFF_LINK0 = ::T.let(nil, ::T.untyped)
  IFF_LINK1 = ::T.let(nil, ::T.untyped)
  IFF_LINK2 = ::T.let(nil, ::T.untyped)
  IFF_OACTIVE = ::T.let(nil, ::T.untyped)
  IFF_SIMPLEX = ::T.let(nil, ::T.untyped)
  IPPROTO_EON = ::T.let(nil, ::T.untyped)
  IPPROTO_GGP = ::T.let(nil, ::T.untyped)
  IPPROTO_HELLO = ::T.let(nil, ::T.untyped)
  IPPROTO_MAX = ::T.let(nil, ::T.untyped)
  IPPROTO_ND = ::T.let(nil, ::T.untyped)
  IPPROTO_XTP = ::T.let(nil, ::T.untyped)
  IPV6_DONTFRAG = ::T.let(nil, ::T.untyped)
  IPV6_PATHMTU = ::T.let(nil, ::T.untyped)
  IPV6_RECVPATHMTU = ::T.let(nil, ::T.untyped)
  IPV6_USE_MIN_MTU = ::T.let(nil, ::T.untyped)
  IP_PORTRANGE = ::T.let(nil, ::T.untyped)
  IP_RECVDSTADDR = ::T.let(nil, ::T.untyped)
  IP_RECVIF = ::T.let(nil, ::T.untyped)
  LOCAL_PEERCRED = ::T.let(nil, ::T.untyped)
  MSG_EOF = ::T.let(nil, ::T.untyped)
  MSG_FLUSH = ::T.let(nil, ::T.untyped)
  MSG_HAVEMORE = ::T.let(nil, ::T.untyped)
  MSG_HOLD = ::T.let(nil, ::T.untyped)
  MSG_RCVMORE = ::T.let(nil, ::T.untyped)
  MSG_SEND = ::T.let(nil, ::T.untyped)
  PF_CCITT = ::T.let(nil, ::T.untyped)
  PF_CHAOS = ::T.let(nil, ::T.untyped)
  PF_CNT = ::T.let(nil, ::T.untyped)
  PF_COIP = ::T.let(nil, ::T.untyped)
  PF_DATAKIT = ::T.let(nil, ::T.untyped)
  PF_DLI = ::T.let(nil, ::T.untyped)
  PF_ECMA = ::T.let(nil, ::T.untyped)
  PF_HYLINK = ::T.let(nil, ::T.untyped)
  PF_IMPLINK = ::T.let(nil, ::T.untyped)
  PF_ISO = ::T.let(nil, ::T.untyped)
  PF_LAT = ::T.let(nil, ::T.untyped)
  PF_LINK = ::T.let(nil, ::T.untyped)
  PF_NATM = ::T.let(nil, ::T.untyped)
  PF_NDRV = ::T.let(nil, ::T.untyped)
  PF_NETBIOS = ::T.let(nil, ::T.untyped)
  PF_NS = ::T.let(nil, ::T.untyped)
  PF_OSI = ::T.let(nil, ::T.untyped)
  PF_PIP = ::T.let(nil, ::T.untyped)
  PF_PPP = ::T.let(nil, ::T.untyped)
  PF_PUP = ::T.let(nil, ::T.untyped)
  PF_RTIP = ::T.let(nil, ::T.untyped)
  PF_SIP = ::T.let(nil, ::T.untyped)
  PF_SYSTEM = ::T.let(nil, ::T.untyped)
  PF_XTP = ::T.let(nil, ::T.untyped)
  SCM_CREDS = ::T.let(nil, ::T.untyped)
  SO_DONTTRUNC = ::T.let(nil, ::T.untyped)
  SO_NKE = ::T.let(nil, ::T.untyped)
  SO_NOSIGPIPE = ::T.let(nil, ::T.untyped)
  SO_NREAD = ::T.let(nil, ::T.untyped)
  SO_USELOOPBACK = ::T.let(nil, ::T.untyped)
  SO_WANTMORE = ::T.let(nil, ::T.untyped)
  SO_WANTOOBFLAG = ::T.let(nil, ::T.untyped)
  TCP_NOOPT = ::T.let(nil, ::T.untyped)
  TCP_NOPUSH = ::T.let(nil, ::T.untyped)
end

class SortedSet
  def initialize(*args, &block); end
end

class SortedSet
  def self.setup(); end
end

module StackProf
  VERSION = ::T.let(nil, ::T.untyped)
end

class StackProf::Middleware
  def call(env); end

  def initialize(app, options=T.unsafe(nil)); end
end

class StackProf::Middleware
  def self.enabled(); end

  def self.enabled=(enabled); end

  def self.enabled?(env); end

  def self.interval(); end

  def self.interval=(interval); end

  def self.metadata(); end

  def self.metadata=(metadata); end

  def self.mode(); end

  def self.mode=(mode); end

  def self.path(); end

  def self.path=(path); end

  def self.raw(); end

  def self.raw=(raw); end

  def self.save(); end
end

class String
  include ::JSON::Ext::Generator::GeneratorMethods::String
  def shellescape(); end

  def shellsplit(); end
  BLANK_RE = ::T.let(nil, ::T.untyped)
  ENCODED_BLANKS = ::T.let(nil, ::T.untyped)
end

class StringScanner
  def bol?(); end

  def initialize(*_); end
  Id = ::T.let(nil, ::T.untyped)
  Version = ::T.let(nil, ::T.untyped)
end

class Struct
  def filter(*_); end
end

Struct::Group = Etc::Group

Struct::Passwd = Etc::Passwd

Struct::Tms = Process::Tms

class SynchronizedDelegator
  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
end

module TZInfo::RubyCoreSupport
  HALF_DAYS_IN_DAY = ::T.let(nil, ::T.untyped)
end

class TZInfo::ZoneinfoDataSource
  DEFAULT_ALTERNATE_ISO3166_TAB_SEARCH_PATH = ::T.let(nil, ::T.untyped)
  DEFAULT_SEARCH_PATH = ::T.let(nil, ::T.untyped)
end

class TZInfo::ZoneinfoTimezoneInfo
  MAX_TIMESTAMP = ::T.let(nil, ::T.untyped)
  MIN_TIMESTAMP = ::T.let(nil, ::T.untyped)
end

class Tempfile
  def _close(); end

  def inspect(); 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

module ThreadSafe
  NULL = ::T.let(nil, ::T.untyped)
  VERSION = ::T.let(nil, ::T.untyped)
end

ThreadSafe::Array = Array

class ThreadSafe::AtomicReferenceCacheBackend
  def [](key); end

  def []=(key, value); end

  def clear(); end

  def compute(key); end

  def compute_if_absent(key); end

  def compute_if_present(key); end

  def delete(key); end

  def delete_pair(key, value); end

  def each_pair(); end

  def empty?(); end

  def get_and_set(key, value); end

  def get_or_default(key, else_value=T.unsafe(nil)); end

  def initialize(options=T.unsafe(nil)); end

  def key?(key); end

  def merge_pair(key, value); end

  def replace_if_exists(key, new_value); end

  def replace_pair(key, old_value, new_value); end

  def size(); end
  DEFAULT_CAPACITY = ::T.let(nil, ::T.untyped)
  HASH_BITS = ::T.let(nil, ::T.untyped)
  LOCKED = ::T.let(nil, ::T.untyped)
  MAX_CAPACITY = ::T.let(nil, ::T.untyped)
  MOVED = ::T.let(nil, ::T.untyped)
  NOW_RESIZING = ::T.let(nil, ::T.untyped)
  TRANSFER_BUFFER_SIZE = ::T.let(nil, ::T.untyped)
  WAITING = ::T.let(nil, ::T.untyped)
end

class ThreadSafe::AtomicReferenceCacheBackend::Node
  include ::ThreadSafe::Util::CheapLockable
  def initialize(hash, key, value, next_node=T.unsafe(nil)); end

  def key(); end

  def key?(key); end

  def locked?(); end

  def matches?(key, hash); end

  def pure_hash(); end

  def try_await_lock(table, i); end

  def try_lock_via_hash(node_hash=T.unsafe(nil)); end

  def unlock_via_hash(locked_hash, node_hash); end
  HASH_BITS = ::T.let(nil, ::T.untyped)
  LOCKED = ::T.let(nil, ::T.untyped)
  MOVED = ::T.let(nil, ::T.untyped)
  SPIN_LOCK_ATTEMPTS = ::T.let(nil, ::T.untyped)
  WAITING = ::T.let(nil, ::T.untyped)
end

class ThreadSafe::AtomicReferenceCacheBackend::Node
  extend ::ThreadSafe::Util::Volatile
  def self.locked_hash?(hash); end
end

class ThreadSafe::AtomicReferenceCacheBackend::Table
  def cas_new_node(i, hash, key, value); end

  def delete_node_at(i, node, predecessor_node); end

  def try_lock_via_hash(i, node, node_hash); end

  def try_to_cas_in_computed(i, hash, key); end
end

class ThreadSafe::AtomicReferenceCacheBackend::Table
end

class ThreadSafe::AtomicReferenceCacheBackend
  extend ::ThreadSafe::Util::Volatile
end

ThreadSafe::ConcurrentCacheBackend = ThreadSafe::MriCacheBackend

ThreadSafe::Hash = Hash

class ThreadSafe::MriCacheBackend
  WRITE_LOCK = ::T.let(nil, ::T.untyped)
end

class ThreadSafe::SynchronizedCacheBackend
  include ::Mutex_m
  def lock(); end

  def locked?(); end

  def synchronize(&block); end

  def try_lock(); end

  def unlock(); end
end

class ThreadSafe::SynchronizedCacheBackend
end

module ThreadSafe::Util
  CPU_COUNT = ::T.let(nil, ::T.untyped)
  FIXNUM_BIT_SIZE = ::T.let(nil, ::T.untyped)
  MAX_INT = ::T.let(nil, ::T.untyped)
end

class ThreadSafe::Util::Adder
  def add(x); end

  def decrement(); end

  def increment(); end

  def reset(); end

  def sum(); end
end

class ThreadSafe::Util::Adder
end

class ThreadSafe::Util::AtomicReference
  def compare_and_set(old_value, new_value); end

  def get(); end

  def initialize(value=T.unsafe(nil)); end

  def set(new_value); end

  def value(); end

  def value=(new_value); end
end

class ThreadSafe::Util::AtomicReference
end

module ThreadSafe::Util::CheapLockable
  def cas_mutex(old_value, new_value); end

  def compare_and_set_mutex(old_value, new_value); end

  def lazy_set_mutex(value); end

  def mutex(); end

  def mutex=(value); end
end

module ThreadSafe::Util::CheapLockable
  extend ::ThreadSafe::Util::Volatile
end

class ThreadSafe::Util::PowerOfTwoTuple
  def hash_to_index(hash); end

  def next_in_size_table(); end

  def volatile_get_by_hash(hash); end

  def volatile_set_by_hash(hash, value); end
end

class ThreadSafe::Util::PowerOfTwoTuple
end

class ThreadSafe::Util::Striped64
  def busy?(); end

  def initialize(); end

  def retry_update(x, hash_code, was_uncontended); end
  THREAD_LOCAL_KEY = ::T.let(nil, ::T.untyped)
end

class ThreadSafe::Util::Striped64::Cell
  def cas(old_value, new_value); end

  def cas_computed(); end

  def padding_(); end
end

class ThreadSafe::Util::Striped64::Cell
end

class ThreadSafe::Util::Striped64
  extend ::ThreadSafe::Util::Volatile
end

module ThreadSafe::Util::Volatile
  def attr_volatile(*attr_names); end
end

module ThreadSafe::Util::Volatile
end

class ThreadSafe::Util::VolatileTuple
  include ::Enumerable
  def cas(i, old_value, new_value); end

  def compare_and_set(i, old_value, new_value); end

  def each(&blk); end

  def initialize(size); end

  def size(); end

  def volatile_get(i); end

  def volatile_set(i, value); end
end

class ThreadSafe::Util::VolatileTuple
end

module ThreadSafe::Util::XorShiftRandom
  def get(); end

  def xorshift(x); end
  MAX_XOR_SHIFTABLE_INT = ::T.let(nil, ::T.untyped)
end

module ThreadSafe::Util::XorShiftRandom
  extend ::ThreadSafe::Util::XorShiftRandom
end

module ThreadSafe::Util
end

class Time
  COMMON_YEAR_DAYS_IN_MONTH = ::T.let(nil, ::T.untyped)
  DATE_FORMATS = ::T.let(nil, ::T.untyped)
end

class Timecop
  VERSION = ::T.let(nil, ::T.untyped)
end

class TracePoint
  def __enable(_, _1); end

  def eval_script(); end

  def instruction_sequence(); end

  def parameters(); end
end

class TrueClass
  include ::JSON::Ext::Generator::GeneratorMethods::TrueClass
end

module URI
  include ::URI::RFC2396_REGEXP
end

class URI::FTP
  def 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::File
end

class URI::HTTP
  def buffer_open(buf, proxy, options); 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

URI::Parser = URI::RFC2396_Parser

URI::REGEXP = URI::RFC2396_REGEXP

class URI::RFC2396_Parser
  def initialize(opts=T.unsafe(nil)); end
end

class URI::RFC3986_Parser
  def join(*uris); end

  def parse(uri); end

  def regexp(); end

  def split(uri); end
  RFC3986_relative_ref = ::T.let(nil, ::T.untyped)
end

module URI::Util
  def self.make_components_hash(klass, array_hash); end
end

module URI
  extend ::URI::Escape
  def self.get_encoding(label); end
end

module Unicode::DisplayWidth
  DATA_DIRECTORY = ::T.let(nil, ::T.untyped)
  DEPTHS = ::T.let(nil, ::T.untyped)
  INDEX = ::T.let(nil, ::T.untyped)
  INDEX_FILENAME = ::T.let(nil, ::T.untyped)
  NO_STRING_EXT = ::T.let(nil, ::T.untyped)
  UNICODE_VERSION = ::T.let(nil, ::T.untyped)
  VERSION = ::T.let(nil, ::T.untyped)
end

module UnicodeNormalize
end

module UnicodeNormalize
end

module Warning
  extend ::Warning
end

class WeakRef
  def initialize(orig); end
  RUBYGEMS_ACTIVATION_MONITOR = ::T.let(nil, ::T.untyped)
end

class Zlib::Deflate
  def initialize(*_); end
end

class Zlib::GzipReader
  def initialize(*_); end
end

class Zlib::GzipWriter
  def initialize(*_); end
end

class Zlib::Inflate
  def initialize(*_); end
end