tapioca: init and sync. 145 errors => 28 errors

Library/Homebrew/sorbet/rbi/gems/activesupport@6.0.3.1.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: false
+
+

Library/Homebrew/sorbet/rbi/gems/ast@2.4.1.rbi

@@ -0,0 +1,53 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+module AST
+end
+
+class AST::Node
+  def initialize(type, children = _, properties = _); end
+
+  def +(array); end
+  def <<(element); end
+  def ==(other); end
+  def append(element); end
+  def children; end
+  def clone; end
+  def concat(array); end
+  def dup; end
+  def eql?(other); end
+  def hash; end
+  def inspect(indent = _); end
+  def to_a; end
+  def to_ast; end
+  def to_s(indent = _); end
+  def to_sexp(indent = _); end
+  def to_sexp_array; end
+  def type; end
+  def updated(type = _, children = _, properties = _); end
+
+  protected
+
+  def assign_properties(properties); end
+  def fancy_type; end
+
+  private
+
+  def original_dup; end
+end
+
+class AST::Processor
+  include(::AST::Processor::Mixin)
+end
+
+module AST::Processor::Mixin
+  def handler_missing(node); end
+  def process(node); end
+  def process_all(nodes); end
+end
+
+module AST::Sexp
+  def s(type, *children); end
+end

Library/Homebrew/sorbet/rbi/gems/byebug@11.1.3.rbi

@@ -0,0 +1,15 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+module Byebug
+  def self.attach; end
+  def self.spawn(host = _, port = _); end
+end
+
+module Kernel
+  def byebug; end
+  def debugger; end
+  def remote_byebug(host = _, port = _); end
+end

Library/Homebrew/sorbet/rbi/gems/coderay@1.1.3.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/connection_pool@2.2.3.rbi

@@ -0,0 +1,65 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+class ConnectionPool
+  def initialize(options = _, &block); end
+
+  def available; end
+  def checkin; end
+  def checkout(options = _); end
+  def shutdown(&block); end
+  def size; end
+  def with(options = _); end
+
+  def self.wrap(options, &block); end
+end
+
+ConnectionPool::DEFAULTS = T.let(T.unsafe(nil), Hash)
+
+class ConnectionPool::Error < ::RuntimeError
+end
+
+class ConnectionPool::PoolShuttingDownError < ::ConnectionPool::Error
+end
+
+class ConnectionPool::TimedStack
+  def initialize(size = _, &block); end
+
+  def <<(obj, options = _); end
+  def empty?; end
+  def length; end
+  def max; end
+  def pop(timeout = _, options = _); end
+  def push(obj, options = _); end
+  def shutdown(&block); end
+
+  private
+
+  def connection_stored?(options = _); end
+  def current_time; end
+  def fetch_connection(options = _); end
+  def shutdown_connections(options = _); end
+  def store_connection(obj, options = _); end
+  def try_create(options = _); end
+end
+
+class ConnectionPool::TimeoutError < ::Timeout::Error
+end
+
+ConnectionPool::VERSION = T.let(T.unsafe(nil), String)
+
+class ConnectionPool::Wrapper < ::BasicObject
+  def initialize(options = _, &block); end
+
+  def method_missing(name, *args, &block); end
+  def pool_available; end
+  def pool_shutdown(&block); end
+  def pool_size; end
+  def respond_to?(id, *args); end
+  def with(&block); end
+  def wrapped_pool; end
+end
+
+ConnectionPool::Wrapper::METHODS = T.let(T.unsafe(nil), Array)

Library/Homebrew/sorbet/rbi/gems/coveralls@0.8.23.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/diff-lcs@1.3.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/docile@1.3.2.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/domain_name@0.5.20190701.rbi

@@ -0,0 +1,88 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+class DomainName
+  def initialize(hostname); end
+
+  def <(other); end
+  def <=(other); end
+  def <=>(other); end
+  def ==(other); end
+  def >(other); end
+  def >=(other); end
+  def canonical?; end
+  def canonical_tld?; end
+  def cookie_domain?(domain, host_only = _); end
+  def domain; end
+  def domain_idn; end
+  def hostname; end
+  def hostname_idn; end
+  def idn; end
+  def inspect; end
+  def ipaddr; end
+  def ipaddr?; end
+  def superdomain; end
+  def tld; end
+  def tld_idn; end
+  def to_s; end
+  def to_str; end
+  def uri_host; end
+
+  def self.etld_data; end
+  def self.normalize(domain); end
+end
+
+DomainName::DOT = T.let(T.unsafe(nil), String)
+
+DomainName::ETLD_DATA = T.let(T.unsafe(nil), Hash)
+
+DomainName::ETLD_DATA_DATE = T.let(T.unsafe(nil), String)
+
+module DomainName::Punycode
+  def self.decode(string); end
+  def self.decode_hostname(hostname); end
+  def self.encode(string); end
+  def self.encode_hostname(hostname); end
+end
+
+class DomainName::Punycode::ArgumentError < ::ArgumentError
+end
+
+DomainName::Punycode::BASE = T.let(T.unsafe(nil), Integer)
+
+class DomainName::Punycode::BufferOverflowError < ::DomainName::Punycode::ArgumentError
+end
+
+DomainName::Punycode::CUTOFF = T.let(T.unsafe(nil), Integer)
+
+DomainName::Punycode::DAMP = T.let(T.unsafe(nil), Integer)
+
+DomainName::Punycode::DECODE_DIGIT = T.let(T.unsafe(nil), Hash)
+
+DomainName::Punycode::DELIMITER = T.let(T.unsafe(nil), String)
+
+DomainName::Punycode::DOT = T.let(T.unsafe(nil), String)
+
+DomainName::Punycode::ENCODE_DIGIT = T.let(T.unsafe(nil), Proc)
+
+DomainName::Punycode::INITIAL_BIAS = T.let(T.unsafe(nil), Integer)
+
+DomainName::Punycode::INITIAL_N = T.let(T.unsafe(nil), Integer)
+
+DomainName::Punycode::LOBASE = T.let(T.unsafe(nil), Integer)
+
+DomainName::Punycode::MAXINT = T.let(T.unsafe(nil), Integer)
+
+DomainName::Punycode::PREFIX = T.let(T.unsafe(nil), String)
+
+DomainName::Punycode::RE_NONBASIC = T.let(T.unsafe(nil), Regexp)
+
+DomainName::Punycode::SKEW = T.let(T.unsafe(nil), Integer)
+
+DomainName::Punycode::TMAX = T.let(T.unsafe(nil), Integer)
+
+DomainName::Punycode::TMIN = T.let(T.unsafe(nil), Integer)
+
+DomainName::VERSION = T.let(T.unsafe(nil), String)

Library/Homebrew/sorbet/rbi/gems/hpricot@0.8.6.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/http-cookie@1.0.3.rbi

@@ -0,0 +1,216 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+module HTTP
+end
+
+class HTTP::Cookie
+  include(::Mechanize::CookieDeprecated)
+  include(::Mechanize::CookieIMethods)
+  include(::Comparable)
+  extend(::Mechanize::CookieDeprecated)
+  extend(::Mechanize::CookieCMethods)
+
+  def initialize(*args); end
+
+  def <=>(other); end
+  def acceptable?; end
+  def acceptable_from_uri?(uri); end
+  def accessed_at; end
+  def accessed_at=(_); end
+  def cookie_value; end
+  def created_at; end
+  def created_at=(_); end
+  def domain; end
+  def domain=(domain); end
+  def domain_name; end
+  def dot_domain; end
+  def encode_with(coder); end
+  def expire!; end
+  def expired?(time = _); end
+  def expires; end
+  def expires=(t); end
+  def expires_at; end
+  def expires_at=(t); end
+  def for_domain; end
+  def for_domain=(_); end
+  def for_domain?; end
+  def httponly; end
+  def httponly=(_); end
+  def httponly?; end
+  def init_with(coder); end
+  def inspect; end
+  def max_age; end
+  def max_age=(sec); end
+  def name; end
+  def name=(name); end
+  def origin; end
+  def origin=(origin); end
+  def path; end
+  def path=(path); end
+  def secure; end
+  def secure=(_); end
+  def secure?; end
+  def session; end
+  def session?; end
+  def set_cookie_value; end
+  def to_s; end
+  def to_yaml_properties; end
+  def valid_for_uri?(uri); end
+  def value; end
+  def value=(value); end
+  def yaml_initialize(tag, map); end
+
+  def self.cookie_value(cookies); end
+  def self.cookie_value_to_hash(cookie_value); end
+  def self.path_match?(base_path, target_path); end
+end
+
+HTTP::Cookie::MAX_COOKIES_PER_DOMAIN = T.let(T.unsafe(nil), Integer)
+
+HTTP::Cookie::MAX_COOKIES_TOTAL = T.let(T.unsafe(nil), Integer)
+
+HTTP::Cookie::MAX_LENGTH = T.let(T.unsafe(nil), Integer)
+
+HTTP::Cookie::PERSISTENT_PROPERTIES = T.let(T.unsafe(nil), Array)
+
+class HTTP::Cookie::Scanner < ::StringScanner
+  def initialize(string, logger = _); end
+
+  def parse_cookie_date(s); end
+  def scan_cookie; end
+  def scan_dquoted; end
+  def scan_name; end
+  def scan_name_value(comma_as_separator = _); end
+  def scan_set_cookie; end
+  def scan_value(comma_as_separator = _); end
+  def skip_wsp; end
+
+  private
+
+  def tuple_to_time(day_of_month, month, year, time); end
+
+  def self.quote(s); end
+end
+
+HTTP::Cookie::Scanner::RE_BAD_CHAR = T.let(T.unsafe(nil), Regexp)
+
+HTTP::Cookie::Scanner::RE_COOKIE_COMMA = T.let(T.unsafe(nil), Regexp)
+
+HTTP::Cookie::Scanner::RE_NAME = T.let(T.unsafe(nil), Regexp)
+
+HTTP::Cookie::Scanner::RE_WSP = T.let(T.unsafe(nil), Regexp)
+
+HTTP::Cookie::UNIX_EPOCH = T.let(T.unsafe(nil), Time)
+
+HTTP::Cookie::VERSION = T.let(T.unsafe(nil), String)
+
+class HTTP::CookieJar
+  include(::Mechanize::CookieDeprecated)
+  include(::Mechanize::CookieJarIMethods)
+  include(::Enumerable)
+
+  def initialize(options = _); end
+
+  def <<(cookie); end
+  def cleanup(session = _); end
+  def clear; end
+  def cookies(url = _); end
+  def delete(cookie); end
+  def each(uri = _, &block); end
+  def empty?(url = _); end
+  def load(readable, *options); end
+  def parse(set_cookie, origin, options = _); end
+  def save(writable, *options); end
+  def store; end
+
+  private
+
+  def get_impl(base, value, *args); end
+  def initialize_copy(other); end
+
+  def self.const_missing(name); end
+end
+
+class HTTP::CookieJar::AbstractSaver
+  def initialize(options = _); end
+
+  def load(io, jar); end
+  def save(io, jar); end
+
+  private
+
+  def default_options; end
+
+  def self.class_to_symbol(klass); end
+  def self.implementation(symbol); end
+  def self.inherited(subclass); end
+end
+
+class HTTP::CookieJar::YAMLSaver < ::HTTP::CookieJar::AbstractSaver
+  def load(io, jar); end
+  def save(io, jar); end
+
+  private
+
+  def default_options; end
+end
+
+class HTTP::CookieJar::AbstractStore
+  include(::MonitorMixin)
+  include(::Enumerable)
+
+  def initialize(options = _); end
+
+  def add(cookie); end
+  def cleanup(session = _); end
+  def clear; end
+  def delete(cookie); end
+  def each(uri = _, &block); end
+  def empty?; end
+
+  private
+
+  def default_options; end
+  def initialize_copy(other); end
+
+  def self.class_to_symbol(klass); end
+  def self.implementation(symbol); end
+  def self.inherited(subclass); end
+end
+
+class HTTP::CookieJar::CookiestxtSaver < ::HTTP::CookieJar::AbstractSaver
+  def load(io, jar); end
+  def save(io, jar); end
+
+  private
+
+  def cookie_to_record(cookie); end
+  def default_options; end
+  def parse_record(line); end
+end
+
+HTTP::CookieJar::CookiestxtSaver::False = T.let(T.unsafe(nil), String)
+
+HTTP::CookieJar::CookiestxtSaver::HTTPONLY_PREFIX = T.let(T.unsafe(nil), String)
+
+HTTP::CookieJar::CookiestxtSaver::RE_HTTPONLY_PREFIX = T.let(T.unsafe(nil), Regexp)
+
+HTTP::CookieJar::CookiestxtSaver::True = T.let(T.unsafe(nil), String)
+
+class HTTP::CookieJar::HashStore < ::HTTP::CookieJar::AbstractStore
+  def initialize(options = _); end
+
+  def add(cookie); end
+  def cleanup(session = _); end
+  def clear; end
+  def default_options; end
+  def delete(cookie); end
+  def each(uri = _); end
+
+  private
+
+  def initialize_copy(other); end
+end

Library/Homebrew/sorbet/rbi/gems/i18n@1.8.3.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/json@2.3.0.rbi

@@ -0,0 +1,87 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+class Class < ::Module
+  def json_creatable?; end
+end
+
+module JSON
+
+  private
+
+  def dump(obj, anIO = _, limit = _); end
+  def fast_generate(obj, opts = _); end
+  def fast_unparse(obj, opts = _); end
+  def generate(obj, opts = _); end
+  def load(source, proc = _, options = _); end
+  def parse(source, opts = _); end
+  def parse!(source, opts = _); end
+  def pretty_generate(obj, opts = _); end
+  def pretty_unparse(obj, opts = _); end
+  def recurse_proc(result, &proc); end
+  def restore(source, proc = _, options = _); end
+  def unparse(obj, opts = _); end
+
+  def self.[](object, opts = _); end
+  def self.create_id; end
+  def self.create_id=(_); end
+  def self.deep_const_get(path); end
+  def self.dump(obj, anIO = _, limit = _); end
+  def self.dump_default_options; end
+  def self.dump_default_options=(_); end
+  def self.fast_generate(obj, opts = _); end
+  def self.fast_unparse(obj, opts = _); end
+  def self.generate(obj, opts = _); end
+  def self.generator; end
+  def self.generator=(generator); end
+  def self.iconv(to, from, string); end
+  def self.load(source, proc = _, options = _); end
+  def self.load_default_options; end
+  def self.load_default_options=(_); end
+  def self.parse(source, opts = _); end
+  def self.parse!(source, opts = _); end
+  def self.parser; end
+  def self.parser=(parser); end
+  def self.pretty_generate(obj, opts = _); end
+  def self.pretty_unparse(obj, opts = _); end
+  def self.recurse_proc(result, &proc); end
+  def self.restore(source, proc = _, options = _); end
+  def self.state; end
+  def self.state=(_); end
+  def self.unparse(obj, opts = _); end
+end
+
+class JSON::GenericObject < ::OpenStruct
+  def as_json(*_); end
+  def to_hash; end
+  def to_json(*a); end
+  def |(other); end
+
+  def self.dump(obj, *args); end
+  def self.from_hash(object); end
+  def self.json_creatable=(_); end
+  def self.json_creatable?; end
+  def self.json_create(data); end
+  def self.load(source, proc = _, opts = _); end
+end
+
+class JSON::JSONError < ::StandardError
+  def self.wrap(exception); end
+end
+
+JSON::Parser = JSON::Ext::Parser
+
+JSON::State = JSON::Ext::Generator::State
+
+JSON::UnparserError = JSON::GeneratorError
+
+module Kernel
+
+  private
+
+  def JSON(object, *args); end
+  def j(*objs); end
+  def jj(*objs); end
+end

Library/Homebrew/sorbet/rbi/gems/method_source@1.0.0.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/mime-types-data@3.2020.0512.rbi

@@ -0,0 +1,64 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+module MIME
+end
+
+class MIME::Types
+  include(::Enumerable)
+  extend(::Enumerable)
+
+  def initialize; end
+
+  def [](type_id, complete: _, registered: _); end
+  def add(*types); end
+  def add_type(type, quiet = _); end
+  def count; end
+  def each; end
+  def inspect; end
+  def of(filename); end
+  def type_for(filename); end
+
+  private
+
+  def add_type_variant!(mime_type); end
+  def index_extensions!(mime_type); end
+  def match(pattern); end
+  def prune_matches(matches, complete, registered); end
+  def reindex_extensions!(mime_type); end
+
+  def self.[](type_id, complete: _, registered: _); end
+  def self.add(*types); end
+  def self.count; end
+  def self.each; end
+  def self.logger; end
+  def self.logger=(_); end
+  def self.new(*_); end
+  def self.of(filename); end
+  def self.type_for(filename); end
+end
+
+class MIME::Types::Cache < ::Struct
+  def data; end
+  def data=(_); end
+  def version; end
+  def version=(_); end
+
+  def self.[](*_); end
+  def self.inspect; end
+  def self.load(cache_file = _); end
+  def self.members; end
+  def self.new(*_); end
+  def self.save(types = _, cache_file = _); end
+end
+
+module MIME::Types::Data
+end
+
+MIME::Types::Data::PATH = T.let(T.unsafe(nil), String)
+
+MIME::Types::Data::VERSION = T.let(T.unsafe(nil), String)
+
+MIME::Types::VERSION = T.let(T.unsafe(nil), String)

Library/Homebrew/sorbet/rbi/gems/mime-types@3.3.1.rbi

@@ -0,0 +1,253 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+module MIME
+end
+
+class MIME::Type
+  include(::Comparable)
+
+  def initialize(content_type); end
+
+  def <=>(other); end
+  def add_extensions(*extensions); end
+  def ascii?; end
+  def binary?; end
+  def complete?; end
+  def content_type; end
+  def default_encoding; end
+  def docs; end
+  def docs=(_); end
+  def encode_with(coder); end
+  def encoding; end
+  def encoding=(enc); end
+  def eql?(other); end
+  def extensions; end
+  def extensions=(value); end
+  def friendly(lang = _); end
+  def i18n_key; end
+  def init_with(coder); end
+  def inspect; end
+  def like?(other); end
+  def media_type; end
+  def obsolete; end
+  def obsolete=(_); end
+  def obsolete?; end
+  def preferred_extension; end
+  def preferred_extension=(value); end
+  def priority_compare(other); end
+  def raw_media_type; end
+  def raw_sub_type; end
+  def registered; end
+  def registered=(_); end
+  def registered?; end
+  def signature; end
+  def signature=(_); end
+  def signature?; end
+  def simplified; end
+  def sub_type; end
+  def to_h; end
+  def to_json(*args); end
+  def to_s; end
+  def to_str; end
+  def use_instead; end
+  def use_instead=(_); end
+  def xref_urls; end
+  def xrefs; end
+  def xrefs=(xrefs); end
+
+  private
+
+  def content_type=(type_string); end
+  def intern_string(string); end
+  def xref_map(values, helper); end
+  def xref_url_for_draft(value); end
+  def xref_url_for_person(value); end
+  def xref_url_for_rfc(value); end
+  def xref_url_for_rfc_errata(value); end
+  def xref_url_for_template(value); end
+
+  def self.i18n_key(content_type); end
+  def self.match(content_type); end
+  def self.simplified(content_type, remove_x_prefix: _); end
+end
+
+class MIME::Type::Columnar < ::MIME::Type
+  def initialize(container, content_type, extensions); end
+
+  def docs(*args); end
+  def docs=(*args); end
+  def encode_with(coder); end
+  def encoding(*args); end
+  def encoding=(*args); end
+  def friendly(*args); end
+  def obsolete(*args); end
+  def obsolete=(*args); end
+  def obsolete?(*args); end
+  def preferred_extension(*args); end
+  def preferred_extension=(*args); end
+  def registered(*args); end
+  def registered=(*args); end
+  def registered?(*args); end
+  def signature(*args); end
+  def signature=(*args); end
+  def signature?(*args); end
+  def use_instead(*args); end
+  def use_instead=(*args); end
+  def xref_urls(*args); end
+  def xrefs(*args); end
+  def xrefs=(*args); end
+end
+
+class MIME::Type::InvalidContentType < ::ArgumentError
+  def initialize(type_string); end
+
+  def to_s; end
+end
+
+class MIME::Type::InvalidEncoding < ::ArgumentError
+  def initialize(encoding); end
+
+  def to_s; end
+end
+
+MIME::Type::VERSION = T.let(T.unsafe(nil), String)
+
+class MIME::Types
+  include(::Enumerable)
+  extend(::Enumerable)
+
+  def initialize; end
+
+  def [](type_id, complete: _, registered: _); end
+  def add(*types); end
+  def add_type(type, quiet = _); end
+  def count; end
+  def each; end
+  def inspect; end
+  def of(filename); end
+  def type_for(filename); end
+
+  private
+
+  def add_type_variant!(mime_type); end
+  def index_extensions!(mime_type); end
+  def match(pattern); end
+  def prune_matches(matches, complete, registered); end
+  def reindex_extensions!(mime_type); end
+
+  def self.[](type_id, complete: _, registered: _); end
+  def self.add(*types); end
+  def self.count; end
+  def self.each; end
+  def self.logger; end
+  def self.logger=(_); end
+  def self.new(*_); end
+  def self.of(filename); end
+  def self.type_for(filename); end
+end
+
+class MIME::Types::Cache < ::Struct
+  def data; end
+  def data=(_); end
+  def version; end
+  def version=(_); end
+
+  def self.[](*_); end
+  def self.inspect; end
+  def self.load(cache_file = _); end
+  def self.members; end
+  def self.new(*_); end
+  def self.save(types = _, cache_file = _); end
+end
+
+module MIME::Types::Columnar
+  def load_base_data(path); end
+
+  private
+
+  def arr(line); end
+  def dict(line, array: _); end
+  def each_file_line(name, lookup = _); end
+  def flag(line); end
+  def load_docs; end
+  def load_encoding; end
+  def load_flags; end
+  def load_friendly; end
+  def load_preferred_extension; end
+  def load_use_instead; end
+  def load_xrefs; end
+  def opt(line); end
+
+  def self.extended(obj); end
+end
+
+MIME::Types::Columnar::LOAD_MUTEX = T.let(T.unsafe(nil), Thread::Mutex)
+
+class MIME::Types::Container
+  extend(::Forwardable)
+
+  def initialize(hash = _); end
+
+  def ==(*args, &block); end
+  def [](key); end
+  def []=(key, value); end
+  def add(key, value); end
+  def count(*args, &block); end
+  def each(*args, &block); end
+  def each_value(*args, &block); end
+  def empty?(*args, &block); end
+  def encode_with(coder); end
+  def flat_map(*args, &block); end
+  def init_with(coder); end
+  def keys(*args, &block); end
+  def marshal_dump; end
+  def marshal_load(hash); end
+  def merge(other); end
+  def merge!(other); end
+  def select(*args, &block); end
+  def to_hash; end
+  def values(*args, &block); end
+
+  protected
+
+  def container; end
+  def container=(_); end
+  def normalize; end
+end
+
+class MIME::Types::Loader
+  def initialize(path = _, container = _); end
+
+  def container; end
+  def load(options = _); end
+  def load_columnar; end
+  def load_json; end
+  def load_yaml; end
+  def path; end
+
+  private
+
+  def columnar_path; end
+  def json_path; end
+  def yaml_path; end
+
+  def self.load(options = _); end
+  def self.load_from_json(filename); end
+  def self.load_from_yaml(filename); end
+end
+
+MIME::Types::VERSION = T.let(T.unsafe(nil), String)
+
+class MIME::Types::WarnLogger < ::Logger
+  def initialize(_one, _two = _, _three = _); end
+end
+
+class MIME::Types::WarnLogger::WarnLogDevice < ::Logger::LogDevice
+  def initialize(*_); end
+
+  def close; end
+  def write(m); end
+end

Library/Homebrew/sorbet/rbi/gems/mini_portile2@2.4.0.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/minitest@5.14.1.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/mustache@1.1.1.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/net-http-digest_auth@1.4.1.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/net-http-persistent@4.0.0.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/ntlm-http@0.1.1.rbi

@@ -0,0 +1,232 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+module Net::NTLM
+  def self.apply_des(plain, keys); end
+  def self.decode_utf16le(str); end
+  def self.encode_utf16le(str); end
+  def self.gen_keys(str); end
+  def self.lm_hash(password); end
+  def self.lm_response(arg); end
+  def self.lmv2_response(arg, opt = _); end
+  def self.ntlm2_session(arg, opt = _); end
+  def self.ntlm_hash(password, opt = _); end
+  def self.ntlm_response(arg); end
+  def self.ntlmv2_hash(user, password, target, opt = _); end
+  def self.ntlmv2_response(arg, opt = _); end
+  def self.pack_int64le(val); end
+  def self.split7(str); end
+  def self.swap16(str); end
+end
+
+class Net::NTLM::Blob < ::Net::NTLM::FieldSet
+  def blob_signature; end
+  def blob_signature=(val); end
+  def challenge; end
+  def challenge=(val); end
+  def reserved; end
+  def reserved=(val); end
+  def target_info; end
+  def target_info=(val); end
+  def timestamp; end
+  def timestamp=(val); end
+  def unknown1; end
+  def unknown1=(val); end
+  def unknown2; end
+  def unknown2=(val); end
+
+  def self.inherited(subclass); end
+end
+
+class Net::NTLM::Field
+  def initialize(opts); end
+
+  def active; end
+  def active=(_); end
+  def size; end
+  def value; end
+  def value=(_); end
+end
+
+class Net::NTLM::FieldSet
+  def initialize; end
+
+  def [](name); end
+  def []=(name, val); end
+  def disable(name); end
+  def enable(name); end
+  def parse(str, offset = _); end
+  def serialize; end
+  def size; end
+
+  def self.define(&block); end
+  def self.int16LE(name, opts); end
+  def self.int32LE(name, opts); end
+  def self.int64LE(name, opts); end
+  def self.names; end
+  def self.opts; end
+  def self.prototypes; end
+  def self.security_buffer(name, opts); end
+  def self.string(name, opts); end
+  def self.types; end
+end
+
+class Net::NTLM::Int16LE < ::Net::NTLM::Field
+  def initialize(opt); end
+
+  def parse(str, offset = _); end
+  def serialize; end
+end
+
+class Net::NTLM::Int32LE < ::Net::NTLM::Field
+  def initialize(opt); end
+
+  def parse(str, offset = _); end
+  def serialize; end
+end
+
+class Net::NTLM::Int64LE < ::Net::NTLM::Field
+  def initialize(opt); end
+
+  def parse(str, offset = _); end
+  def serialize; end
+end
+
+class Net::NTLM::Message < ::Net::NTLM::FieldSet
+  def data_size; end
+  def decode64(str); end
+  def dump_flags; end
+  def encode64; end
+  def has_flag?(flag); end
+  def head_size; end
+  def serialize; end
+  def set_flag(flag); end
+  def size; end
+
+  private
+
+  def data_edge; end
+  def deflag; end
+  def security_buffers; end
+
+  def self.decode64(str); end
+  def self.parse(str); end
+end
+
+class Net::NTLM::Message::Type0 < ::Net::NTLM::Message
+  def sign; end
+  def sign=(val); end
+  def type; end
+  def type=(val); end
+
+  def self.inherited(subclass); end
+end
+
+class Net::NTLM::Message::Type1 < ::Net::NTLM::Message
+  def domain; end
+  def domain=(val); end
+  def flag; end
+  def flag=(val); end
+  def padding; end
+  def padding=(val); end
+  def parse(str); end
+  def sign; end
+  def sign=(val); end
+  def type; end
+  def type=(val); end
+  def workstation; end
+  def workstation=(val); end
+
+  def self.inherited(subclass); end
+  def self.parse(str); end
+end
+
+class Net::NTLM::Message::Type2 < ::Net::NTLM::Message
+  def challenge; end
+  def challenge=(val); end
+  def context; end
+  def context=(val); end
+  def flag; end
+  def flag=(val); end
+  def padding; end
+  def padding=(val); end
+  def parse(str); end
+  def response(arg, opt = _); end
+  def sign; end
+  def sign=(val); end
+  def target_info; end
+  def target_info=(val); end
+  def target_name; end
+  def target_name=(val); end
+  def type; end
+  def type=(val); end
+
+  def self.inherited(subclass); end
+  def self.parse(str); end
+end
+
+class Net::NTLM::Message::Type3 < ::Net::NTLM::Message
+  def domain; end
+  def domain=(val); end
+  def flag; end
+  def flag=(val); end
+  def lm_response; end
+  def lm_response=(val); end
+  def ntlm_response; end
+  def ntlm_response=(val); end
+  def session_key; end
+  def session_key=(val); end
+  def sign; end
+  def sign=(val); end
+  def type; end
+  def type=(val); end
+  def user; end
+  def user=(val); end
+  def workstation; end
+  def workstation=(val); end
+
+  def self.create(arg, opt = _); end
+  def self.inherited(subclass); end
+  def self.parse(str); end
+end
+
+class Net::NTLM::SecurityBuffer < ::Net::NTLM::FieldSet
+  def initialize(opts); end
+
+  def active; end
+  def active=(_); end
+  def allocated; end
+  def allocated=(val); end
+  def data_size; end
+  def length; end
+  def length=(val); end
+  def offset; end
+  def offset=(val); end
+  def parse(str, offset = _); end
+  def serialize; end
+  def value; end
+  def value=(val); end
+
+  def self.inherited(subclass); end
+end
+
+class Net::NTLM::String < ::Net::NTLM::Field
+  def initialize(opts); end
+
+  def parse(str, offset = _); end
+  def serialize; end
+  def value=(val); end
+end
+
+module Net::NTLM::VERSION
+end
+
+Net::NTLM::VERSION::MAJOR = T.let(T.unsafe(nil), Integer)
+
+Net::NTLM::VERSION::MINOR = T.let(T.unsafe(nil), Integer)
+
+Net::NTLM::VERSION::STRING = T.let(T.unsafe(nil), String)
+
+Net::NTLM::VERSION::TINY = T.let(T.unsafe(nil), Integer)

Library/Homebrew/sorbet/rbi/gems/parallel@1.19.1.rbi

@@ -0,0 +1,90 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+module Parallel
+  extend(::Parallel::ProcessorCount)
+
+  def self.all?(*args, &block); end
+  def self.any?(*args, &block); end
+  def self.each(array, options = _, &block); end
+  def self.each_with_index(array, options = _, &block); end
+  def self.flat_map(*args, &block); end
+  def self.in_processes(options = _, &block); end
+  def self.in_threads(options = _); end
+  def self.map(source, options = _, &block); end
+  def self.map_with_index(array, options = _, &block); end
+  def self.worker_number; end
+  def self.worker_number=(worker_num); end
+end
+
+class Parallel::Break < ::StandardError
+end
+
+class Parallel::DeadWorker < ::StandardError
+end
+
+class Parallel::ExceptionWrapper
+  def initialize(exception); end
+
+  def exception; end
+end
+
+class Parallel::JobFactory
+  def initialize(source, mutex); end
+
+  def next; end
+  def pack(item, index); end
+  def size; end
+  def unpack(data); end
+
+  private
+
+  def producer?; end
+  def queue_wrapper(array); end
+end
+
+class Parallel::Kill < ::StandardError
+end
+
+module Parallel::ProcessorCount
+  def physical_processor_count; end
+  def processor_count; end
+end
+
+Parallel::Stop = T.let(T.unsafe(nil), Object)
+
+class Parallel::UndumpableException < ::StandardError
+  def initialize(original); end
+
+  def backtrace; end
+end
+
+class Parallel::UserInterruptHandler
+  def self.kill(thing); end
+  def self.kill_on_ctrl_c(pids, options); end
+end
+
+Parallel::UserInterruptHandler::INTERRUPT_SIGNAL = T.let(T.unsafe(nil), Symbol)
+
+Parallel::VERSION = T.let(T.unsafe(nil), String)
+
+Parallel::Version = T.let(T.unsafe(nil), String)
+
+class Parallel::Worker
+  def initialize(read, write, pid); end
+
+  def close_pipes; end
+  def pid; end
+  def read; end
+  def stop; end
+  def thread; end
+  def thread=(_); end
+  def work(data); end
+  def write; end
+
+  private
+
+  def wait; end
+end

Library/Homebrew/sorbet/rbi/gems/parallel_tests@3.0.0.rbi

@@ -0,0 +1,80 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+module ParallelTests
+  def self.bundler_enabled?; end
+  def self.delta; end
+  def self.determine_number_of_processes(count); end
+  def self.first_process?; end
+  def self.last_process?; end
+  def self.now; end
+  def self.number_of_running_processes; end
+  def self.pid_file_path; end
+  def self.pids; end
+  def self.stop_all_processes; end
+  def self.wait_for_other_processes_to_finish; end
+  def self.with_pid_file; end
+  def self.with_ruby_binary(command); end
+end
+
+class ParallelTests::CLI
+  def run(argv); end
+
+  private
+
+  def any_test_failed?(test_results); end
+  def append_test_options(options, argv); end
+  def detailed_duration(seconds); end
+  def execute_in_parallel(items, num_processes, options); end
+  def execute_shell_command_in_parallel(command, num_processes, options); end
+  def extract_file_paths(argv); end
+  def extract_test_options(argv); end
+  def final_fail_message; end
+  def first_is_1?; end
+  def handle_interrupt; end
+  def load_runner(type); end
+  def lock(lockfile); end
+  def parse_options!(argv); end
+  def report_failure_rerun_commmand(test_results, options); end
+  def report_number_of_tests(groups); end
+  def report_results(test_results, options); end
+  def report_time_taken; end
+  def reprint_output(result, lockfile); end
+  def run_tests(group, process_number, num_processes, options); end
+  def run_tests_in_parallel(num_processes, options); end
+  def simulate_output_for_ci(simulate); end
+  def use_colors?; end
+end
+
+class ParallelTests::Grouper
+  def self.by_scenarios(tests, num_groups, options = _); end
+  def self.by_steps(tests, num_groups, options); end
+  def self.in_even_groups_by_size(items, num_groups, options = _); end
+end
+
+class ParallelTests::Pids
+  def initialize(file_path); end
+
+  def add(pid); end
+  def all; end
+  def count; end
+  def delete(pid); end
+  def file_path; end
+  def mutex; end
+
+  private
+
+  def clear; end
+  def pids; end
+  def read; end
+  def save; end
+  def sync; end
+end
+
+ParallelTests::RUBY_BINARY = T.let(T.unsafe(nil), String)
+
+ParallelTests::VERSION = T.let(T.unsafe(nil), String)
+
+ParallelTests::Version = T.let(T.unsafe(nil), String)

Library/Homebrew/sorbet/rbi/gems/plist@3.5.0.rbi

@@ -0,0 +1,125 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+module Plist
+  def self.parse_xml(filename_or_xml); end
+end
+
+module Plist::Emit
+  def save_plist(filename, options = _); end
+  def to_plist(envelope = _, options = _); end
+
+  def self.comment(content); end
+  def self.dump(obj, envelope = _, options = _); end
+  def self.element_type(item); end
+  def self.plist_node(element, options = _); end
+  def self.save_plist(obj, filename, options = _); end
+  def self.tag(type, contents = _, options = _, &block); end
+  def self.wrap(contents); end
+end
+
+Plist::Emit::DEFAULT_INDENT = T.let(T.unsafe(nil), String)
+
+class Plist::Emit::IndentedString
+  def initialize(str = _); end
+
+  def <<(val); end
+  def indent_string; end
+  def indent_string=(_); end
+  def lower_indent; end
+  def raise_indent; end
+  def to_s; end
+end
+
+class Plist::Listener
+  def initialize; end
+
+  def open; end
+  def open=(_); end
+  def result; end
+  def result=(_); end
+  def tag_end(name); end
+  def tag_start(name, attributes); end
+  def text(contents); end
+end
+
+class Plist::PArray < ::Plist::PTag
+  def to_ruby; end
+end
+
+class Plist::PData < ::Plist::PTag
+  def to_ruby; end
+end
+
+class Plist::PDate < ::Plist::PTag
+  def to_ruby; end
+end
+
+class Plist::PDict < ::Plist::PTag
+  def to_ruby; end
+end
+
+class Plist::PFalse < ::Plist::PTag
+  def to_ruby; end
+end
+
+class Plist::PInteger < ::Plist::PTag
+  def to_ruby; end
+end
+
+class Plist::PKey < ::Plist::PTag
+  def to_ruby; end
+end
+
+class Plist::PList < ::Plist::PTag
+  def to_ruby; end
+end
+
+class Plist::PReal < ::Plist::PTag
+  def to_ruby; end
+end
+
+class Plist::PString < ::Plist::PTag
+  def to_ruby; end
+end
+
+class Plist::PTag
+  def initialize; end
+
+  def children; end
+  def children=(_); end
+  def text; end
+  def text=(_); end
+  def to_ruby; end
+
+  def self.inherited(sub_class); end
+  def self.mappings; end
+end
+
+class Plist::PTrue < ::Plist::PTag
+  def to_ruby; end
+end
+
+class Plist::StreamParser
+  def initialize(plist_data_or_file, listener); end
+
+  def parse; end
+
+  private
+
+  def parse_encoding_from_xml_declaration(xml_declaration); end
+end
+
+Plist::StreamParser::COMMENT_END = T.let(T.unsafe(nil), Regexp)
+
+Plist::StreamParser::COMMENT_START = T.let(T.unsafe(nil), Regexp)
+
+Plist::StreamParser::DOCTYPE_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+Plist::StreamParser::TEXT = T.let(T.unsafe(nil), Regexp)
+
+Plist::StreamParser::XMLDECL_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+Plist::VERSION = T.let(T.unsafe(nil), String)

Library/Homebrew/sorbet/rbi/gems/pry@0.13.1.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/rainbow@3.0.0.rbi

@@ -0,0 +1,142 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+module Rainbow
+  def self.enabled; end
+  def self.enabled=(value); end
+  def self.global; end
+  def self.new; end
+  def self.uncolor(string); end
+end
+
+class Rainbow::Color
+  def ground; end
+
+  def self.build(ground, values); end
+  def self.parse_hex_color(hex); end
+end
+
+class Rainbow::Color::Indexed < ::Rainbow::Color
+  def initialize(ground, num); end
+
+  def codes; end
+  def num; end
+end
+
+class Rainbow::Color::Named < ::Rainbow::Color::Indexed
+  def initialize(ground, name); end
+
+  def self.color_names; end
+  def self.valid_names; end
+end
+
+Rainbow::Color::Named::NAMES = T.let(T.unsafe(nil), Hash)
+
+class Rainbow::Color::RGB < ::Rainbow::Color::Indexed
+  def initialize(ground, *values); end
+
+  def b; end
+  def codes; end
+  def g; end
+  def r; end
+
+  private
+
+  def code_from_rgb; end
+
+  def self.to_ansi_domain(value); end
+end
+
+class Rainbow::Color::X11Named < ::Rainbow::Color::RGB
+  include(::Rainbow::X11ColorNames)
+
+  def initialize(ground, name); end
+
+  def self.color_names; end
+  def self.valid_names; end
+end
+
+class Rainbow::NullPresenter < ::String
+  def background(*_values); end
+  def bg(*_values); end
+  def black; end
+  def blink; end
+  def blue; end
+  def bold; end
+  def bright; end
+  def color(*_values); end
+  def cyan; end
+  def dark; end
+  def faint; end
+  def fg(*_values); end
+  def foreground(*_values); end
+  def green; end
+  def hide; end
+  def inverse; end
+  def italic; end
+  def magenta; end
+  def method_missing(method_name, *args); end
+  def red; end
+  def reset; end
+  def underline; end
+  def white; end
+  def yellow; end
+
+  private
+
+  def respond_to_missing?(method_name, *args); end
+end
+
+class Rainbow::Presenter < ::String
+  def background(*values); end
+  def bg(*values); end
+  def black; end
+  def blink; end
+  def blue; end
+  def bold; end
+  def bright; end
+  def color(*values); end
+  def cyan; end
+  def dark; end
+  def faint; end
+  def fg(*values); end
+  def foreground(*values); end
+  def green; end
+  def hide; end
+  def inverse; end
+  def italic; end
+  def magenta; end
+  def method_missing(method_name, *args); end
+  def red; end
+  def reset; end
+  def underline; end
+  def white; end
+  def yellow; end
+
+  private
+
+  def respond_to_missing?(method_name, *args); end
+  def wrap_with_sgr(codes); end
+end
+
+Rainbow::Presenter::TERM_EFFECTS = T.let(T.unsafe(nil), Hash)
+
+class Rainbow::StringUtils
+  def self.uncolor(string); end
+  def self.wrap_with_sgr(string, codes); end
+end
+
+class Rainbow::Wrapper
+  def initialize(enabled = _); end
+
+  def enabled; end
+  def enabled=(_); end
+  def wrap(string); end
+end
+
+module Rainbow::X11ColorNames
+end
+
+Rainbow::X11ColorNames::NAMES = T.let(T.unsafe(nil), Hash)

Library/Homebrew/sorbet/rbi/gems/rdiscount@2.2.0.1.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/rexml@3.2.4.rbi

@@ -0,0 +1,678 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+class Array
+  include(::Enumerable)
+  include(::JSON::Ext::Generator::GeneratorMethods::Array)
+  include(::Plist::Emit)
+
+  def dclone; end
+end
+
+class Float < ::Numeric
+  include(::JSON::Ext::Generator::GeneratorMethods::Float)
+
+  def dclone; end
+end
+
+class Integer < ::Numeric
+  include(::JSON::Ext::Generator::GeneratorMethods::Integer)
+
+  def dclone; end
+end
+
+Integer::GMP_VERSION = T.let(T.unsafe(nil), String)
+
+class Object < ::BasicObject
+  include(::Kernel)
+  include(::JSON::Ext::Generator::GeneratorMethods::Object)
+  include(::PP::ObjectMixin)
+
+  def dclone; end
+end
+
+class REXML::AttlistDecl < ::REXML::Child
+  include(::Enumerable)
+
+  def initialize(source); end
+
+  def [](key); end
+  def each(&block); end
+  def element_name; end
+  def include?(key); end
+  def node_type; end
+  def write(out, indent = _); end
+end
+
+class REXML::Attribute
+  include(::REXML::Node)
+  include(::REXML::XMLTokens)
+  include(::REXML::Namespace)
+
+  def initialize(first, second = _, parent = _); end
+
+  def ==(other); end
+  def clone; end
+  def doctype; end
+  def element; end
+  def element=(element); end
+  def hash; end
+  def inspect; end
+  def namespace(arg = _); end
+  def node_type; end
+  def normalized=(_); end
+  def prefix; end
+  def remove; end
+  def to_s; end
+  def to_string; end
+  def value; end
+  def write(output, indent = _); end
+  def xpath; end
+end
+
+class REXML::Attributes < ::Hash
+  def initialize(element); end
+
+  def <<(attribute); end
+  def [](name); end
+  def []=(name, value); end
+  def add(attribute); end
+  def delete(attribute); end
+  def delete_all(name); end
+  def each; end
+  def each_attribute; end
+  def get_attribute(name); end
+  def get_attribute_ns(namespace, name); end
+  def length; end
+  def namespaces; end
+  def prefixes; end
+  def size; end
+  def to_a; end
+end
+
+class REXML::CData < ::REXML::Text
+  def initialize(first, whitespace = _, parent = _); end
+
+  def clone; end
+  def to_s; end
+  def value; end
+  def write(output = _, indent = _, transitive = _, ie_hack = _); end
+end
+
+class REXML::Child
+  include(::REXML::Node)
+
+  def initialize(parent = _); end
+
+  def bytes; end
+  def document; end
+  def next_sibling; end
+  def next_sibling=(other); end
+  def parent; end
+  def parent=(other); end
+  def previous_sibling; end
+  def previous_sibling=(other); end
+  def remove; end
+  def replace_with(child); end
+end
+
+class REXML::Comment < ::REXML::Child
+  include(::Comparable)
+
+  def initialize(first, second = _); end
+
+  def <=>(other); end
+  def ==(other); end
+  def clone; end
+  def node_type; end
+  def string; end
+  def string=(_); end
+  def to_s; end
+  def write(output, indent = _, transitive = _, ie_hack = _); end
+end
+
+class REXML::Declaration < ::REXML::Child
+  def initialize(src); end
+
+  def to_s; end
+  def write(output, indent); end
+end
+
+class REXML::DocType < ::REXML::Parent
+  include(::REXML::XMLTokens)
+
+  def initialize(first, parent = _); end
+
+  def add(child); end
+  def attribute_of(element, attribute); end
+  def attributes_of(element); end
+  def clone; end
+  def context; end
+  def entities; end
+  def entity(name); end
+  def external_id; end
+  def name; end
+  def namespaces; end
+  def node_type; end
+  def notation(name); end
+  def notations; end
+  def public; end
+  def system; end
+  def write(output, indent = _, transitive = _, ie_hack = _); end
+
+  private
+
+  def strip_quotes(quoted_string); end
+end
+
+class REXML::Document < ::REXML::Element
+  def initialize(source = _, context = _); end
+
+  def <<(child); end
+  def add(child); end
+  def add_element(arg = _, arg2 = _); end
+  def clone; end
+  def doctype; end
+  def document; end
+  def encoding; end
+  def entity_expansion_count; end
+  def expanded_name; end
+  def name; end
+  def node_type; end
+  def record_entity_expansion; end
+  def root; end
+  def stand_alone?; end
+  def version; end
+  def write(*arguments); end
+  def xml_decl; end
+
+  private
+
+  def build(source); end
+
+  def self.entity_expansion_limit; end
+  def self.entity_expansion_limit=(val); end
+  def self.entity_expansion_text_limit; end
+  def self.entity_expansion_text_limit=(val); end
+  def self.parse_stream(source, listener); end
+end
+
+class REXML::Element < ::REXML::Parent
+  include(::REXML::XMLTokens)
+  include(::REXML::Namespace)
+
+  def initialize(arg = _, parent = _, context = _); end
+
+  def [](name_or_index); end
+  def add_attribute(key, value = _); end
+  def add_attributes(hash); end
+  def add_element(element, attrs = _); end
+  def add_namespace(prefix, uri = _); end
+  def add_text(text); end
+  def attribute(name, namespace = _); end
+  def attributes; end
+  def cdatas; end
+  def clone; end
+  def comments; end
+  def context; end
+  def context=(_); end
+  def delete_attribute(key); end
+  def delete_element(element); end
+  def delete_namespace(namespace = _); end
+  def document; end
+  def each_element(xpath = _, &block); end
+  def each_element_with_attribute(key, value = _, max = _, name = _, &block); end
+  def each_element_with_text(text = _, max = _, name = _, &block); end
+  def elements; end
+  def get_elements(xpath); end
+  def get_text(path = _); end
+  def has_attributes?; end
+  def has_elements?; end
+  def has_text?; end
+  def ignore_whitespace_nodes; end
+  def inspect; end
+  def instructions; end
+  def namespace(prefix = _); end
+  def namespaces; end
+  def next_element; end
+  def node_type; end
+  def prefixes; end
+  def previous_element; end
+  def raw; end
+  def root; end
+  def root_node; end
+  def text(path = _); end
+  def text=(text); end
+  def texts; end
+  def whitespace; end
+  def write(output = _, indent = _, transitive = _, ie_hack = _); end
+  def xpath; end
+
+  private
+
+  def __to_xpath_helper(node); end
+  def each_with_something(test, max = _, name = _); end
+end
+
+class REXML::Elements
+  include(::Enumerable)
+
+  def initialize(parent); end
+
+  def <<(element = _); end
+  def [](index, name = _); end
+  def []=(index, element); end
+  def add(element = _); end
+  def collect(xpath = _); end
+  def delete(element); end
+  def delete_all(xpath); end
+  def each(xpath = _); end
+  def empty?; end
+  def index(element); end
+  def inject(xpath = _, initial = _); end
+  def size; end
+  def to_a(xpath = _); end
+
+  private
+
+  def literalize(name); end
+end
+
+module REXML::Encoding
+  def decode(string); end
+  def encode(string); end
+  def encoding; end
+  def encoding=(encoding); end
+
+  private
+
+  def find_encoding(name); end
+end
+
+class REXML::Entity < ::REXML::Child
+  include(::REXML::XMLTokens)
+
+  def initialize(stream, value = _, parent = _, reference = _); end
+
+  def external; end
+  def name; end
+  def ndata; end
+  def normalized; end
+  def pubid; end
+  def ref; end
+  def to_s; end
+  def unnormalized; end
+  def value; end
+  def write(out, indent = _); end
+
+  def self.matches?(string); end
+end
+
+class REXML::ExternalEntity < ::REXML::Child
+  def initialize(src); end
+
+  def to_s; end
+  def write(output, indent); end
+end
+
+class REXML::Formatters::Default
+  def initialize(ie_hack = _); end
+
+  def write(node, output); end
+
+  protected
+
+  def write_cdata(node, output); end
+  def write_comment(node, output); end
+  def write_document(node, output); end
+  def write_element(node, output); end
+  def write_instruction(node, output); end
+  def write_text(node, output); end
+end
+
+class REXML::Formatters::Pretty < ::REXML::Formatters::Default
+  def initialize(indentation = _, ie_hack = _); end
+
+  def compact; end
+  def compact=(_); end
+  def width; end
+  def width=(_); end
+
+  protected
+
+  def write_cdata(node, output); end
+  def write_comment(node, output); end
+  def write_document(node, output); end
+  def write_element(node, output); end
+  def write_text(node, output); end
+
+  private
+
+  def indent_text(string, level = _, style = _, indentfirstline = _); end
+  def wrap(string, width); end
+end
+
+class REXML::IOSource < ::REXML::Source
+  def initialize(arg, block_size = _, encoding = _); end
+
+  def consume(pattern); end
+  def current_line; end
+  def empty?; end
+  def match(pattern, cons = _); end
+  def position; end
+  def read; end
+  def scan(pattern, cons = _); end
+
+  private
+
+  def encoding_updated; end
+  def readline; end
+end
+
+class REXML::Instruction < ::REXML::Child
+  def initialize(target, content = _); end
+
+  def ==(other); end
+  def clone; end
+  def content; end
+  def content=(_); end
+  def inspect; end
+  def node_type; end
+  def target; end
+  def target=(_); end
+  def write(writer, indent = _, transitive = _, ie_hack = _); end
+end
+
+class REXML::NotationDecl < ::REXML::Child
+  def initialize(name, middle, pub, sys); end
+
+  def name; end
+  def public; end
+  def public=(_); end
+  def system; end
+  def system=(_); end
+  def to_s; end
+  def write(output, indent = _); end
+end
+
+class REXML::Output
+  include(::REXML::Encoding)
+
+  def initialize(real_IO, encd = _); end
+
+  def <<(content); end
+  def encoding; end
+  def to_s; end
+end
+
+class REXML::Parent < ::REXML::Child
+  include(::Enumerable)
+
+  def initialize(parent = _); end
+
+  def <<(object); end
+  def [](index); end
+  def []=(*args); end
+  def add(object); end
+  def children; end
+  def deep_clone; end
+  def delete(object); end
+  def delete_at(index); end
+  def delete_if(&block); end
+  def each(&block); end
+  def each_child(&block); end
+  def each_index(&block); end
+  def index(child); end
+  def insert_after(child1, child2); end
+  def insert_before(child1, child2); end
+  def length; end
+  def parent?; end
+  def push(object); end
+  def replace_child(to_replace, replacement); end
+  def size; end
+  def to_a; end
+  def unshift(object); end
+end
+
+class REXML::ParseException < ::RuntimeError
+  def initialize(message, source = _, parser = _, exception = _); end
+
+  def context; end
+  def continued_exception; end
+  def continued_exception=(_); end
+  def line; end
+  def parser; end
+  def parser=(_); end
+  def position; end
+  def source; end
+  def source=(_); end
+  def to_s; end
+end
+
+class REXML::Parsers::BaseParser
+  def initialize(source); end
+
+  def add_listener(listener); end
+  def empty?; end
+  def entity(reference, entities); end
+  def has_next?; end
+  def normalize(input, entities = _, entity_filter = _); end
+  def peek(depth = _); end
+  def position; end
+  def pull; end
+  def source; end
+  def stream=(source); end
+  def unnormalize(string, entities = _, filter = _); end
+  def unshift(token); end
+
+  private
+
+  def need_source_encoding_update?(xml_declaration_encoding); end
+  def parse_attributes(prefixes, curr_ns); end
+  def process_instruction; end
+  def pull_event; end
+end
+
+REXML::Parsers::BaseParser::QNAME = T.let(T.unsafe(nil), Regexp)
+
+REXML::Parsers::BaseParser::QNAME_STR = T.let(T.unsafe(nil), String)
+
+class REXML::Parsers::StreamParser
+  def initialize(source, listener); end
+
+  def add_listener(listener); end
+  def parse; end
+end
+
+class REXML::Parsers::TreeParser
+  def initialize(source, build_context = _); end
+
+  def add_listener(listener); end
+  def parse; end
+end
+
+class REXML::Parsers::XPathParser
+  include(::REXML::XMLTokens)
+
+  def abbreviate(path); end
+  def expand(path); end
+  def namespaces=(namespaces); end
+  def parse(path); end
+  def predicate(path); end
+  def predicate_to_string(path, &block); end
+
+  private
+
+  def AdditiveExpr(path, parsed); end
+  def AndExpr(path, parsed); end
+  def EqualityExpr(path, parsed); end
+  def FilterExpr(path, parsed); end
+  def FunctionCall(rest, parsed); end
+  def LocationPath(path, parsed); end
+  def MultiplicativeExpr(path, parsed); end
+  def NodeTest(path, parsed); end
+  def OrExpr(path, parsed); end
+  def PathExpr(path, parsed); end
+  def Predicate(path, parsed); end
+  def PrimaryExpr(path, parsed); end
+  def RelationalExpr(path, parsed); end
+  def RelativeLocationPath(path, parsed); end
+  def UnaryExpr(path, parsed); end
+  def UnionExpr(path, parsed); end
+  def get_group(string); end
+  def parse_args(string); end
+end
+
+REXML::Parsers::XPathParser::LOCAL_NAME_WILDCARD = T.let(T.unsafe(nil), Regexp)
+
+REXML::Parsers::XPathParser::PREFIX_WILDCARD = T.let(T.unsafe(nil), Regexp)
+
+class REXML::Source
+  include(::REXML::Encoding)
+
+  def initialize(arg, encoding = _); end
+
+  def buffer; end
+  def consume(pattern); end
+  def current_line; end
+  def empty?; end
+  def encoding; end
+  def encoding=(enc); end
+  def line; end
+  def match(pattern, cons = _); end
+  def match_to(char, pattern); end
+  def match_to_consume(char, pattern); end
+  def position; end
+  def read; end
+  def scan(pattern, cons = _); end
+
+  private
+
+  def detect_encoding; end
+  def encoding_updated; end
+end
+
+class REXML::Text < ::REXML::Child
+  include(::Comparable)
+
+  def initialize(arg, respect_whitespace = _, parent = _, raw = _, entity_filter = _, illegal = _); end
+
+  def <<(to_append); end
+  def <=>(other); end
+  def clone; end
+  def doctype; end
+  def empty?; end
+  def indent_text(string, level = _, style = _, indentfirstline = _); end
+  def inspect; end
+  def node_type; end
+  def parent=(parent); end
+  def raw; end
+  def raw=(_); end
+  def to_s; end
+  def value; end
+  def value=(val); end
+  def wrap(string, width, addnewline = _); end
+  def write(writer, indent = _, transitive = _, ie_hack = _); end
+  def write_with_substitution(out, input); end
+  def xpath; end
+
+  private
+
+  def clear_cache; end
+
+  def self.check(string, pattern, doctype); end
+  def self.expand(ref, doctype, filter); end
+  def self.normalize(input, doctype = _, entity_filter = _); end
+  def self.read_with_substitution(input, illegal = _); end
+  def self.unnormalize(string, doctype = _, filter = _, illegal = _); end
+end
+
+class REXML::XMLDecl < ::REXML::Child
+  include(::REXML::Encoding)
+
+  def initialize(version = _, encoding = _, standalone = _); end
+
+  def ==(other); end
+  def clone; end
+  def dowrite; end
+  def encoding=(enc); end
+  def inspect; end
+  def node_type; end
+  def nowrite; end
+  def old_enc=(encoding); end
+  def stand_alone?; end
+  def standalone; end
+  def standalone=(_); end
+  def version; end
+  def version=(_); end
+  def write(writer, indent = _, transitive = _, ie_hack = _); end
+  def writeencoding; end
+  def writethis; end
+  def xmldecl(version, encoding, standalone); end
+
+  private
+
+  def content(enc); end
+
+  def self.default; end
+end
+
+class REXML::XPathNode
+  def initialize(node, context = _); end
+
+  def context; end
+  def position; end
+  def raw_node; end
+end
+
+class REXML::XPathParser
+  include(::REXML::XMLTokens)
+
+  def initialize(strict: _); end
+
+  def []=(variable_name, value); end
+  def first(path_stack, node); end
+  def get_first(path, nodeset); end
+  def match(path_stack, nodeset); end
+  def namespaces=(namespaces = _); end
+  def parse(path, nodeset); end
+  def predicate(path, nodeset); end
+  def variables=(vars = _); end
+
+  private
+
+  def child(nodeset); end
+  def compare(a, operator, b); end
+  def descendant(nodeset, include_self); end
+  def descendant_recursive(raw_node, new_nodeset, new_nodes, include_self); end
+  def each_unnode(nodeset); end
+  def enter(tag, *args); end
+  def equality_relational_compare(set1, op, set2); end
+  def evaluate_predicate(expression, nodesets); end
+  def expr(path_stack, nodeset, context = _); end
+  def filter_nodeset(nodeset); end
+  def following(node); end
+  def following_node_of(node); end
+  def get_namespace(node, prefix); end
+  def leave(tag, *args); end
+  def next_sibling_node(node); end
+  def node_test(path_stack, nodesets, any_type: _); end
+  def norm(b); end
+  def normalize_compare_values(a, operator, b); end
+  def preceding(node); end
+  def preceding_node_of(node); end
+  def sort(array_of_nodes, order); end
+  def step(path_stack, any_type: _, order: _); end
+  def strict?; end
+  def trace(*args); end
+  def unnode(nodeset); end
+  def value_type(value); end
+end
+
+class Symbol
+  include(::Comparable)
+
+  def dclone; end
+end

Library/Homebrew/sorbet/rbi/gems/ronn@0.7.3.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/rspec-its@1.3.0.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/rspec-retry@0.6.2.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/rspec-support@3.9.3.rbi

@@ -0,0 +1,470 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+module RSpec
+  extend(::RSpec::Support::Warnings)
+  extend(::RSpec::Core::Warnings)
+
+  def self.clear_examples; end
+  def self.configuration; end
+  def self.configuration=(_); end
+  def self.configure; end
+  def self.const_missing(name); end
+  def self.context(*args, &example_group_block); end
+  def self.current_example; end
+  def self.current_example=(example); end
+  def self.describe(*args, &example_group_block); end
+  def self.example_group(*args, &example_group_block); end
+  def self.fcontext(*args, &example_group_block); end
+  def self.fdescribe(*args, &example_group_block); end
+  def self.reset; end
+  def self.shared_context(name, *args, &block); end
+  def self.shared_examples(name, *args, &block); end
+  def self.shared_examples_for(name, *args, &block); end
+  def self.world; end
+  def self.world=(_); end
+  def self.xcontext(*args, &example_group_block); end
+  def self.xdescribe(*args, &example_group_block); end
+end
+
+class RSpec::CallerFilter
+  def self.first_non_rspec_line(skip_frames = _, increment = _); end
+end
+
+RSpec::CallerFilter::ADDITIONAL_TOP_LEVEL_FILES = T.let(T.unsafe(nil), Array)
+
+RSpec::CallerFilter::IGNORE_REGEX = T.let(T.unsafe(nil), Regexp)
+
+RSpec::CallerFilter::LIB_REGEX = T.let(T.unsafe(nil), Regexp)
+
+RSpec::CallerFilter::RSPEC_LIBS = T.let(T.unsafe(nil), Array)
+
+RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
+
+RSpec::SharedContext = RSpec::Core::SharedContext
+
+module RSpec::Support
+  def self.class_of(object); end
+  def self.define_optimized_require_for_rspec(lib, &require_relative); end
+  def self.deregister_matcher_definition(&block); end
+  def self.failure_notifier; end
+  def self.failure_notifier=(callable); end
+  def self.is_a_matcher?(object); end
+  def self.matcher_definitions; end
+  def self.method_handle_for(object, method_name); end
+  def self.notify_failure(failure, options = _); end
+  def self.register_matcher_definition(&block); end
+  def self.require_rspec_core(f); end
+  def self.require_rspec_expectations(f); end
+  def self.require_rspec_matchers(f); end
+  def self.require_rspec_mocks(f); end
+  def self.require_rspec_support(f); end
+  def self.rspec_description_for_object(object); end
+  def self.thread_local_data; end
+  def self.warning_notifier; end
+  def self.warning_notifier=(_); end
+  def self.with_failure_notifier(callable); end
+end
+
+module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
+  def self.===(exception); end
+end
+
+RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue::AVOID_RESCUING = T.let(T.unsafe(nil), Array)
+
+class RSpec::Support::BlockSignature < ::RSpec::Support::MethodSignature
+  def classify_parameters; end
+end
+
+class RSpec::Support::ComparableVersion
+  include(::Comparable)
+
+  def initialize(string); end
+
+  def <=>(other); end
+  def segments; end
+  def string; end
+end
+
+RSpec::Support::DEFAULT_FAILURE_NOTIFIER = T.let(T.unsafe(nil), Proc)
+
+RSpec::Support::DEFAULT_WARNING_NOTIFIER = T.let(T.unsafe(nil), Proc)
+
+class RSpec::Support::Differ
+  def initialize(opts = _); end
+
+  def color?; end
+  def diff(actual, expected); end
+  def diff_as_object(actual, expected); end
+  def diff_as_string(actual, expected); end
+
+  private
+
+  def add_old_hunk_to_hunk(hunk, oldhunk); end
+  def add_to_output(output, string); end
+  def all_strings?(*args); end
+  def any_multiline_strings?(*args); end
+  def blue(text); end
+  def build_hunks(actual, expected); end
+  def coerce_to_string(string_or_array); end
+  def color(text, color_code); end
+  def color_diff(diff); end
+  def diffably_stringify(array); end
+  def finalize_output(output, final_line); end
+  def format_type; end
+  def green(text); end
+  def handle_encoding_errors(actual, expected); end
+  def hash_to_string(hash); end
+  def multiline?(string); end
+  def no_numbers?(*args); end
+  def no_procs?(*args); end
+  def normal(text); end
+  def object_to_string(object); end
+  def red(text); end
+  def safely_flatten(array); end
+end
+
+class RSpec::Support::DirectoryMaker
+  def self.mkdir_p(path); end
+end
+
+class RSpec::Support::EncodedString
+  def initialize(string, encoding = _); end
+
+  def <<(string); end
+  def ==(*args, &block); end
+  def empty?(*args, &block); end
+  def encoding(*args, &block); end
+  def eql?(*args, &block); end
+  def lines(*args, &block); end
+  def source_encoding; end
+  def split(regex_or_string); end
+  def to_s; end
+  def to_str; end
+
+  private
+
+  def detect_source_encoding(string); end
+  def matching_encoding(string); end
+  def remove_invalid_bytes(string); end
+
+  def self.pick_encoding(source_a, source_b); end
+end
+
+RSpec::Support::EncodedString::REPLACE = T.let(T.unsafe(nil), String)
+
+RSpec::Support::EncodedString::US_ASCII = T.let(T.unsafe(nil), String)
+
+RSpec::Support::EncodedString::UTF_8 = T.let(T.unsafe(nil), String)
+
+module RSpec::Support::FuzzyMatcher
+  def self.values_match?(expected, actual); end
+end
+
+RSpec::Support::KERNEL_METHOD_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+class RSpec::Support::LooseSignatureVerifier < ::RSpec::Support::MethodSignatureVerifier
+
+  private
+
+  def split_args(*args); end
+end
+
+class RSpec::Support::LooseSignatureVerifier::SignatureWithKeywordArgumentsMatcher
+  def initialize(signature); end
+
+  def has_kw_args_in?(args); end
+  def invalid_kw_args_from(_kw_args); end
+  def missing_kw_args_from(_kw_args); end
+  def non_kw_args_arity_description; end
+  def valid_non_kw_args?(*args); end
+end
+
+class RSpec::Support::MethodSignature
+  def initialize(method); end
+
+  def arbitrary_kw_args?; end
+  def classify_arity(arity = _); end
+  def classify_parameters; end
+  def could_contain_kw_args?(args); end
+  def description; end
+  def has_kw_args_in?(args); end
+  def invalid_kw_args_from(given_kw_args); end
+  def max_non_kw_args; end
+  def min_non_kw_args; end
+  def missing_kw_args_from(given_kw_args); end
+  def non_kw_args_arity_description; end
+  def optional_kw_args; end
+  def required_kw_args; end
+  def unlimited_args?; end
+  def valid_non_kw_args?(positional_arg_count, optional_max_arg_count = _); end
+end
+
+RSpec::Support::MethodSignature::INFINITY = T.let(T.unsafe(nil), Float)
+
+class RSpec::Support::MethodSignatureExpectation
+  def initialize; end
+
+  def empty?; end
+  def expect_arbitrary_keywords; end
+  def expect_arbitrary_keywords=(_); end
+  def expect_unlimited_arguments; end
+  def expect_unlimited_arguments=(_); end
+  def keywords; end
+  def keywords=(values); end
+  def max_count; end
+  def max_count=(number); end
+  def min_count; end
+  def min_count=(number); end
+end
+
+class RSpec::Support::MethodSignatureVerifier
+  def initialize(signature, args = _); end
+
+  def error_message; end
+  def kw_args; end
+  def max_non_kw_args; end
+  def min_non_kw_args; end
+  def non_kw_args; end
+  def valid?; end
+  def with_expectation(expectation); end
+
+  private
+
+  def arbitrary_kw_args?; end
+  def invalid_kw_args; end
+  def missing_kw_args; end
+  def split_args(*args); end
+  def unlimited_args?; end
+  def valid_non_kw_args?; end
+end
+
+class RSpec::Support::Mutex < ::Thread::Mutex
+  def self.new; end
+end
+
+RSpec::Support::Mutex::NEW_MUTEX_METHOD = T.let(T.unsafe(nil), Method)
+
+module RSpec::Support::OS
+
+  private
+
+  def windows?; end
+  def windows_file_path?; end
+
+  def self.windows?; end
+  def self.windows_file_path?; end
+end
+
+class RSpec::Support::ObjectFormatter
+  def initialize(max_formatted_output_length = _); end
+
+  def format(object); end
+  def max_formatted_output_length; end
+  def max_formatted_output_length=(_); end
+  def prepare_array(array); end
+  def prepare_element(element); end
+  def prepare_for_inspection(object); end
+  def prepare_hash(input_hash); end
+  def recursive_structure?(object); end
+  def sort_hash_keys(input_hash); end
+  def with_entering_structure(structure); end
+
+  private
+
+  def truncate_string(str, start_index, end_index); end
+
+  def self.default_instance; end
+  def self.format(object); end
+  def self.prepare_for_inspection(object); end
+end
+
+class RSpec::Support::ObjectFormatter::BaseInspector < ::Struct
+  def formatter; end
+  def formatter=(_); end
+  def inspect; end
+  def object; end
+  def object=(_); end
+  def pretty_print(pp); end
+
+  def self.[](*_); end
+  def self.can_inspect?(_object); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*_); end
+end
+
+class RSpec::Support::ObjectFormatter::BigDecimalInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
+  def inspect; end
+
+  def self.can_inspect?(object); end
+end
+
+class RSpec::Support::ObjectFormatter::DateTimeInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
+  def inspect; end
+
+  def self.can_inspect?(object); end
+end
+
+RSpec::Support::ObjectFormatter::DateTimeInspector::FORMAT = T.let(T.unsafe(nil), String)
+
+class RSpec::Support::ObjectFormatter::DelegatorInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
+  def inspect; end
+
+  def self.can_inspect?(object); end
+end
+
+class RSpec::Support::ObjectFormatter::DescribableMatcherInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
+  def inspect; end
+
+  def self.can_inspect?(object); end
+end
+
+RSpec::Support::ObjectFormatter::ELLIPSIS = T.let(T.unsafe(nil), String)
+
+RSpec::Support::ObjectFormatter::INSPECTOR_CLASSES = T.let(T.unsafe(nil), Array)
+
+class RSpec::Support::ObjectFormatter::InspectableItem < ::Struct
+  def inspect; end
+  def pretty_print(pp); end
+  def text; end
+  def text=(_); end
+
+  def self.[](*_); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*_); end
+end
+
+class RSpec::Support::ObjectFormatter::InspectableObjectInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
+  def inspect; end
+
+  def self.can_inspect?(object); end
+end
+
+class RSpec::Support::ObjectFormatter::TimeInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
+  def inspect; end
+
+  def self.can_inspect?(object); end
+end
+
+RSpec::Support::ObjectFormatter::TimeInspector::FORMAT = T.let(T.unsafe(nil), String)
+
+class RSpec::Support::ObjectFormatter::UninspectableObjectInspector < ::RSpec::Support::ObjectFormatter::BaseInspector
+  def inspect; end
+  def klass; end
+  def native_object_id; end
+
+  def self.can_inspect?(object); end
+end
+
+RSpec::Support::ObjectFormatter::UninspectableObjectInspector::OBJECT_ID_FORMAT = T.let(T.unsafe(nil), String)
+
+module RSpec::Support::RecursiveConstMethods
+  def const_defined_on?(mod, const_name); end
+  def constants_defined_on(mod); end
+  def get_const_defined_on(mod, const_name); end
+  def normalize_const_name(const_name); end
+  def recursive_const_defined?(const_name); end
+  def recursive_const_get(const_name); end
+end
+
+class RSpec::Support::ReentrantMutex
+  def initialize; end
+
+  def synchronize; end
+
+  private
+
+  def enter; end
+  def exit; end
+end
+
+module RSpec::Support::Ruby
+
+  private
+
+  def jruby?; end
+  def jruby_9000?; end
+  def jruby_version; end
+  def mri?; end
+  def non_mri?; end
+  def rbx?; end
+  def truffleruby?; end
+
+  def self.jruby?; end
+  def self.jruby_9000?; end
+  def self.jruby_version; end
+  def self.mri?; end
+  def self.non_mri?; end
+  def self.rbx?; end
+  def self.truffleruby?; end
+end
+
+module RSpec::Support::RubyFeatures
+
+  private
+
+  def caller_locations_supported?; end
+  def fork_supported?; end
+  def kw_args_supported?; end
+  def module_prepends_supported?; end
+  def module_refinement_supported?; end
+  def optional_and_splat_args_supported?; end
+  def required_kw_args_supported?; end
+  def ripper_supported?; end
+  def supports_exception_cause?; end
+  def supports_rebinding_module_methods?; end
+  def supports_taint?; end
+
+  def self.caller_locations_supported?; end
+  def self.fork_supported?; end
+  def self.kw_args_supported?; end
+  def self.module_prepends_supported?; end
+  def self.module_refinement_supported?; end
+  def self.optional_and_splat_args_supported?; end
+  def self.required_kw_args_supported?; end
+  def self.ripper_supported?; end
+  def self.supports_exception_cause?; end
+  def self.supports_rebinding_module_methods?; end
+  def self.supports_taint?; end
+end
+
+RSpec::Support::StrictSignatureVerifier = RSpec::Support::MethodSignatureVerifier
+
+module RSpec::Support::Version
+end
+
+RSpec::Support::Version::STRING = T.let(T.unsafe(nil), String)
+
+module RSpec::Support::Warnings
+  def deprecate(deprecated, options = _); end
+  def warn_deprecation(message, options = _); end
+  def warn_with(message, options = _); end
+  def warning(text, options = _); end
+end
+
+module RSpec::Support::WithKeywordsWhenNeeded
+
+  private
+
+  def class_exec(klass, *args, &block); end
+
+  def self.class_exec(klass, *args, &block); end
+end
+
+class RSpec::Support::HunkGenerator
+  def initialize(actual, expected); end
+
+  def hunks; end
+
+  private
+
+  def actual_lines; end
+  def build_hunk(piece); end
+  def context_lines; end
+  def diffs; end
+  def expected_lines; end
+end

Library/Homebrew/sorbet/rbi/gems/rspec-wait@0.0.9.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/rspec@3.9.0.rbi

@@ -0,0 +1,39 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+module RSpec
+  extend(::RSpec::Support::Warnings)
+  extend(::RSpec::Core::Warnings)
+
+  def self.clear_examples; end
+  def self.configuration; end
+  def self.configuration=(_); end
+  def self.configure; end
+  def self.const_missing(name); end
+  def self.context(*args, &example_group_block); end
+  def self.current_example; end
+  def self.current_example=(example); end
+  def self.describe(*args, &example_group_block); end
+  def self.example_group(*args, &example_group_block); end
+  def self.fcontext(*args, &example_group_block); end
+  def self.fdescribe(*args, &example_group_block); end
+  def self.reset; end
+  def self.shared_context(name, *args, &block); end
+  def self.shared_examples(name, *args, &block); end
+  def self.shared_examples_for(name, *args, &block); end
+  def self.world; end
+  def self.world=(_); end
+  def self.xcontext(*args, &example_group_block); end
+  def self.xdescribe(*args, &example_group_block); end
+end
+
+RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
+
+RSpec::SharedContext = RSpec::Core::SharedContext
+
+module RSpec::Version
+end
+
+RSpec::Version::STRING = T.let(T.unsafe(nil), String)

Library/Homebrew/sorbet/rbi/gems/rubocop-performance@1.6.1.rbi

@@ -0,0 +1,525 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+module RuboCop
+end
+
+module RuboCop::Cop
+end
+
+module RuboCop::Cop::Performance
+end
+
+class RuboCop::Cop::Performance::BindCall < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::RangeHelp)
+  extend(::RuboCop::Cop::TargetRubyVersion)
+
+  def autocorrect(node); end
+  def bind_with_call_method?(node = _); end
+  def on_send(node); end
+
+  private
+
+  def build_call_args(call_args_node); end
+  def correction_range(receiver, node); end
+  def message(bind_arg, call_args); end
+end
+
+RuboCop::Cop::Performance::BindCall::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::Caller < ::RuboCop::Cop::Cop
+  def caller_with_scope_method?(node = _); end
+  def on_send(node); end
+  def slow_caller?(node = _); end
+
+  private
+
+  def int_value(node); end
+  def message(node); end
+end
+
+RuboCop::Cop::Performance::Caller::MSG_BRACE = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Performance::Caller::MSG_FIRST = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::CaseWhenSplat < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::Alignment)
+  include(::RuboCop::Cop::RangeHelp)
+
+  def autocorrect(when_node); end
+  def on_case(case_node); end
+
+  private
+
+  def indent_for(node); end
+  def inline_fix_branch(corrector, when_node); end
+  def needs_reorder?(when_node); end
+  def new_branch_without_then(node, new_condition); end
+  def new_condition_with_then(node, new_condition); end
+  def non_splat?(condition); end
+  def reorder_condition(corrector, when_node); end
+  def reordering_correction(when_node); end
+  def replacement(conditions); end
+  def splat_offenses(when_conditions); end
+  def when_branch_range(when_node); end
+end
+
+RuboCop::Cop::Performance::CaseWhenSplat::ARRAY_MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Performance::CaseWhenSplat::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::Casecmp < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def downcase_downcase(node = _); end
+  def downcase_eq(node = _); end
+  def eq_downcase(node = _); end
+  def on_send(node); end
+
+  private
+
+  def build_good_method(arg, variable); end
+  def correction(node, _receiver, method, arg, variable); end
+  def take_method_apart(node); end
+end
+
+RuboCop::Cop::Performance::Casecmp::CASE_METHODS = T.let(T.unsafe(nil), Array)
+
+RuboCop::Cop::Performance::Casecmp::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::ChainArrayAllocation < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::RangeHelp)
+
+  def flat_map_candidate?(node = _); end
+  def on_send(node); end
+end
+
+RuboCop::Cop::Performance::ChainArrayAllocation::ALWAYS_RETURNS_NEW_ARRAY = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Performance::ChainArrayAllocation::HAS_MUTATION_ALTERNATIVE = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Performance::ChainArrayAllocation::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Performance::ChainArrayAllocation::RETURNS_NEW_ARRAY_WHEN_NO_BLOCK = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Performance::ChainArrayAllocation::RETURN_NEW_ARRAY_WHEN_ARGS = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::CompareWithBlock < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::RangeHelp)
+
+  def autocorrect(node); end
+  def compare?(node = _); end
+  def on_block(node); end
+  def replaceable_body?(node = _, param1, param2); end
+
+  private
+
+  def compare_range(send, node); end
+  def message(send, method, var_a, var_b, args); end
+  def slow_compare?(method, args_a, args_b); end
+end
+
+RuboCop::Cop::Performance::CompareWithBlock::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::Count < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::RangeHelp)
+
+  def autocorrect(node); end
+  def count_candidate?(node = _); end
+  def on_send(node); end
+
+  private
+
+  def eligible_node?(node); end
+  def source_starting_at(node); end
+end
+
+RuboCop::Cop::Performance::Count::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::DeletePrefix < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::RegexpMetacharacter)
+  extend(::RuboCop::Cop::TargetRubyVersion)
+
+  def autocorrect(node); end
+  def delete_prefix_candidate?(node = _); end
+  def on_send(node); end
+end
+
+RuboCop::Cop::Performance::DeletePrefix::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Performance::DeletePrefix::PREFERRED_METHODS = T.let(T.unsafe(nil), Hash)
+
+class RuboCop::Cop::Performance::DeleteSuffix < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::RegexpMetacharacter)
+  extend(::RuboCop::Cop::TargetRubyVersion)
+
+  def autocorrect(node); end
+  def delete_suffix_candidate?(node = _); end
+  def on_send(node); end
+end
+
+RuboCop::Cop::Performance::DeleteSuffix::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Performance::DeleteSuffix::PREFERRED_METHODS = T.let(T.unsafe(nil), Hash)
+
+class RuboCop::Cop::Performance::Detect < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def detect_candidate?(node = _); end
+  def on_send(node); end
+
+  private
+
+  def accept_first_call?(receiver, body); end
+  def lazy?(node); end
+  def preferred_method; end
+  def register_offense(node, receiver, second_method); end
+end
+
+RuboCop::Cop::Performance::Detect::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Performance::Detect::REVERSE_MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::DoubleStartEndWith < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def check_with_active_support_aliases(node = _); end
+  def on_or(node); end
+  def two_start_end_with_calls(node = _); end
+
+  private
+
+  def add_offense_for_double_call(node, receiver, method, combined_args); end
+  def check_for_active_support_aliases?; end
+  def combine_args(first_call_args, second_call_args); end
+  def process_source(node); end
+end
+
+RuboCop::Cop::Performance::DoubleStartEndWith::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::EndWith < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::RegexpMetacharacter)
+
+  def autocorrect(node); end
+  def on_match_with_lvasgn(node); end
+  def on_send(node); end
+  def redundant_regex?(node = _); end
+end
+
+RuboCop::Cop::Performance::EndWith::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::FixedSize < ::RuboCop::Cop::Cop
+  def counter(node = _); end
+  def on_send(node); end
+
+  private
+
+  def allowed_argument?(arg); end
+  def allowed_parent?(node); end
+  def allowed_variable?(var); end
+  def contains_double_splat?(node); end
+  def contains_splat?(node); end
+  def non_string_argument?(node); end
+end
+
+RuboCop::Cop::Performance::FixedSize::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::FlatMap < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::RangeHelp)
+
+  def autocorrect(node); end
+  def flat_map_candidate?(node = _); end
+  def on_send(node); end
+
+  private
+
+  def offense_for_levels(node, map_node, first_method, flatten); end
+  def offense_for_method(node, map_node, first_method, flatten); end
+  def register_offense(node, map_node, first_method, flatten, message); end
+end
+
+RuboCop::Cop::Performance::FlatMap::FLATTEN_MULTIPLE_LEVELS = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Performance::FlatMap::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::InefficientHashSearch < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def inefficient_include?(node = _); end
+  def on_send(node); end
+
+  private
+
+  def autocorrect_argument(node); end
+  def autocorrect_hash_expression(node); end
+  def autocorrect_method(node); end
+  def current_method(node); end
+  def message(node); end
+  def use_long_method; end
+end
+
+class RuboCop::Cop::Performance::OpenStruct < ::RuboCop::Cop::Cop
+  def on_send(node); end
+  def open_struct(node = _); end
+end
+
+RuboCop::Cop::Performance::OpenStruct::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::RangeInclude < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def on_send(node); end
+  def range_include(node = _); end
+end
+
+RuboCop::Cop::Performance::RangeInclude::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::RedundantBlockCall < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def blockarg_assigned?(node0, param1); end
+  def blockarg_calls(node0, param1); end
+  def blockarg_def(node = _); end
+  def on_def(node); end
+
+  private
+
+  def args_include_block_pass?(blockcall); end
+  def calls_to_report(argname, body); end
+end
+
+RuboCop::Cop::Performance::RedundantBlockCall::CLOSE_PAREN = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Performance::RedundantBlockCall::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Performance::RedundantBlockCall::OPEN_PAREN = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Performance::RedundantBlockCall::SPACE = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Performance::RedundantBlockCall::YIELD = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::RedundantMatch < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def match_call?(node = _); end
+  def on_send(node); end
+  def only_truthiness_matters?(node = _); end
+end
+
+RuboCop::Cop::Performance::RedundantMatch::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::RedundantMerge < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def modifier_flow_control?(node = _); end
+  def on_send(node); end
+  def redundant_merge_candidate(node = _); end
+
+  private
+
+  def correct_multiple_elements(node, parent, new_source); end
+  def correct_single_element(node, new_source); end
+  def each_redundant_merge(node); end
+  def indent_width; end
+  def kwsplat_used?(pairs); end
+  def leading_spaces(node); end
+  def max_key_value_pairs; end
+  def message(node); end
+  def non_redundant_merge?(node, receiver, pairs); end
+  def non_redundant_pairs?(receiver, pairs); end
+  def non_redundant_value_used?(receiver, node); end
+  def rewrite_with_modifier(node, parent, new_source); end
+  def to_assignments(receiver, pairs); end
+end
+
+RuboCop::Cop::Performance::RedundantMerge::AREF_ASGN = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::RedundantMerge::EachWithObjectInspector
+  extend(::RuboCop::AST::NodePattern::Macros)
+
+  def initialize(node, receiver); end
+
+  def each_with_object_node(node = _); end
+  def value_used?; end
+
+  private
+
+  def eligible_receiver?; end
+  def node; end
+  def receiver; end
+  def second_argument; end
+  def unwind(receiver); end
+end
+
+RuboCop::Cop::Performance::RedundantMerge::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Performance::RedundantMerge::WITH_MODIFIER_CORRECTION = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::RegexpMatch < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def last_matches(node0); end
+  def match_method?(node = _); end
+  def match_node?(node = _); end
+  def match_operator?(node = _); end
+  def match_threequals?(node = _); end
+  def match_with_int_arg_method?(node = _); end
+  def match_with_lvasgn?(node); end
+  def on_case(node); end
+  def on_if(node); end
+  def search_match_nodes(node0); end
+
+  private
+
+  def check_condition(cond); end
+  def correct_operator(corrector, recv, arg, oper = _); end
+  def correction_range(recv, arg); end
+  def find_last_match(body, range, scope_root); end
+  def last_match_used?(match_node); end
+  def match_gvar?(sym); end
+  def message(node); end
+  def modifier_form?(match_node); end
+  def next_match_pos(body, match_node_pos, scope_root); end
+  def range_to_search_for_last_matches(match_node, body, scope_root); end
+  def replace_with_match_predicate_method(corrector, recv, arg, op_range); end
+  def scope_body(node); end
+  def scope_root(node); end
+  def swap_receiver_and_arg(corrector, recv, arg); end
+end
+
+RuboCop::Cop::Performance::RegexpMatch::MATCH_NODE_PATTERN = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Performance::RegexpMatch::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Performance::RegexpMatch::TYPES_IMPLEMENTING_MATCH = T.let(T.unsafe(nil), Array)
+
+class RuboCop::Cop::Performance::ReverseEach < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::RangeHelp)
+
+  def autocorrect(node); end
+  def on_send(node); end
+  def reverse_each?(node = _); end
+end
+
+RuboCop::Cop::Performance::ReverseEach::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Performance::ReverseEach::UNDERSCORE = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::Size < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def on_send(node); end
+
+  private
+
+  def allowed_parent?(node); end
+  def array?(node); end
+  def eligible_node?(node); end
+  def eligible_receiver?(node); end
+  def hash?(node); end
+end
+
+RuboCop::Cop::Performance::Size::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::StartWith < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::RegexpMetacharacter)
+
+  def autocorrect(node); end
+  def on_match_with_lvasgn(node); end
+  def on_send(node); end
+  def redundant_regex?(node = _); end
+end
+
+RuboCop::Cop::Performance::StartWith::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::StringReplacement < ::RuboCop::Cop::Cop
+  include(::RuboCop::Cop::RangeHelp)
+
+  def autocorrect(node); end
+  def on_send(node); end
+  def replace_method(node, first, second, first_param, replacement); end
+  def string_replacement?(node = _); end
+
+  private
+
+  def accept_first_param?(first_param); end
+  def accept_second_param?(second_param); end
+  def first_source(first_param); end
+  def message(node, first_source, second_source); end
+  def method_suffix(node); end
+  def offense(node, first_param, second_param); end
+  def range(node); end
+  def remove_second_param(corrector, node, first_param); end
+  def replacement_method(node, first_source, second_source); end
+  def source_from_regex_constructor(node); end
+  def source_from_regex_literal(node); end
+end
+
+RuboCop::Cop::Performance::StringReplacement::BANG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Performance::StringReplacement::DELETE = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Performance::StringReplacement::DETERMINISTIC_REGEX = T.let(T.unsafe(nil), Regexp)
+
+RuboCop::Cop::Performance::StringReplacement::MSG = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Performance::StringReplacement::TR = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::TimesMap < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def on_block(node); end
+  def on_send(node); end
+  def times_map_call(node = _); end
+
+  private
+
+  def check(node); end
+  def message(map_or_collect, count); end
+end
+
+RuboCop::Cop::Performance::TimesMap::MESSAGE = T.let(T.unsafe(nil), String)
+
+RuboCop::Cop::Performance::TimesMap::MESSAGE_ONLY_IF = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::UnfreezeString < ::RuboCop::Cop::Cop
+  def dup_string?(node = _); end
+  def on_send(node); end
+  def string_new?(node = _); end
+end
+
+RuboCop::Cop::Performance::UnfreezeString::MSG = T.let(T.unsafe(nil), String)
+
+class RuboCop::Cop::Performance::UriDefaultParser < ::RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def on_send(node); end
+  def uri_parser_new?(node = _); end
+end
+
+RuboCop::Cop::Performance::UriDefaultParser::MSG = T.let(T.unsafe(nil), String)
+
+module RuboCop::Cop::RegexpMetacharacter
+
+  private
+
+  def drop_end_metacharacter(regexp_string); end
+  def drop_start_metacharacter(regexp_string); end
+  def literal_at_end?(regexp); end
+  def literal_at_end_with_backslash_z?(regex_str); end
+  def literal_at_end_with_dollar?(regex_str); end
+  def literal_at_start?(regexp); end
+  def literal_at_start_with_backslash_a?(regex_str); end
+  def literal_at_start_with_caret?(regex_str); end
+  def safe_multiline?; end
+end
+
+RuboCop::NodePattern = RuboCop::AST::NodePattern
+
+module RuboCop::Performance
+end
+
+RuboCop::Performance::CONFIG = T.let(T.unsafe(nil), Hash)
+
+module RuboCop::Performance::Inject
+  def self.defaults!; end
+end
+
+module RuboCop::Performance::Version
+end
+
+RuboCop::Performance::Version::STRING = T.let(T.unsafe(nil), String)
+
+RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource
+
+RuboCop::Token = RuboCop::AST::Token

Library/Homebrew/sorbet/rbi/gems/ruby-macho@2.2.0.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/ruby-progressbar@1.10.1.rbi

@@ -0,0 +1,421 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+class ProgressBar
+  def self.create(*args); end
+end
+
+class ProgressBar::Base
+  extend(::Forwardable)
+
+  def initialize(options = _); end
+
+  def clear(*args, &block); end
+  def decrement; end
+  def finish; end
+  def finished?; end
+  def format(other); end
+  def format=(other); end
+  def increment; end
+  def inspect; end
+  def log(*args, &block); end
+  def pause; end
+  def paused?; end
+  def progress(*args, &block); end
+  def progress=(new_progress); end
+  def progress_mark=(mark); end
+  def refresh(*args, &block); end
+  def remainder_mark=(mark); end
+  def reset; end
+  def resume; end
+  def start(options = _); end
+  def started?; end
+  def stop; end
+  def stopped?; end
+  def title; end
+  def title=(title); end
+  def to_h; end
+  def to_s(new_format = _); end
+  def total(*args, &block); end
+  def total=(new_total); end
+
+  protected
+
+  def autofinish; end
+  def autofinish=(_); end
+  def autostart; end
+  def autostart=(_); end
+  def bar; end
+  def bar=(_); end
+  def finished; end
+  def finished=(_); end
+  def output; end
+  def output=(_); end
+  def percentage; end
+  def percentage=(_); end
+  def progressable; end
+  def progressable=(_); end
+  def rate; end
+  def rate=(_); end
+  def time; end
+  def time=(_); end
+  def timer; end
+  def timer=(_); end
+  def title_comp; end
+  def title_comp=(_); end
+  def update_progress(*args); end
+end
+
+module ProgressBar::Calculators
+end
+
+class ProgressBar::Calculators::Length
+  def initialize(options = _); end
+
+  def calculate_length; end
+  def current_length; end
+  def current_length=(_); end
+  def length; end
+  def length_changed?; end
+  def length_override; end
+  def length_override=(other); end
+  def output; end
+  def output=(_); end
+  def reset_length; end
+
+  private
+
+  def dynamic_width; end
+  def dynamic_width_stty; end
+  def dynamic_width_tput; end
+  def dynamic_width_via_io_object; end
+  def dynamic_width_via_output_stream_object; end
+  def dynamic_width_via_system_calls; end
+  def terminal_width; end
+  def unix?; end
+end
+
+class ProgressBar::Calculators::RunningAverage
+  def self.calculate(current_average, new_value_to_average, smoothing_factor); end
+end
+
+module ProgressBar::Components
+end
+
+class ProgressBar::Components::Bar
+  def initialize(options = _); end
+
+  def length; end
+  def length=(_); end
+  def progress; end
+  def progress=(_); end
+  def progress_mark; end
+  def progress_mark=(_); end
+  def remainder_mark; end
+  def remainder_mark=(_); end
+  def to_s(options = _); end
+  def upa_steps; end
+  def upa_steps=(_); end
+
+  private
+
+  def bar(length); end
+  def bar_with_percentage(length); end
+  def complete_bar(length); end
+  def complete_bar_with_percentage(length); end
+  def completed_length; end
+  def incomplete_space(length); end
+  def incomplete_string; end
+  def integrated_percentage_complete_string; end
+  def standard_complete_string; end
+  def unknown_progress_frame; end
+  def unknown_string; end
+end
+
+ProgressBar::Components::Bar::DEFAULT_PROGRESS_MARK = T.let(T.unsafe(nil), String)
+
+ProgressBar::Components::Bar::DEFAULT_REMAINDER_MARK = T.let(T.unsafe(nil), String)
+
+ProgressBar::Components::Bar::DEFAULT_UPA_STEPS = T.let(T.unsafe(nil), Array)
+
+class ProgressBar::Components::Percentage
+  def initialize(options = _); end
+
+  def progress; end
+  def progress=(_); end
+
+  private
+
+  def justified_percentage; end
+  def justified_percentage_with_precision; end
+  def percentage; end
+  def percentage_with_precision; end
+end
+
+class ProgressBar::Components::Rate
+  def initialize(options = _); end
+
+  def progress; end
+  def progress=(_); end
+  def rate_scale; end
+  def rate_scale=(_); end
+  def started_at; end
+  def started_at=(_); end
+  def stopped_at; end
+  def stopped_at=(_); end
+  def timer; end
+  def timer=(_); end
+
+  private
+
+  def base_rate; end
+  def elapsed_seconds; end
+  def rate_of_change(format_string = _); end
+  def rate_of_change_with_precision; end
+  def scaled_rate; end
+end
+
+class ProgressBar::Components::Time
+  def initialize(options = _); end
+
+  def elapsed_with_label; end
+  def estimated_with_label; end
+
+  protected
+
+  def estimated_with_friendly_oob; end
+  def estimated_with_no_oob; end
+  def estimated_with_unknown_oob; end
+  def out_of_bounds_time_format; end
+  def out_of_bounds_time_format=(format); end
+  def progress; end
+  def progress=(_); end
+  def timer; end
+  def timer=(_); end
+
+  private
+
+  def elapsed; end
+  def estimated; end
+  def estimated_seconds_remaining; end
+  def estimated_with_elapsed_fallback; end
+  def out_of_bounds_time; end
+end
+
+ProgressBar::Components::Time::ELAPSED_LABEL = T.let(T.unsafe(nil), String)
+
+ProgressBar::Components::Time::ESTIMATED_LABEL = T.let(T.unsafe(nil), String)
+
+ProgressBar::Components::Time::NO_TIME_ELAPSED_TEXT = T.let(T.unsafe(nil), String)
+
+ProgressBar::Components::Time::OOB_FRIENDLY_TIME_TEXT = T.let(T.unsafe(nil), String)
+
+ProgressBar::Components::Time::OOB_LIMIT_IN_HOURS = T.let(T.unsafe(nil), Integer)
+
+ProgressBar::Components::Time::OOB_TIME_FORMATS = T.let(T.unsafe(nil), Array)
+
+ProgressBar::Components::Time::OOB_UNKNOWN_TIME_TEXT = T.let(T.unsafe(nil), String)
+
+ProgressBar::Components::Time::TIME_FORMAT = T.let(T.unsafe(nil), String)
+
+class ProgressBar::Components::Title
+  def initialize(options = _); end
+
+  def title; end
+  def title=(_); end
+end
+
+ProgressBar::Components::Title::DEFAULT_TITLE = T.let(T.unsafe(nil), String)
+
+module ProgressBar::Format
+end
+
+class ProgressBar::Format::Formatter
+  def self.process(format_string, max_length, bar); end
+end
+
+class ProgressBar::Format::Molecule
+  def initialize(letter); end
+
+  def bar_molecule?; end
+  def full_key; end
+  def key; end
+  def key=(_); end
+  def lookup_value(environment, length = _); end
+  def method_name; end
+  def method_name=(_); end
+  def non_bar_molecule?; end
+end
+
+ProgressBar::Format::Molecule::BAR_MOLECULES = T.let(T.unsafe(nil), Array)
+
+ProgressBar::Format::Molecule::MOLECULES = T.let(T.unsafe(nil), Hash)
+
+class ProgressBar::Format::String < ::String
+  def bar_molecule_placeholder_length; end
+  def bar_molecules; end
+  def displayable_length; end
+  def molecules; end
+  def non_bar_molecules; end
+end
+
+ProgressBar::Format::String::ANSI_SGR_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+ProgressBar::Format::String::MOLECULE_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+class ProgressBar::InvalidProgressError < ::RuntimeError
+end
+
+class ProgressBar::Output
+  def initialize(options = _); end
+
+  def clear_string; end
+  def length; end
+  def log(string); end
+  def refresh(options = _); end
+  def stream; end
+  def stream=(_); end
+  def with_refresh; end
+
+  protected
+
+  def bar; end
+  def bar=(_); end
+  def length_calculator; end
+  def length_calculator=(_); end
+  def throttle; end
+  def throttle=(_); end
+
+  private
+
+  def print_and_flush; end
+
+  def self.detect(options = _); end
+end
+
+ProgressBar::Output::DEFAULT_OUTPUT_STREAM = T.let(T.unsafe(nil), IO)
+
+module ProgressBar::Outputs
+end
+
+class ProgressBar::Outputs::NonTty < ::ProgressBar::Output
+  def bar_update_string; end
+  def clear; end
+  def default_format; end
+  def eol; end
+  def last_update_length; end
+  def refresh_with_format_change(*_); end
+  def resolve_format(*_); end
+
+  protected
+
+  def last_update_length=(_); end
+end
+
+ProgressBar::Outputs::NonTty::DEFAULT_FORMAT_STRING = T.let(T.unsafe(nil), String)
+
+class ProgressBar::Outputs::Tty < ::ProgressBar::Output
+  def bar_update_string; end
+  def clear; end
+  def default_format; end
+  def eol; end
+  def refresh_with_format_change; end
+  def resolve_format(other_format); end
+end
+
+ProgressBar::Outputs::Tty::DEFAULT_FORMAT_STRING = T.let(T.unsafe(nil), String)
+
+class ProgressBar::Progress
+  def initialize(options = _); end
+
+  def absolute; end
+  def decrement; end
+  def finish; end
+  def finished?; end
+  def increment; end
+  def none?; end
+  def percentage_completed; end
+  def percentage_completed_with_precision; end
+  def progress; end
+  def progress=(new_progress); end
+  def reset; end
+  def running_average; end
+  def running_average=(_); end
+  def smoothing; end
+  def smoothing=(_); end
+  def start(options = _); end
+  def starting_position; end
+  def starting_position=(_); end
+  def total; end
+  def total=(new_total); end
+  def total_with_unknown_indicator; end
+  def unknown?; end
+end
+
+ProgressBar::Progress::DEFAULT_BEGINNING_POSITION = T.let(T.unsafe(nil), Integer)
+
+ProgressBar::Progress::DEFAULT_SMOOTHING = T.let(T.unsafe(nil), Float)
+
+ProgressBar::Progress::DEFAULT_TOTAL = T.let(T.unsafe(nil), Integer)
+
+module ProgressBar::Refinements
+end
+
+module ProgressBar::Refinements::Enumerator
+end
+
+class ProgressBar::Throttle
+  def initialize(options = _); end
+
+  def choke(options = _); end
+  def rate; end
+  def rate=(_); end
+  def started_at; end
+  def started_at=(_); end
+  def stopped_at; end
+  def stopped_at=(_); end
+  def timer; end
+  def timer=(_); end
+end
+
+class ProgressBar::Time
+  def initialize(time = _); end
+
+  def now; end
+  def unmocked_time_method; end
+
+  protected
+
+  def time; end
+  def time=(_); end
+end
+
+ProgressBar::Time::TIME_MOCKING_LIBRARY_METHODS = T.let(T.unsafe(nil), Array)
+
+class ProgressBar::Timer
+  def initialize(options = _); end
+
+  def divide_seconds(seconds); end
+  def elapsed_seconds; end
+  def elapsed_whole_seconds; end
+  def pause; end
+  def reset; end
+  def reset?; end
+  def restart; end
+  def resume; end
+  def start; end
+  def started?; end
+  def started_at; end
+  def started_at=(_); end
+  def stop; end
+  def stopped?; end
+  def stopped_at; end
+  def stopped_at=(_); end
+
+  protected
+
+  def time; end
+  def time=(_); end
+end

Library/Homebrew/sorbet/rbi/gems/simplecov-html@0.10.2.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/simplecov@0.16.1.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/sync@0.5.0.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/term-ansicolor@1.7.1.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/thor@1.0.1.rbi

@@ -0,0 +1,825 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+class Thor
+  include(::Thor::Base)
+  include(::Thor::Invocation)
+  include(::Thor::Shell)
+  extend(::Thor::Base::ClassMethods)
+  extend(::Thor::Invocation::ClassMethods)
+
+  def help(command = _, subcommand = _); end
+
+  def self.check_unknown_options!(options = _); end
+  def self.check_unknown_options?(config); end
+  def self.command_help(shell, command_name); end
+  def self.default_command(meth = _); end
+  def self.default_task(meth = _); end
+  def self.deprecation_warning(message); end
+  def self.desc(usage, description, options = _); end
+  def self.disable_required_check!(*command_names); end
+  def self.disable_required_check?(command); end
+  def self.help(shell, subcommand = _); end
+  def self.long_desc(long_description, options = _); end
+  def self.map(mappings = _, **kw); end
+  def self.method_option(name, options = _); end
+  def self.method_options(options = _); end
+  def self.option(name, options = _); end
+  def self.options(options = _); end
+  def self.package_name(name, _ = _); end
+  def self.printable_commands(all = _, subcommand = _); end
+  def self.printable_tasks(all = _, subcommand = _); end
+  def self.register(klass, subcommand_name, usage, description, options = _); 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.subcommands; end
+  def self.subtask(subcommand, subcommand_class); end
+  def self.subtasks; end
+  def self.task_help(shell, command_name); end
+end
+
+module Thor::Actions
+  mixes_in_class_methods(::Thor::Actions::ClassMethods)
+
+  def initialize(args = _, options = _, config = _); 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 = _); end
+  def behavior; end
+  def behavior=(_); end
+  def chmod(path, mode, config = _); 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 = _); 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 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 = _, config = _, &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 = _); end
+  def remove_dir(path, config = _); end
+  def remove_file(path, config = _); end
+  def run(command, config = _); end
+  def run_ruby_script(command, config = _); end
+  def source_paths; end
+  def template(source, *args, &block); end
+  def thor(command, *args); end
+  def uncomment_lines(path, flag, *args); end
+
+  protected
+
+  def _cleanup_options_and_set(options, key); end
+  def _shared_configuration; end
+
+  private
+
+  def capture(*args); end
+  def concat(string); end
+  def output_buffer; end
+  def output_buffer=(_); end
+  def with_output_buffer(buf = _); end
+
+  def self.included(base); end
+end
+
+class Thor::Actions::CapturableERB < ::ERB
+  def set_eoutvar(compiler, eoutvar = _); end
+end
+
+module Thor::Actions::ClassMethods
+  def add_runtime_options!; end
+  def source_paths; end
+  def source_paths_for_search; end
+  def source_root(path = _); end
+end
+
+class Thor::Actions::CreateFile < ::Thor::Actions::EmptyDirectory
+  def initialize(base, destination, data, config = _); end
+
+  def data; end
+  def identical?; end
+  def invoke!; end
+  def render; end
+
+  protected
+
+  def force_on_collision?; end
+  def force_or_skip_or_conflict(force, skip, &block); end
+  def on_conflict_behavior(&block); end
+end
+
+class Thor::Actions::CreateLink < ::Thor::Actions::CreateFile
+  def data; end
+  def exists?; end
+  def identical?; end
+  def invoke!; end
+end
+
+class Thor::Actions::Directory < ::Thor::Actions::EmptyDirectory
+  def initialize(base, source, destination = _, config = _, &block); end
+
+  def invoke!; end
+  def revoke!; end
+  def source; end
+
+  protected
+
+  def execute!; end
+  def file_level_lookup(previous_lookup); end
+  def files(lookup); end
+end
+
+class Thor::Actions::EmptyDirectory
+  def initialize(base, destination, config = _); end
+
+  def base; end
+  def config; end
+  def destination; end
+  def exists?; end
+  def given_destination; end
+  def invoke!; end
+  def relative_destination; end
+  def revoke!; end
+
+  protected
+
+  def convert_encoded_instructions(filename); end
+  def destination=(destination); end
+  def invoke_with_conflict_check(&block); end
+  def on_conflict_behavior; end
+  def on_file_clash_behavior; end
+  def pretend?; end
+  def say_status(status, color); end
+end
+
+class Thor::Actions::InjectIntoFile < ::Thor::Actions::EmptyDirectory
+  def initialize(base, destination, data, config); end
+
+  def behavior; end
+  def flag; end
+  def invoke!; end
+  def replacement; end
+  def revoke!; end
+
+  protected
+
+  def replace!(regexp, string, force); end
+  def say_status(behavior, warning: _, color: _); end
+end
+
+Thor::Actions::WARNINGS = T.let(T.unsafe(nil), Hash)
+
+class Thor::AmbiguousCommandError < ::Thor::Error
+end
+
+Thor::AmbiguousTaskError = Thor::AmbiguousCommandError
+
+class Thor::Argument
+  def initialize(name, options = _); end
+
+  def banner; end
+  def default; end
+  def description; end
+  def enum; end
+  def human_name; end
+  def name; end
+  def required; end
+  def required?; end
+  def show_default?; end
+  def type; end
+  def usage; end
+
+  protected
+
+  def default_banner; end
+  def valid_type?(type); end
+  def validate!; end
+end
+
+Thor::Argument::VALID_TYPES = T.let(T.unsafe(nil), Array)
+
+class Thor::Arguments
+  def initialize(arguments = _); end
+
+  def parse(args); end
+  def remaining; end
+
+  private
+
+  def check_requirement!; end
+  def current_is_value?; end
+  def last?; end
+  def no_or_skip?(arg); end
+  def parse_array(name); end
+  def parse_hash(name); end
+  def parse_numeric(name); end
+  def parse_string(name); end
+  def peek; end
+  def shift; end
+  def unshift(arg); end
+
+  def self.parse(*args); end
+  def self.split(args); end
+end
+
+Thor::Arguments::NUMERIC = T.let(T.unsafe(nil), Regexp)
+
+module Thor::Base
+  include(::Thor::Invocation)
+  include(::Thor::Shell)
+
+  mixes_in_class_methods(::Thor::Base::ClassMethods)
+
+  def initialize(args = _, local_options = _, config = _); end
+
+  def args; end
+  def args=(_); end
+  def options; end
+  def options=(_); end
+  def parent_options; end
+  def parent_options=(_); end
+
+  def self.included(base); end
+  def self.register_klass_file(klass); end
+  def self.shell; end
+  def self.shell=(_); end
+  def self.subclass_files; end
+  def self.subclasses; end
+end
+
+module Thor::Base::ClassMethods
+  def all_commands; end
+  def all_tasks; end
+  def allow_incompatible_default_type!; end
+  def argument(name, options = _); end
+  def arguments; end
+  def attr_accessor(*_); end
+  def attr_reader(*_); end
+  def attr_writer(*_); 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 = _); end
+  def class_options(options = _); end
+  def commands; end
+  def disable_required_check?(command_name); end
+  def exit_on_failure?; end
+  def group(name = _); end
+  def handle_argument_error(command, error, args, arity); end
+  def handle_no_command_error(command, has_namespace = _); end
+  def handle_no_task_error(command, has_namespace = _); end
+  def namespace(name = _); end
+  def no_commands(&block); end
+  def no_commands?; end
+  def no_commands_context; end
+  def no_tasks(&block); 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 = _, config = _); 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
+
+  protected
+
+  def baseclass; end
+  def basename; end
+  def build_option(name, options, scope); end
+  def build_options(options, scope); end
+  def class_options_help(shell, groups = _); end
+  def create_command(meth); end
+  def create_task(meth); end
+  def dispatch(command, given_args, given_opts, config); end
+  def find_and_refresh_command(name); end
+  def find_and_refresh_task(name); end
+  def from_superclass(method, default = _); end
+  def inherited(klass); end
+  def initialize_added; end
+  def is_thor_reserved_word?(word, type); end
+  def method_added(meth); end
+  def print_options(shell, options, group_name = _); end
+end
+
+class Thor::Command < ::Struct
+  def initialize(name, description, long_description, usage, options = _); end
+
+  def formatted_usage(klass, namespace = _, subcommand = _); end
+  def hidden?; end
+  def run(instance, args = _); end
+
+  protected
+
+  def handle_argument_error?(instance, error, caller); end
+  def handle_no_method_error?(instance, error, caller); 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 sans_backtrace(backtrace, caller); end
+
+  private
+
+  def initialize_copy(other); end
+end
+
+Thor::Command::FILE_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+module Thor::CoreExt
+end
+
+class Thor::CoreExt::HashWithIndifferentAccess < ::Hash
+  def initialize(hash = _); end
+
+  def [](key); end
+  def []=(key, value); end
+  def delete(key); end
+  def fetch(key, *args); end
+  def key?(key); end
+  def merge(other); end
+  def merge!(other); end
+  def replace(other_hash); end
+  def reverse_merge(other); end
+  def reverse_merge!(other_hash); end
+  def to_hash; end
+  def values_at(*indices); end
+
+  protected
+
+  def convert_key(key); end
+  def method_missing(method, *args); end
+end
+
+Thor::Correctable = DidYouMean::Correctable
+
+class Thor::DynamicCommand < ::Thor::Command
+  def initialize(name, options = _); end
+
+  def run(instance, args = _); end
+end
+
+Thor::DynamicTask = Thor::DynamicCommand
+
+class Thor::Error < ::StandardError
+end
+
+class Thor::Group
+  include(::Thor::Base)
+  include(::Thor::Invocation)
+  include(::Thor::Shell)
+  extend(::Thor::Base::ClassMethods)
+  extend(::Thor::Invocation::ClassMethods)
+
+
+  protected
+
+  def _invoke_for_class_method(klass, command = _, *args, &block); end
+
+  def self.class_options_help(shell, groups = _); end
+  def self.desc(description = _); 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
+end
+
+Thor::HELP_MAPPINGS = T.let(T.unsafe(nil), Array)
+
+class Thor::HiddenCommand < ::Thor::Command
+  def hidden?; end
+end
+
+Thor::HiddenTask = Thor::HiddenCommand
+
+module Thor::Invocation
+  mixes_in_class_methods(::Thor::Invocation::ClassMethods)
+
+  def initialize(args = _, options = _, config = _, &block); end
+
+  def current_command_chain; end
+  def invoke(name = _, *args); end
+  def invoke_all; end
+  def invoke_command(command, *args); end
+  def invoke_task(command, *args); end
+  def invoke_with_padding(*args); end
+
+  protected
+
+  def _parse_initialization_options(args, opts, config); end
+  def _retrieve_class_and_command(name, sent_command = _); end
+  def _retrieve_class_and_task(name, sent_command = _); end
+  def _shared_configuration; end
+
+  def self.included(base); end
+end
+
+module Thor::Invocation::ClassMethods
+  def prepare_for_invocation(key, name); end
+end
+
+class Thor::InvocationError < ::Thor::Error
+end
+
+module Thor::LineEditor
+  def self.best_available; end
+  def self.readline(prompt, options = _); end
+end
+
+class Thor::LineEditor::Basic
+  def initialize(prompt, options); end
+
+  def options; end
+  def prompt; end
+  def readline; end
+
+  private
+
+  def echo?; end
+  def get_input; end
+
+  def self.available?; end
+end
+
+class Thor::LineEditor::Readline < ::Thor::LineEditor::Basic
+  def readline; end
+
+  private
+
+  def add_to_history?; end
+  def completion_options; end
+  def completion_proc; end
+  def use_path_completion?; end
+
+  def self.available?; end
+end
+
+class Thor::LineEditor::Readline::PathCompletion
+  def initialize(text); end
+
+  def matches; end
+
+  private
+
+  def absolute_matches; end
+  def base_path; end
+  def glob_pattern; end
+  def relative_matches; end
+  def text; end
+end
+
+class Thor::MalformattedArgumentError < ::Thor::InvocationError
+end
+
+class Thor::NestedContext
+  def initialize; end
+
+  def enter; end
+  def entered?; end
+
+  private
+
+  def pop; end
+  def push; end
+end
+
+class Thor::NoKwargSpellChecker < ::DidYouMean::SpellChecker
+  def initialize(dictionary); end
+end
+
+class Thor::Option < ::Thor::Argument
+  def initialize(name, options = _); end
+
+  def aliases; end
+  def array?; end
+  def boolean?; end
+  def group; end
+  def hash?; end
+  def hide; end
+  def human_name; end
+  def lazy_default; end
+  def numeric?; end
+  def repeatable; end
+  def string?; end
+  def switch_name; end
+  def usage(padding = _); end
+
+  protected
+
+  def dasherize(str); end
+  def dasherized?; end
+  def undasherize(str); end
+  def validate!; end
+  def validate_default_type!; end
+
+  def self.parse(key, value); end
+end
+
+Thor::Option::VALID_TYPES = T.let(T.unsafe(nil), Array)
+
+class Thor::Options < ::Thor::Arguments
+  def initialize(hash_options = _, defaults = _, stop_on_unknown = _, disable_required_check = _); end
+
+  def check_unknown!; end
+  def parse(args); end
+  def peek; end
+  def remaining; end
+
+  protected
+
+  def assign_result!(option, result); end
+  def current_is_switch?; end
+  def current_is_switch_formatted?; end
+  def current_is_value?; end
+  def normalize_switch(arg); end
+  def parse_boolean(switch); end
+  def parse_peek(switch, option); end
+  def parsing_options?; end
+  def switch?(arg); end
+  def switch_option(arg); end
+
+  def self.to_switches(options); end
+end
+
+Thor::Options::EQ_RE = T.let(T.unsafe(nil), Regexp)
+
+Thor::Options::LONG_RE = T.let(T.unsafe(nil), Regexp)
+
+Thor::Options::OPTS_END = T.let(T.unsafe(nil), String)
+
+Thor::Options::SHORT_NUM = T.let(T.unsafe(nil), Regexp)
+
+Thor::Options::SHORT_RE = T.let(T.unsafe(nil), Regexp)
+
+Thor::Options::SHORT_SQ_RE = T.let(T.unsafe(nil), Regexp)
+
+class Thor::RequiredArgumentMissingError < ::Thor::InvocationError
+end
+
+module Thor::Sandbox
+end
+
+module Thor::Shell
+  def initialize(args = _, options = _, config = _); end
+
+  def ask(*args, &block); end
+  def error(*args, &block); end
+  def file_collision(*args, &block); 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=(_); end
+  def terminal_width(*args, &block); end
+  def with_padding; end
+  def yes?(*args, &block); end
+
+  protected
+
+  def _shared_configuration; end
+end
+
+class Thor::Shell::Basic
+  def initialize; end
+
+  def ask(statement, *args); end
+  def base; end
+  def base=(_); end
+  def error(statement); end
+  def file_collision(destination); end
+  def indent(count = _); end
+  def mute; end
+  def mute?; end
+  def no?(statement, color = _); end
+  def padding; end
+  def padding=(value); end
+  def print_in_columns(array); end
+  def print_table(array, options = _); end
+  def print_wrapped(message, options = _); end
+  def say(message = _, color = _, force_new_line = _); end
+  def say_status(status, message, log_status = _); end
+  def set_color(string, *_); end
+  def terminal_width; end
+  def yes?(statement, color = _); end
+
+  protected
+
+  def answer_match(possibilities, answer, case_insensitive); end
+  def as_unicode; end
+  def ask_filtered(statement, color, options); end
+  def ask_simply(statement, color, options); end
+  def can_display_colors?; end
+  def dynamic_width; end
+  def dynamic_width_stty; end
+  def dynamic_width_tput; end
+  def file_collision_help; end
+  def git_merge_tool; end
+  def is?(value); end
+  def lookup_color(color); end
+  def merge(destination, content); end
+  def merge_tool; end
+  def prepare_message(message, *color); end
+  def quiet?; end
+  def show_diff(destination, content); end
+  def stderr; end
+  def stdout; end
+  def truncate(string, width); end
+  def unix?; end
+end
+
+Thor::Shell::Basic::DEFAULT_TERMINAL_WIDTH = T.let(T.unsafe(nil), Integer)
+
+class Thor::Shell::Color < ::Thor::Shell::Basic
+  def set_color(string, *colors); end
+
+  protected
+
+  def are_colors_disabled?; end
+  def can_display_colors?; end
+  def diff_lcs_loaded?; end
+  def output_diff_line(diff); end
+  def show_diff(destination, content); end
+end
+
+Thor::Shell::Color::BLACK = T.let(T.unsafe(nil), String)
+
+Thor::Shell::Color::BLUE = T.let(T.unsafe(nil), String)
+
+Thor::Shell::Color::BOLD = T.let(T.unsafe(nil), String)
+
+Thor::Shell::Color::CLEAR = T.let(T.unsafe(nil), String)
+
+Thor::Shell::Color::CYAN = T.let(T.unsafe(nil), String)
+
+Thor::Shell::Color::GREEN = T.let(T.unsafe(nil), String)
+
+Thor::Shell::Color::MAGENTA = T.let(T.unsafe(nil), String)
+
+Thor::Shell::Color::ON_BLACK = T.let(T.unsafe(nil), String)
+
+Thor::Shell::Color::ON_BLUE = T.let(T.unsafe(nil), String)
+
+Thor::Shell::Color::ON_CYAN = T.let(T.unsafe(nil), String)
+
+Thor::Shell::Color::ON_GREEN = T.let(T.unsafe(nil), String)
+
+Thor::Shell::Color::ON_MAGENTA = T.let(T.unsafe(nil), String)
+
+Thor::Shell::Color::ON_RED = T.let(T.unsafe(nil), String)
+
+Thor::Shell::Color::ON_WHITE = T.let(T.unsafe(nil), String)
+
+Thor::Shell::Color::ON_YELLOW = T.let(T.unsafe(nil), String)
+
+Thor::Shell::Color::RED = T.let(T.unsafe(nil), String)
+
+Thor::Shell::Color::WHITE = T.let(T.unsafe(nil), String)
+
+Thor::Shell::Color::YELLOW = T.let(T.unsafe(nil), String)
+
+class Thor::Shell::HTML < ::Thor::Shell::Basic
+  def ask(statement, color = _); end
+  def set_color(string, *colors); end
+
+  protected
+
+  def can_display_colors?; end
+  def diff_lcs_loaded?; end
+  def output_diff_line(diff); end
+  def show_diff(destination, content); end
+end
+
+Thor::Shell::HTML::BLACK = T.let(T.unsafe(nil), String)
+
+Thor::Shell::HTML::BLUE = T.let(T.unsafe(nil), String)
+
+Thor::Shell::HTML::BOLD = T.let(T.unsafe(nil), String)
+
+Thor::Shell::HTML::CYAN = T.let(T.unsafe(nil), String)
+
+Thor::Shell::HTML::GREEN = T.let(T.unsafe(nil), String)
+
+Thor::Shell::HTML::MAGENTA = T.let(T.unsafe(nil), String)
+
+Thor::Shell::HTML::ON_BLACK = T.let(T.unsafe(nil), String)
+
+Thor::Shell::HTML::ON_BLUE = T.let(T.unsafe(nil), String)
+
+Thor::Shell::HTML::ON_CYAN = T.let(T.unsafe(nil), String)
+
+Thor::Shell::HTML::ON_GREEN = T.let(T.unsafe(nil), String)
+
+Thor::Shell::HTML::ON_MAGENTA = T.let(T.unsafe(nil), String)
+
+Thor::Shell::HTML::ON_RED = T.let(T.unsafe(nil), String)
+
+Thor::Shell::HTML::ON_WHITE = T.let(T.unsafe(nil), String)
+
+Thor::Shell::HTML::ON_YELLOW = T.let(T.unsafe(nil), String)
+
+Thor::Shell::HTML::RED = T.let(T.unsafe(nil), String)
+
+Thor::Shell::HTML::WHITE = T.let(T.unsafe(nil), String)
+
+Thor::Shell::HTML::YELLOW = T.let(T.unsafe(nil), String)
+
+Thor::Shell::SHELL_DELEGATED_METHODS = T.let(T.unsafe(nil), Array)
+
+Thor::TEMPLATE_EXTNAME = T.let(T.unsafe(nil), String)
+
+Thor::THOR_RESERVED_WORDS = T.let(T.unsafe(nil), Array)
+
+Thor::Task = Thor::Command
+
+class Thor::UndefinedCommandError < ::Thor::Error
+  include(::DidYouMean::Correctable)
+
+  def initialize(command, all_commands, namespace); end
+
+  def all_commands; end
+  def command; end
+end
+
+class Thor::UndefinedCommandError::SpellChecker
+  def initialize(error); end
+
+  def corrections; end
+  def error; end
+  def spell_checker; end
+end
+
+Thor::UndefinedTaskError = Thor::UndefinedCommandError
+
+class Thor::UnknownArgumentError < ::Thor::Error
+  include(::DidYouMean::Correctable)
+
+  def initialize(switches, unknown); end
+
+  def switches; end
+  def unknown; end
+end
+
+class Thor::UnknownArgumentError::SpellChecker
+  def initialize(error); end
+
+  def corrections; end
+  def error; end
+  def spell_checker; end
+end
+
+module 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 = _); end
+  def self.find_class_and_task_by_namespace(namespace, fallback = _); end
+  def self.globs_for(path); end
+  def self.load_thorfile(path, content = _, debug = _); end
+  def self.namespace_from_thor_class(constant); end
+  def self.namespaces_in_content(contents, file = _); 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

Library/Homebrew/sorbet/rbi/gems/thread_safe@0.3.6.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/tins@1.25.0.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/tzinfo@1.2.7.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/unf@0.1.4.rbi

@@ -0,0 +1,21 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+module UNF
+end
+
+class UNF::Normalizer
+  include(::Singleton)
+  extend(::Singleton::SingletonClassMethods)
+
+  def initialize; end
+
+  def normalize(_, _); end
+
+  def self.instance; end
+  def self.normalize(string, form); end
+end
+
+UNF::VERSION = T.let(T.unsafe(nil), String)

Library/Homebrew/sorbet/rbi/gems/unf_ext@0.0.7.7.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/gems/unicode-display_width@1.7.0.rbi

@@ -0,0 +1,26 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+module Unicode
+end
+
+module Unicode::DisplayWidth
+  def self.emoji_extra_width_of(string, ambiguous = _, overwrite = _, _ = _); end
+  def self.of(string, ambiguous = _, overwrite = _, options = _); end
+end
+
+Unicode::DisplayWidth::DATA_DIRECTORY = T.let(T.unsafe(nil), String)
+
+Unicode::DisplayWidth::DEPTHS = T.let(T.unsafe(nil), Array)
+
+Unicode::DisplayWidth::INDEX = T.let(T.unsafe(nil), Array)
+
+Unicode::DisplayWidth::INDEX_FILENAME = T.let(T.unsafe(nil), String)
+
+Unicode::DisplayWidth::NO_STRING_EXT = T.let(T.unsafe(nil), TrueClass)
+
+Unicode::DisplayWidth::UNICODE_VERSION = T.let(T.unsafe(nil), String)
+
+Unicode::DisplayWidth::VERSION = T.let(T.unsafe(nil), String)

Library/Homebrew/sorbet/rbi/gems/webrobots@0.1.2.rbi

@@ -0,0 +1,172 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+class Nokogiri::HTML::Document < ::Nokogiri::XML::Document
+  def fragment(tags = _); end
+  def meta_encoding; end
+  def meta_encoding=(encoding); end
+  def meta_robots(custom_name = _); end
+  def nofollow?(custom_name = _); end
+  def noindex?(custom_name = _); end
+  def serialize(options = _); end
+  def title; end
+  def title=(text); end
+  def type; end
+
+  private
+
+  def meta_content_type; end
+  def parse_meta_robots(custom_name); end
+  def set_metadata_element(element); end
+
+  def self.new(*_); end
+  def self.parse(string_or_io, url = _, encoding = _, options = _); end
+  def self.read_io(_, _, _, _); end
+  def self.read_memory(_, _, _, _); end
+end
+
+class WebRobots
+  def initialize(user_agent, options = _); end
+
+  def allowed?(url); end
+  def crawl_delay(url); end
+  def create_cache; end
+  def disallowed?(url); end
+  def error(url); end
+  def error!(url); end
+  def flush_cache; end
+  def option(url, token); end
+  def options(url); end
+  def reset(url); end
+  def sitemaps(url); end
+  def user_agent; end
+
+  private
+
+  def crawl_delay_handler(delay, last_checked_at); end
+  def fetch_robots_txt(site); end
+  def get_robots_txt(site); end
+  def http_get(uri); end
+  def robots_txt_for(url); end
+  def split_uri(url); end
+end
+
+class WebRobots::Error < ::StandardError
+end
+
+class WebRobots::ParseError < ::WebRobots::Error
+  def initialize(message, site); end
+
+  def site; end
+  def to_s; end
+end
+
+class WebRobots::RobotsTxt
+  def initialize(site, records, options = _); end
+
+  def allow?(request_uri, user_agent = _); end
+  def crawl_delay(user_agent = _); end
+  def error; end
+  def error!; end
+  def error=(_); end
+  def options(user_agent = _); end
+  def site; end
+  def sitemaps; end
+  def timestamp; end
+
+  private
+
+  def find_record(user_agent = _); end
+  def target(user_agent = _); end
+
+  def self.unfetchable(site, reason, target = _); end
+end
+
+class WebRobots::RobotsTxt::AccessControlLine < ::WebRobots::RobotsTxt::Line
+  def compile; end
+  def match?(request_uri); end
+end
+
+class WebRobots::RobotsTxt::AgentLine < ::WebRobots::RobotsTxt::Line
+  def compile; end
+  def pattern; end
+end
+
+class WebRobots::RobotsTxt::AllowLine < ::WebRobots::RobotsTxt::AccessControlLine
+  def allow?; end
+end
+
+class WebRobots::RobotsTxt::CrawlDelayLine < ::WebRobots::RobotsTxt::Line
+  def compile; end
+  def delay; end
+end
+
+WebRobots::RobotsTxt::DISALLOW_ALL = T.let(T.unsafe(nil), String)
+
+class WebRobots::RobotsTxt::DisallowLine < ::WebRobots::RobotsTxt::AccessControlLine
+  def allow?; end
+end
+
+class WebRobots::RobotsTxt::ExtentionLine < ::WebRobots::RobotsTxt::Line
+end
+
+class WebRobots::RobotsTxt::Line
+  def initialize(token, value); end
+
+  def compile; end
+  def token; end
+  def value; end
+end
+
+class WebRobots::RobotsTxt::Parser < ::Racc::Parser
+  def initialize(target, crawl_delay_handler = _); end
+
+  def _reduce_1(val, _values, result); end
+  def _reduce_17(val, _values, result); end
+  def _reduce_18(val, _values, result); end
+  def _reduce_19(val, _values, result); end
+  def _reduce_2(val, _values, result); end
+  def _reduce_20(val, _values, result); end
+  def _reduce_21(val, _values, result); end
+  def _reduce_24(val, _values, result); end
+  def _reduce_25(val, _values, result); end
+  def _reduce_26(val, _values, result); end
+  def _reduce_28(val, _values, result); end
+  def _reduce_31(val, _values, result); end
+  def _reduce_32(val, _values, result); end
+  def _reduce_38(val, _values, result); end
+  def _reduce_39(val, _values, result); end
+  def _reduce_40(val, _values, result); end
+  def _reduce_41(val, _values, result); end
+  def _reduce_none(val, _values, result); end
+  def next_token; end
+  def on_error(token_id, value, stack); end
+  def parse(input, site); end
+  def parse!(input, site); end
+  def parse_error(message); end
+end
+
+WebRobots::RobotsTxt::Parser::KNOWN_TOKENS = T.let(T.unsafe(nil), Array)
+
+WebRobots::RobotsTxt::Parser::RE_KNOWN_TOKENS = T.let(T.unsafe(nil), Regexp)
+
+WebRobots::RobotsTxt::Parser::Racc_arg = T.let(T.unsafe(nil), Array)
+
+WebRobots::RobotsTxt::Parser::Racc_token_to_s_table = T.let(T.unsafe(nil), Array)
+
+class WebRobots::RobotsTxt::Record
+  def initialize(agentlines, rulelines); end
+
+  def allow?(request_uri); end
+  def default?; end
+  def delay; end
+  def match?(user_agent); end
+  def options; end
+end
+
+module Webrobots
+end
+
+Webrobots::VERSION = T.let(T.unsafe(nil), String)

Library/Homebrew/sorbet/rbi/gems/zeitwerk@2.3.0.rbi

@@ -0,0 +1,6 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   tapioca sync
+
+# typed: true
+
+

Library/Homebrew/sorbet/rbi/todo.rbi

@@ -1,81 +1,20 @@
 # This file is autogenerated. Do not edit it by hand. Regenerate it with:
 #   srb rbi todo
 
-# typed: ignore
-module ::ActiveSupport::Inflector; end
-module ::Coveralls::Output; end
-module ::Coveralls::SimpleCov::Formatter; end
-module ::I18n; end
-module ::ParallelTests; end
-module ::RSpec; end
-module ::RSpec::Core::Formatters::ProgressFormatter; end
-module ::RSpec::Matchers; end
-module ::RSpec::Matchers::DSL; end
-module ::RSpec::Support::ObjectFormatter; end
-module ::SimpleCov; end
-module ::SimpleCov::Formatter::HTMLFormatter; end
-module ::SimpleCov::Formatter::MultiFormatter; end
-module ::Tap; end
-module ::Tap::TAP_DIRECTORY; end
-module ::User; end
-module Cask::Artifact::AbstractUninstall::User; end
-module Cask::Artifact::Pkg::Plist::Emit; end
-module Cask::Artifact::Pkg::User; end
-module Cask::Cask; end
-module Cask::CaskLoader::FromTapLoader::Tap; end
-module Cask::CaskLoader::FromTapPathLoader::Tap; end
-module Cask::CaskLoader::Tap; end
-module Cask::Caskroom::User; end
-module Cask::Cmd::Doctor::Tap; end
-module Cask::Cmd::Style::Tap; end
-module Cask::Cmd::Tap; end
-module Cask::DSL::ConflictsWith; end
-module Cask::DSL::DependsOn; end
-module Cask::Staged::User; end
-module Cask::Utils::User; end
-module Commands::Tap; end
-module CurlDownloadStrategy::Mechanize::HTTP::ContentDispositionParser; end
+# typed: strong
 module DependencyCollector::Compat; end
-module DependencyCollector::Dependencies; end
-module DependencyCollector::Requirements; end
-module FormulaCellarChecks::Plist; end
-module Formulary::Tap; end
-module Formulary::TapLoader::Tap; end
-module Homebrew::Diagnostic::Checks::Tap; end
 module Homebrew::Error; end
-module Homebrew::Pry; end
-module Homebrew::Search::Tap; end
-module Homebrew::SimpleCov; end
-module Homebrew::Tap; end
-module Homebrew::Tap::TAP_DIRECTORY; end
-module Keg::MachO::MachOError; end
-module Keg::MachO::Tools; end
-module Kernel::Tap; end
 module MacOS::CLT; end
 module MacOS::CLT::PKG_PATH; end
 module MacOS::Version; end
+module MacOS::Version::SYMBOLS; end
 module MacOS::X11; end
 module MacOS::XQuartz; end
 module MacOS::Xcode; end
-module MachOShim::MachO; end
-module MachOShim::MachO::NotAMachOError; end
-module MachOShim::MachO::Utils; end
-module NoSeedProgressFormatter::RSpec::Core::Formatters; end
 module OS::Mac::Version::NULL; end
-module Reporter::Tap; end
-module RuboCop::AST::HashNode; end
-module RuboCop::AST::Node::Parser::Source::Map::Heredoc; end
-module RuboCop::AST::SendNode; end
-module RuboCop::AST::StrNode; end
-module RuboCop::Cask::AST::CaskBlock::Parser::Source::Comment; end
-module RuboCop::Cop::Cask::StanzaGrouping::RangeHelp; end
-module RuboCop::Cop::Cop; end
-module RuboCop::Cop::FormulaCop::Parser::CurrentRuby; end
-module RuboCop::Cop::FormulaCop::RangeHelp; end
-module RuboCop::RSpec::ExpectOffense; end
-module SystemCommand::Result::Plist; end
-module Tab::Tap; end
-module TapDependency::Tap; end
-module TapFormulaAmbiguityError::Tap; end
+module T::CompatibilityPatches::RSpecCompatibility::MethodDoubleExtensions; end
+module T::CompatibilityPatches::RSpecCompatibility::RecorderExtensions; end
+module T::Private::Methods::MethodHooks; end
+module T::Private::Methods::SingletonMethodHooks; end
 module Test::Unit::AssertionFailedError; end
 module Test::Unit::Assertions; end

Library/Homebrew/sorbet/tapioca/require.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+# typed: false
+
+# Add your extra requires here