diff --git a/Library/Homebrew/Gemfile.lock b/Library/Homebrew/Gemfile.lock
index c8ed41e87b2f5..5ecb1043393c0 100644
--- a/Library/Homebrew/Gemfile.lock
+++ b/Library/Homebrew/Gemfile.lock
@@ -153,7 +153,7 @@ GEM
       sorbet (~> 0.5.5)
       sorbet-runtime
       thor (>= 0.19.2)
-    tapioca (0.4.21)
+    tapioca (0.4.22)
       bundler (>= 1.17.3)
       parlour (>= 2.1.0)
       pry (>= 0.12.2)
diff --git a/Library/Homebrew/sorbet/rbi/gems/tapioca@0.4.21.rbi b/Library/Homebrew/sorbet/rbi/gems/tapioca@0.4.21.rbi
deleted file mode 100644
index b74af0ad7f4b8..0000000000000
--- a/Library/Homebrew/sorbet/rbi/gems/tapioca@0.4.21.rbi
+++ /dev/null
@@ -1,609 +0,0 @@
-# DO NOT EDIT MANUALLY
-# This is an autogenerated file for types exported from the `tapioca` gem.
-# Please instead update this file by running `bin/tapioca sync`.
-
-# typed: true
-
-module T::Generic::TypeStoragePatch
-  def [](*types); end
-  def type_member(variance = T.unsafe(nil), fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: T.unsafe(nil)); end
-  def type_template(variance = T.unsafe(nil), fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: T.unsafe(nil)); end
-end
-
-module T::Types::Simple::GenericNamePatch
-  def name; end
-end
-
-module T::Types::Simple::NamePatch
-  def name; end
-end
-
-module Tapioca
-  class << self
-    def silence_warnings(&blk); end
-  end
-end
-
-module Tapioca::Cli
-end
-
-class Tapioca::Cli::Main < ::Thor
-  include(::Thor::Actions)
-  extend(::Thor::Actions::ClassMethods)
-
-  def __print_version; end
-  def dsl(*constants); end
-  def generate(*gems); end
-  def init; end
-  def require; end
-  def sync; end
-  def todo; end
-
-  private
-
-  def create_config; end
-  def create_post_require; end
-  def generate_binstub; end
-  def generator; end
-
-  class << self
-    def exit_on_failure?; end
-  end
-end
-
-module Tapioca::Compilers
-end
-
-module Tapioca::Compilers::Dsl
-end
-
-class Tapioca::Compilers::Dsl::Base
-  abstract!
-
-  sig { void }
-  def initialize; end
-
-  sig { abstract.type_parameters(:T).params(root: Parlour::RbiGenerator::Namespace, constant: T.type_parameter(:T)).void }
-  def decorate(root, constant); end
-  sig { abstract.returns(T::Enumerable[Module]) }
-  def gather_constants; end
-  sig { params(constant: Module).returns(T::Boolean) }
-  def handles?(constant); end
-  sig { returns(T::Set[Module]) }
-  def processable_constants; end
-
-  private
-
-  sig { params(method_def: T.any(Method, UnboundMethod)).returns(T::Array[Parlour::RbiGenerator::Parameter]) }
-  def compile_method_parameters_to_parlour(method_def); end
-  sig { params(method_def: T.any(Method, UnboundMethod)).returns(T.nilable(String)) }
-  def compile_method_return_type_to_parlour(method_def); end
-  sig { params(namespace: Parlour::RbiGenerator::Namespace, name: String, options: T::Hash[T.untyped, T.untyped]).void }
-  def create_method(namespace, name, options = T.unsafe(nil)); end
-  sig { params(namespace: Parlour::RbiGenerator::Namespace, method_def: T.any(Method, UnboundMethod), class_method: T::Boolean).void }
-  def create_method_from_def(namespace, method_def, class_method: T.unsafe(nil)); end
-  sig { params(method_def: T.any(Method, UnboundMethod), signature: T.untyped).returns(T::Array[String]) }
-  def parameters_types_from_signature(method_def, signature); end
-  sig { params(name: String).returns(T::Boolean) }
-  def valid_method_name?(name); end
-end
-
-Tapioca::Compilers::Dsl::Base::SPECIAL_METHOD_NAMES = T.let(T.unsafe(nil), Array)
-
-class Tapioca::Compilers::DslCompiler
-  sig { params(requested_constants: T::Array[Module], requested_generators: T::Array[String], error_handler: T.nilable(T.proc.params(error: String).void)).void }
-  def initialize(requested_constants:, requested_generators: T.unsafe(nil), error_handler: T.unsafe(nil)); end
-
-  sig { returns(T.proc.params(error: String).void) }
-  def error_handler; end
-  sig { returns(T::Enumerable[Tapioca::Compilers::Dsl::Base]) }
-  def generators; end
-  sig { returns(T::Array[Module]) }
-  def requested_constants; end
-  sig { params(blk: T.proc.params(constant: Module, rbi: String).void).void }
-  def run(&blk); end
-
-  private
-
-  sig { params(requested_constants: T::Array[Module]).returns(T::Set[Module]) }
-  def gather_constants(requested_constants); end
-  sig { params(requested_generators: T::Array[String]).returns(T::Enumerable[Tapioca::Compilers::Dsl::Base]) }
-  def gather_generators(requested_generators); end
-  sig { params(requested_generators: T::Array[String]).returns(T.proc.params(klass: Class).returns(T::Boolean)) }
-  def generator_filter(requested_generators); end
-  sig { params(constant: Module).returns(T.nilable(String)) }
-  def rbi_for_constant(constant); end
-  sig { params(error: String).returns(T.noreturn) }
-  def report_error(error); end
-  sig { params(parlour: Parlour::RbiGenerator).void }
-  def resolve_conflicts(parlour); end
-end
-
-class Tapioca::Compilers::RequiresCompiler
-  sig { params(sorbet_path: String).void }
-  def initialize(sorbet_path); end
-
-  sig { returns(String) }
-  def compile; end
-
-  private
-
-  sig { params(config: Spoom::Sorbet::Config).returns(T::Array[String]) }
-  def collect_files(config); end
-  sig { params(file_path: String).returns(T::Enumerable[String]) }
-  def collect_requires(file_path); end
-  sig { params(config: Spoom::Sorbet::Config, file_path: Pathname).returns(T::Boolean) }
-  def file_ignored_by_sorbet?(config, file_path); end
-  sig { params(files: T::Enumerable[String], name: String).returns(T::Boolean) }
-  def name_in_project?(files, name); end
-  sig { params(path: Pathname).returns(T::Array[String]) }
-  def path_parts(path); end
-end
-
-module Tapioca::Compilers::Sorbet
-  class << self
-    sig { params(args: String).returns(String) }
-    def run(*args); end
-    sig { returns(String) }
-    def sorbet_path; end
-  end
-end
-
-Tapioca::Compilers::Sorbet::EXE_PATH_ENV_VAR = T.let(T.unsafe(nil), String)
-
-Tapioca::Compilers::Sorbet::SORBET = T.let(T.unsafe(nil), Pathname)
-
-module Tapioca::Compilers::SymbolTable
-end
-
-class Tapioca::Compilers::SymbolTable::SymbolGenerator
-  sig { params(gem: Tapioca::Gemfile::Gem, indent: Integer).void }
-  def initialize(gem, indent = T.unsafe(nil)); end
-
-  def gem; end
-  sig { returns(String) }
-  def generate; end
-  def indent; end
-
-  private
-
-  sig { params(name: String).void }
-  def add_to_alias_namespace(name); end
-  sig { params(name: String).returns(T::Boolean) }
-  def alias_namespaced?(name); end
-  sig { params(constant: Module).returns(T::Array[Module]) }
-  def ancestors_of(constant); end
-  sig { params(constant: Module, other: BasicObject).returns(T::Boolean) }
-  def are_equal?(constant, other); end
-  sig { params(constant: BasicObject).returns(Class) }
-  def class_of(constant); end
-  sig { params(name: T.nilable(String), constant: BasicObject).returns(T.nilable(String)) }
-  def compile(name, constant); end
-  sig { params(name: String, constant: Module).returns(T.nilable(String)) }
-  def compile_alias(name, constant); end
-  sig { params(name: String, constant: Module).returns(T.nilable(String)) }
-  def compile_body(name, constant); end
-  sig { params(name: String, constant: BasicObject).returns(T.nilable(String)) }
-  def compile_constant(name, constant); end
-  sig { params(module_name: String, mod: Module, for_visibility: T::Array[Symbol]).returns(T.nilable(String)) }
-  def compile_directly_owned_methods(module_name, mod, for_visibility = T.unsafe(nil)); end
-  sig { params(constant: Module).returns(T.nilable(String)) }
-  def compile_enums(constant); end
-  sig { params(symbol_name: String, constant: Module, method: T.nilable(UnboundMethod)).returns(T.nilable(String)) }
-  def compile_method(symbol_name, constant, method); end
-  sig { params(name: String, constant: Module).returns(T.nilable(String)) }
-  def compile_methods(name, constant); end
-  sig { params(constant: Module).returns(String) }
-  def compile_mixes_in_class_methods(constant); end
-  sig { params(constant: Module).returns(String) }
-  def compile_mixins(constant); end
-  sig { params(name: String, constant: Module).returns(T.nilable(String)) }
-  def compile_module(name, constant); end
-  sig { params(constant: Module).returns(T.nilable(String)) }
-  def compile_module_helpers(constant); end
-  sig { params(name: String, value: BasicObject).returns(T.nilable(String)) }
-  def compile_object(name, value); end
-  sig { params(constant: Module).returns(T.nilable(String)) }
-  def compile_props(constant); end
-  sig { params(signature: T.untyped, parameters: T::Array[[Symbol, String]]).returns(String) }
-  def compile_signature(signature, parameters); end
-  sig { params(name: String, constant: Module).returns(T.nilable(String)) }
-  def compile_subconstants(name, constant); end
-  sig { params(constant: Class).returns(String) }
-  def compile_superclass(constant); end
-  sig { params(constant: Module).returns(T.nilable(String)) }
-  def compile_type_variable_declarations(constant); end
-  sig { params(constant: Module).returns(T.nilable(String)) }
-  def compile_type_variables(constant); end
-  sig { params(constant: Module).returns(T::Array[Symbol]) }
-  def constants_of(constant); end
-  sig { params(constant: Module, strict: T::Boolean).returns(T::Boolean) }
-  def defined_in_gem?(constant, strict: T.unsafe(nil)); end
-  sig { params(symbols: T::Set[String]).returns(T::Set[String]) }
-  def engine_symbols(symbols); end
-  sig { params(symbol: String).returns(T.nilable(String)) }
-  def generate_from_symbol(symbol); end
-  sig { params(constant: Module).returns(T::Array[String]) }
-  def get_file_candidates(constant); end
-  sig { params(str: String).returns(String) }
-  def indented(str); end
-  sig { params(constant: Module).returns(T::Array[Module]) }
-  def inherited_ancestors_of(constant); end
-  def initialize_method_for(constant); end
-  sig { params(constant: Module).returns(T::Array[Module]) }
-  def interesting_ancestors_of(constant); end
-  sig { params(name: String).void }
-  def mark_seen(name); end
-  sig { params(method: UnboundMethod).returns(T::Boolean) }
-  def method_in_gem?(method); end
-  sig { params(mod: Module).returns(T::Hash[Symbol, T::Array[Symbol]]) }
-  def method_names_by_visibility(mod); end
-  sig { params(constant: Module).returns(T.nilable(String)) }
-  def name_of(constant); end
-  sig { params(constant: Module).returns(T.nilable(String)) }
-  def name_of_proxy_target(constant); end
-  sig { params(object: BasicObject).returns(Integer) }
-  def object_id_of(object); end
-  def parent_declares_constant?(name); end
-  sig { params(constant: Module).returns(T::Boolean) }
-  def public_module?(constant); end
-  sig { params(constant: Module).returns(T.nilable(String)) }
-  def qualified_name_of(constant); end
-  sig { params(constant: Module).returns(T.nilable(String)) }
-  def raw_name_of(constant); end
-  sig { params(symbol: String, inherit: T::Boolean, namespace: Module).returns(BasicObject) }
-  def resolve_constant(symbol, inherit: T.unsafe(nil), namespace: T.unsafe(nil)); end
-  sig { params(name: String).returns(T::Boolean) }
-  def seen?(name); end
-  sig { params(method: T.any(Method, UnboundMethod)).returns(T.untyped) }
-  def signature_of(method); end
-  sig { params(constant: Module).returns(Class) }
-  def singleton_class_of(constant); end
-  sig { params(constant: Module, method_name: String).returns(T::Boolean) }
-  def struct_method?(constant, method_name); end
-  sig { params(constant: Class).returns(T.nilable(Class)) }
-  def superclass_of(constant); end
-  sig { params(symbol_name: String).returns(T::Boolean) }
-  def symbol_ignored?(symbol_name); end
-  sig { returns(T::Set[String]) }
-  def symbols; end
-  sig { params(constant: T::Types::Base).returns(String) }
-  def type_of(constant); end
-  sig { params(name: String).returns(T::Boolean) }
-  def valid_method_name?(name); end
-  sig { type_parameters(:U).params(step: Integer, _blk: T.proc.returns(T.type_parameter(:U))).returns(T.type_parameter(:U)) }
-  def with_indentation(step = T.unsafe(nil), &_blk); end
-  sig { params(constant: Module, blk: T.proc.returns(T.nilable(String))).returns(T.nilable(String)) }
-  def with_indentation_for_constant(constant, &blk); end
-end
-
-Tapioca::Compilers::SymbolTable::SymbolGenerator::IGNORED_SYMBOLS = T.let(T.unsafe(nil), Array)
-
-Tapioca::Compilers::SymbolTable::SymbolGenerator::SPECIAL_METHOD_NAMES = T.let(T.unsafe(nil), Array)
-
-Tapioca::Compilers::SymbolTable::SymbolGenerator::TYPE_PARAMETER_MATCHER = T.let(T.unsafe(nil), Regexp)
-
-module Tapioca::Compilers::SymbolTable::SymbolLoader
-  class << self
-    def ignore_symbol?(symbol); end
-    sig { params(paths: T::Array[Pathname]).returns(T::Set[String]) }
-    def list_from_paths(paths); end
-
-    private
-
-    def ignored_symbols; end
-    sig { params(paths: T::Array[String]).returns(T::Set[String]) }
-    def load_symbols(paths); end
-    def symbol_table_json_from(input, table_type: T.unsafe(nil)); end
-  end
-end
-
-class Tapioca::Compilers::SymbolTable::SymbolLoader::SymbolTableParser
-  class << self
-    def parse(object, parents = T.unsafe(nil)); end
-  end
-end
-
-class Tapioca::Compilers::SymbolTableCompiler
-  sig { params(gem: Tapioca::Gemfile::Gem, indent: Integer).returns(String) }
-  def compile(gem, indent = T.unsafe(nil)); end
-end
-
-class Tapioca::Compilers::TodosCompiler
-  sig { returns(String) }
-  def compile; end
-
-  private
-
-  sig { returns(String) }
-  def list_todos; end
-end
-
-class Tapioca::Config < ::T::Struct
-  const :outdir, String
-  const :prerequire, T.nilable(String)
-  const :postrequire, String
-  const :exclude, T::Array[String]
-  const :typed_overrides, T::Hash[String, String]
-  const :todos_path, String
-  const :generators, T::Array[String]
-
-  sig { returns(Pathname) }
-  def outpath; end
-
-  class << self
-    def inherited(s); end
-  end
-end
-
-Tapioca::Config::DEFAULT_COMMAND = T.let(T.unsafe(nil), String)
-
-Tapioca::Config::DEFAULT_DSLDIR = T.let(T.unsafe(nil), String)
-
-Tapioca::Config::DEFAULT_GEMDIR = T.let(T.unsafe(nil), String)
-
-Tapioca::Config::DEFAULT_OVERRIDES = T.let(T.unsafe(nil), Hash)
-
-Tapioca::Config::DEFAULT_POSTREQUIRE = T.let(T.unsafe(nil), String)
-
-Tapioca::Config::DEFAULT_RBIDIR = T.let(T.unsafe(nil), String)
-
-Tapioca::Config::DEFAULT_TODOSPATH = T.let(T.unsafe(nil), String)
-
-Tapioca::Config::SORBET_CONFIG = T.let(T.unsafe(nil), String)
-
-Tapioca::Config::SORBET_PATH = T.let(T.unsafe(nil), String)
-
-Tapioca::Config::TAPIOCA_CONFIG = T.let(T.unsafe(nil), String)
-
-Tapioca::Config::TAPIOCA_PATH = T.let(T.unsafe(nil), String)
-
-class Tapioca::ConfigBuilder
-  class << self
-    sig { params(command: Symbol, options: T::Hash[String, T.untyped]).returns(Tapioca::Config) }
-    def from_options(command, options); end
-
-    private
-
-    sig { returns(T::Hash[String, T.untyped]) }
-    def config_options; end
-    sig { params(command: Symbol).returns(T::Hash[String, T.untyped]) }
-    def default_options(command); end
-    sig { params(options: T::Hash[String, T.untyped]).returns(T::Hash[String, T.untyped]) }
-    def merge_options(*options); end
-  end
-end
-
-Tapioca::ConfigBuilder::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
-
-module Tapioca::ConstantLocator
-
-  private
-
-  def files_for(klass); end
-
-  class << self
-    def files_for(klass); end
-  end
-end
-
-class Tapioca::Error < ::StandardError
-end
-
-class Tapioca::Gemfile
-  sig { void }
-  def initialize; end
-
-  sig { returns(Bundler::Definition) }
-  def definition; end
-  sig { returns(T::Array[Tapioca::Gemfile::Gem]) }
-  def dependencies; end
-  sig { params(gem_name: String).returns(T.nilable(Tapioca::Gemfile::Gem)) }
-  def gem(gem_name); end
-  sig { returns(T::Array[String]) }
-  def missing_specs; end
-  sig { void }
-  def require; end
-
-  private
-
-  sig { returns(String) }
-  def dir; end
-  sig { returns(File) }
-  def gemfile; end
-  sig { returns(T::Array[Symbol]) }
-  def groups; end
-  sig { returns([T::Array[Tapioca::Gemfile::Gem], T::Array[String]]) }
-  def load_dependencies; end
-  def lockfile; end
-  sig { returns(Bundler::Runtime) }
-  def runtime; end
-end
-
-class Tapioca::Gemfile::Gem
-  sig { params(spec: T.any(Gem::Specification, T.all(Bundler::RemoteSpecification, Bundler::StubSpecification))).void }
-  def initialize(spec); end
-
-  sig { params(path: String).returns(T::Boolean) }
-  def contains_path?(path); end
-  sig { returns(T::Array[Pathname]) }
-  def files; end
-  sig { returns(String) }
-  def full_gem_path; end
-  sig { params(gemfile_dir: String).returns(T::Boolean) }
-  def ignore?(gemfile_dir); end
-  sig { returns(String) }
-  def name; end
-  sig { returns(String) }
-  def rbi_file_name; end
-  def version; end
-
-  private
-
-  sig { returns(T::Boolean) }
-  def gem_ignored?; end
-  sig { params(gemfile_dir: String).returns(T::Boolean) }
-  def gem_in_app_dir?(gemfile_dir); end
-  sig { returns(T::Boolean) }
-  def gem_in_bundle_path?; end
-  sig { params(path: String).returns(T::Boolean) }
-  def has_parent_gemspec?(path); end
-  sig { params(path: T.any(Pathname, String)).returns(String) }
-  def to_realpath(path); end
-  sig { returns(String) }
-  def version_string; end
-end
-
-Tapioca::Gemfile::Gem::IGNORED_GEMS = T.let(T.unsafe(nil), Array)
-
-class Tapioca::Generator < ::Thor::Shell::Color
-  sig { params(config: Tapioca::Config).void }
-  def initialize(config); end
-
-  sig { params(requested_constants: T::Array[String], should_verify: T::Boolean, quiet: T::Boolean).void }
-  def build_dsl(requested_constants, should_verify: T.unsafe(nil), quiet: T.unsafe(nil)); end
-  sig { params(gem_names: T::Array[String]).void }
-  def build_gem_rbis(gem_names); end
-  sig { void }
-  def build_requires; end
-  sig { void }
-  def build_todos; end
-  sig { returns(Tapioca::Config) }
-  def config; end
-  sig { void }
-  def sync_rbis_with_gemfile; end
-
-  private
-
-  sig { params(filename: Pathname).void }
-  def add(filename); end
-  sig { returns(T::Array[String]) }
-  def added_rbis; end
-  sig { params(cause: Symbol, files: T::Array[String]).returns(String) }
-  def build_error_for_files(cause, files); end
-  sig { returns(Tapioca::Gemfile) }
-  def bundle; end
-  sig { params(constant_name: String, contents: String, outpath: Pathname, quiet: T::Boolean).returns(T.nilable(Pathname)) }
-  def compile_dsl_rbi(constant_name, contents, outpath: T.unsafe(nil), quiet: T.unsafe(nil)); end
-  sig { params(gem: Tapioca::Gemfile::Gem).void }
-  def compile_gem_rbi(gem); end
-  sig { returns(Tapioca::Compilers::SymbolTableCompiler) }
-  def compiler; end
-  sig { params(constant_names: T::Array[String]).returns(T::Array[Module]) }
-  def constantize(constant_names); end
-  sig { params(constant_name: String).returns(Pathname) }
-  def dsl_rbi_filename(constant_name); end
-  sig { params(gem_name: String).returns(Pathname) }
-  def existing_rbi(gem_name); end
-  sig { params(requested_constants: T::Array[String], path: Pathname).returns(T::Set[Pathname]) }
-  def existing_rbi_filenames(requested_constants, path: T.unsafe(nil)); end
-  sig { returns(T::Hash[String, String]) }
-  def existing_rbis; end
-  sig { params(gem_name: String).returns(Pathname) }
-  def expected_rbi(gem_name); end
-  sig { returns(T::Hash[String, String]) }
-  def expected_rbis; end
-  sig { params(file: String, error: LoadError).void }
-  def explain_failed_require(file, error); end
-  sig { params(gem_name: String).returns(T::Boolean) }
-  def gem_rbi_exists?(gem_name); end
-  sig { params(gem_name: String, version: String).returns(Pathname) }
-  def gem_rbi_filename(gem_name, version); end
-  sig { params(gem_names: T::Array[String]).returns(T::Array[Tapioca::Gemfile::Gem]) }
-  def gems_to_generate(gem_names); end
-  sig { params(eager_load: T::Boolean).void }
-  def load_application(eager_load:); end
-  sig { void }
-  def load_dsl_generators; end
-  sig { returns(Tapioca::Loader) }
-  def loader; end
-  sig { params(old_filename: Pathname, new_filename: Pathname).void }
-  def move(old_filename, new_filename); end
-  sig { void }
-  def perform_additions; end
-  sig { params(dir: Pathname).void }
-  def perform_dsl_verification(dir); end
-  sig { void }
-  def perform_removals; end
-  sig { params(files: T::Set[Pathname]).void }
-  def purge_stale_dsl_rbi_files(files); end
-  sig { params(path: Pathname).returns(T::Array[Pathname]) }
-  def rbi_files_in(path); end
-  sig { params(command: String, reason: T.nilable(String), strictness: T.nilable(String)).returns(String) }
-  def rbi_header(command, reason: T.unsafe(nil), strictness: T.unsafe(nil)); end
-  sig { params(filename: Pathname).void }
-  def remove(filename); end
-  sig { returns(T::Array[String]) }
-  def removed_rbis; end
-  sig { void }
-  def require_gem_file; end
-  sig { params(message: String, color: T.any(Symbol, T::Array[Symbol])).void }
-  def say_error(message = T.unsafe(nil), *color); end
-  sig { params(tmp_dir: Pathname).returns(T::Hash[String, Symbol]) }
-  def verify_dsl_rbi(tmp_dir:); end
-end
-
-Tapioca::Generator::EMPTY_RBI_COMMENT = T.let(T.unsafe(nil), String)
-
-module Tapioca::GenericTypeRegistry
-  class << self
-    sig { params(constant: Module).returns(T.nilable(T::Hash[Integer, String])) }
-    def lookup_type_variables(constant); end
-    sig { params(constant: T.untyped, types: T.untyped).returns(Module) }
-    def register_type(constant, types); end
-    sig { params(constant: T.untyped, type_member: T::Types::TypeVariable, fixed: T.untyped, lower: T.untyped, upper: T.untyped).void }
-    def register_type_member(constant, type_member, fixed, lower, upper); end
-    sig { params(constant: T.untyped, type_template: T::Types::TypeVariable, fixed: T.untyped, lower: T.untyped, upper: T.untyped).void }
-    def register_type_template(constant, type_template, fixed, lower, upper); end
-
-    private
-
-    sig { params(constant: Module, name: String).returns(Module) }
-    def create_generic_type(constant, name); end
-    sig { params(constant: Class).returns(Class) }
-    def create_safe_subclass(constant); end
-    sig { params(constant: Module).returns(T::Hash[Integer, String]) }
-    def lookup_or_initialize_type_variables(constant); end
-    sig { params(constant: Module).returns(T.nilable(String)) }
-    def name_of(constant); end
-    sig { params(object: BasicObject).returns(Integer) }
-    def object_id_of(object); end
-    sig { params(constant: T.untyped, type_variable_type: T.enum([:type_member, :type_template]), type_variable: T::Types::TypeVariable, fixed: T.untyped, lower: T.untyped, upper: T.untyped).void }
-    def register_type_variable(constant, type_variable_type, type_variable, fixed, lower, upper); end
-    sig { params(type_variable_type: Symbol, variance: Symbol, fixed: T.untyped, lower: T.untyped, upper: T.untyped).returns(String) }
-    def serialize_type_variable(type_variable_type, variance, fixed, lower, upper); end
-  end
-end
-
-class Tapioca::Loader
-  sig { params(gemfile: Tapioca::Gemfile).void }
-  def initialize(gemfile); end
-
-  sig { params(initialize_file: T.nilable(String), require_file: T.nilable(String)).void }
-  def load_bundle(initialize_file, require_file); end
-  sig { params(environment_load: T::Boolean, eager_load: T::Boolean).void }
-  def load_rails(environment_load: T.unsafe(nil), eager_load: T.unsafe(nil)); end
-
-  private
-
-  sig { void }
-  def eager_load_rails_app; end
-  sig { returns(Tapioca::Gemfile) }
-  def gemfile; end
-  sig { void }
-  def load_rails_engines; end
-  sig { void }
-  def load_rake; end
-  sig { returns(T::Array[T.untyped]) }
-  def rails_engines; end
-  sig { void }
-  def require_bundle; end
-  sig { params(file: T.nilable(String)).void }
-  def require_helper(file); end
-  sig { params(path: String).void }
-  def safe_require(path); end
-  sig { void }
-  def silence_deprecations; end
-end
-
-Tapioca::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/sorbet/rbi/gems/tapioca@0.4.22.rbi b/Library/Homebrew/sorbet/rbi/gems/tapioca@0.4.22.rbi
new file mode 100644
index 0000000000000..a7f9ba3b35056
--- /dev/null
+++ b/Library/Homebrew/sorbet/rbi/gems/tapioca@0.4.22.rbi
@@ -0,0 +1,1814 @@
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `tapioca` gem.
+# Please instead update this file by running `bin/tapioca sync`.
+
+# typed: true
+
+class Parlour::Generator
+  sig { params(break_params: Integer, tab_size: Integer, sort_namespaces: T::Boolean).void }
+  def initialize(break_params: T.unsafe(nil), tab_size: T.unsafe(nil), sort_namespaces: T.unsafe(nil)); end
+
+  sig { overridable.returns(T.nilable(Parlour::Plugin)) }
+  def current_plugin; end
+
+  def current_plugin=(_arg0); end
+
+  sig { overridable.returns(Parlour::Options) }
+  def options; end
+end
+
+class Parlour::Options
+  sig { params(break_params: Integer, tab_size: Integer, sort_namespaces: T::Boolean).void }
+  def initialize(break_params:, tab_size:, sort_namespaces:); end
+
+  sig { returns(Integer) }
+  def break_params; end
+
+  sig { params(level: Integer, str: String).returns(String) }
+  def indented(level, str); end
+
+  sig { returns(T::Boolean) }
+  def sort_namespaces; end
+
+  sig { returns(Integer) }
+  def tab_size; end
+end
+
+class Parlour::RbiGenerator < ::Parlour::Generator
+  def initialize(**hash); end
+
+  sig { overridable.params(strictness: String).returns(String) }
+  def rbi(strictness = T.unsafe(nil)); end
+
+  sig { overridable.returns(Parlour::RbiGenerator::Namespace) }
+  def root; end
+end
+
+class Parlour::RbiGenerator::Arbitrary < ::Parlour::RbiGenerator::RbiObject
+  sig { params(generator: Parlour::Generator, code: String, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Arbitrary).void)).void }
+  def initialize(generator, code: T.unsafe(nil), &block); end
+
+  sig { params(other: Object).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { returns(String) }
+  def code; end
+
+  def code=(_arg0); end
+
+  sig { override.returns(String) }
+  def describe; end
+
+  sig { override.void }
+  def generalize_from_rbi!; end
+
+  sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
+  def generate_rbi(indent_level, options); end
+
+  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
+  def merge_into_self(others); end
+
+  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+  def mergeable?(others); end
+end
+
+class Parlour::RbiGenerator::Attribute < ::Parlour::RbiGenerator::Method
+  sig { params(generator: Parlour::Generator, name: String, kind: Symbol, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).void }
+  def initialize(generator, name, kind, type, class_attribute: T.unsafe(nil), &block); end
+
+  sig { override.params(other: Object).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { returns(T::Boolean) }
+  def class_attribute; end
+
+  sig { override.void }
+  def generalize_from_rbi!; end
+
+  sig { returns(Symbol) }
+  def kind; end
+
+  sig { returns(T.any(Parlour::Types::Type, String)) }
+  def type; end
+
+  private
+
+  sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
+  def generate_definition(indent_level, options); end
+end
+
+class Parlour::RbiGenerator::ClassNamespace < ::Parlour::RbiGenerator::Namespace
+  sig { params(generator: Parlour::Generator, name: String, final: T::Boolean, sealed: T::Boolean, superclass: T.nilable(String), abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)).void }
+  def initialize(generator, name, final, sealed, superclass, abstract, &block); end
+
+  sig { returns(T::Boolean) }
+  def abstract; end
+
+  sig { override.returns(String) }
+  def describe; end
+
+  sig { override.void }
+  def generalize_from_rbi!; end
+
+  sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
+  def generate_rbi(indent_level, options); end
+
+  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
+  def merge_into_self(others); end
+
+  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+  def mergeable?(others); end
+
+  sig { returns(T.nilable(String)) }
+  def superclass; end
+end
+
+class Parlour::RbiGenerator::Constant < ::Parlour::RbiGenerator::RbiObject
+  sig { params(generator: Parlour::Generator, name: String, value: T.any(Parlour::Types::Type, String), eigen_constant: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Constant).void)).void }
+  def initialize(generator, name: T.unsafe(nil), value: T.unsafe(nil), eigen_constant: T.unsafe(nil), &block); end
+
+  sig { params(other: Object).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.returns(String) }
+  def describe; end
+
+  def eigen_constant; end
+
+  sig { override.void }
+  def generalize_from_rbi!; end
+
+  sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
+  def generate_rbi(indent_level, options); end
+
+  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
+  def merge_into_self(others); end
+
+  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+  def mergeable?(others); end
+
+  sig { returns(T.any(Parlour::Types::Type, String)) }
+  def value; end
+end
+
+class Parlour::RbiGenerator::EnumClassNamespace < ::Parlour::RbiGenerator::ClassNamespace
+  sig { params(generator: Parlour::Generator, name: String, final: T::Boolean, sealed: T::Boolean, enums: T::Array[T.any(String, [String, String])], abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::EnumClassNamespace).void)).void }
+  def initialize(generator, name, final, sealed, enums, abstract, &block); end
+
+  sig { returns(T::Array[T.any(String, [String, String])]) }
+  def enums; end
+
+  sig { override.void }
+  def generalize_from_rbi!; end
+
+  sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
+  def generate_body(indent_level, options); end
+
+  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
+  def merge_into_self(others); end
+
+  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+  def mergeable?(others); end
+end
+
+class Parlour::RbiGenerator::Extend < ::Parlour::RbiGenerator::RbiObject
+  sig { params(generator: Parlour::Generator, name: String, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Extend).void)).void }
+  def initialize(generator, name: T.unsafe(nil), &block); end
+
+  sig { params(other: Object).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.returns(String) }
+  def describe; end
+
+  sig { override.void }
+  def generalize_from_rbi!; end
+
+  sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
+  def generate_rbi(indent_level, options); end
+
+  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
+  def merge_into_self(others); end
+
+  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+  def mergeable?(others); end
+end
+
+class Parlour::RbiGenerator::Include < ::Parlour::RbiGenerator::RbiObject
+  sig { params(generator: Parlour::Generator, name: String, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Include).void)).void }
+  def initialize(generator, name: T.unsafe(nil), &block); end
+
+  sig { params(other: Object).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.returns(String) }
+  def describe; end
+
+  sig { override.void }
+  def generalize_from_rbi!; end
+
+  sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
+  def generate_rbi(indent_level, options); end
+
+  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
+  def merge_into_self(others); end
+
+  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+  def mergeable?(others); end
+end
+
+class Parlour::RbiGenerator::Method < ::Parlour::RbiGenerator::RbiObject
+  sig { params(generator: Parlour::Generator, name: String, parameters: T::Array[Parlour::RbiGenerator::Parameter], return_type: T.nilable(T.any(Parlour::Types::Type, String)), abstract: T::Boolean, implementation: T::Boolean, override: T::Boolean, overridable: T::Boolean, class_method: T::Boolean, final: T::Boolean, type_parameters: T.nilable(T::Array[Symbol]), block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Method).void)).void }
+  def initialize(generator, name, parameters, return_type = T.unsafe(nil), abstract: T.unsafe(nil), implementation: T.unsafe(nil), override: T.unsafe(nil), overridable: T.unsafe(nil), class_method: T.unsafe(nil), final: T.unsafe(nil), type_parameters: T.unsafe(nil), &block); end
+
+  sig { overridable.params(other: Object).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { returns(T::Boolean) }
+  def abstract; end
+
+  sig { returns(T::Boolean) }
+  def class_method; end
+
+  sig { override.returns(String) }
+  def describe; end
+
+  sig { returns(T::Boolean) }
+  def final; end
+
+  sig { override.void }
+  def generalize_from_rbi!; end
+
+  sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
+  def generate_rbi(indent_level, options); end
+
+  sig { returns(T::Boolean) }
+  def implementation; end
+
+  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
+  def merge_into_self(others); end
+
+  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+  def mergeable?(others); end
+
+  sig { returns(T::Boolean) }
+  def overridable; end
+
+  sig { returns(T::Boolean) }
+  def override; end
+
+  sig { returns(T::Array[Parlour::RbiGenerator::Parameter]) }
+  def parameters; end
+
+  sig { returns(T.nilable(T.any(Parlour::Types::Type, String))) }
+  def return_type; end
+
+  sig { returns(T::Array[Symbol]) }
+  def type_parameters; end
+
+  private
+
+  sig { overridable.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
+  def generate_definition(indent_level, options); end
+
+  sig { returns(String) }
+  def qualifiers; end
+end
+
+class Parlour::RbiGenerator::ModuleNamespace < ::Parlour::RbiGenerator::Namespace
+  sig { params(generator: Parlour::Generator, name: String, final: T::Boolean, sealed: T::Boolean, interface: T::Boolean, abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)).void }
+  def initialize(generator, name, final, sealed, interface, abstract, &block); end
+
+  sig { returns(T::Boolean) }
+  def abstract; end
+
+  sig { override.returns(String) }
+  def describe; end
+
+  sig { override.void }
+  def generalize_from_rbi!; end
+
+  sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
+  def generate_rbi(indent_level, options); end
+
+  sig { returns(T::Boolean) }
+  def interface; end
+
+  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
+  def merge_into_self(others); end
+
+  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+  def mergeable?(others); end
+end
+
+class Parlour::RbiGenerator::Namespace < ::Parlour::RbiGenerator::RbiObject
+  sig { params(generator: Parlour::Generator, name: T.nilable(String), final: T::Boolean, sealed: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Namespace).void)).void }
+  def initialize(generator, name = T.unsafe(nil), final = T.unsafe(nil), sealed = T.unsafe(nil), &block); end
+
+  sig { params(comment: T.any(String, T::Array[String])).void }
+  def add_comment_to_next_child(comment); end
+
+  sig { returns(T::Array[Parlour::RbiGenerator::TypeAlias]) }
+  def aliases; end
+
+  sig { returns(T::Array[Parlour::RbiGenerator::RbiObject]) }
+  def children; end
+
+  sig { returns(T::Array[Parlour::RbiGenerator::Constant]) }
+  def constants; end
+
+  def create_arbitrary(code:, &block); end
+  def create_attr(*args, &blk); end
+
+  sig { params(name: String, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).returns(Parlour::RbiGenerator::Attribute) }
+  def create_attr_accessor(name, type:, class_attribute: T.unsafe(nil), &block); end
+
+  sig { params(name: String, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).returns(Parlour::RbiGenerator::Attribute) }
+  def create_attr_reader(name, type:, class_attribute: T.unsafe(nil), &block); end
+
+  sig { params(name: String, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).returns(Parlour::RbiGenerator::Attribute) }
+  def create_attr_writer(name, type:, class_attribute: T.unsafe(nil), &block); end
+
+  sig { params(name: String, kind: Symbol, type: T.any(Parlour::Types::Type, String), class_attribute: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Attribute).void)).returns(Parlour::RbiGenerator::Attribute) }
+  def create_attribute(name, kind:, type:, class_attribute: T.unsafe(nil), &block); end
+
+  sig { params(name: String, final: T::Boolean, sealed: T::Boolean, superclass: T.nilable(String), abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)).returns(Parlour::RbiGenerator::ClassNamespace) }
+  def create_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), superclass: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
+
+  sig { params(name: String, value: String, eigen_constant: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Constant).void)).returns(Parlour::RbiGenerator::Constant) }
+  def create_constant(name, value:, eigen_constant: T.unsafe(nil), &block); end
+
+  sig { params(name: String, final: T::Boolean, sealed: T::Boolean, enums: T.nilable(T::Array[T.any(String, [String, String])]), abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::EnumClassNamespace).void)).returns(Parlour::RbiGenerator::EnumClassNamespace) }
+  def create_enum_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), enums: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
+
+  sig { params(name: String, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Extend).void)).returns(Parlour::RbiGenerator::Extend) }
+  def create_extend(name, &block); end
+
+  sig { params(extendables: T::Array[String]).returns(T::Array[Parlour::RbiGenerator::Extend]) }
+  def create_extends(extendables); end
+
+  sig { params(name: String, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Include).void)).returns(Parlour::RbiGenerator::Include) }
+  def create_include(name, &block); end
+
+  sig { params(includables: T::Array[String]).returns(T::Array[Parlour::RbiGenerator::Include]) }
+  def create_includes(includables); end
+
+  sig { params(name: String, parameters: T.nilable(T::Array[Parlour::RbiGenerator::Parameter]), return_type: T.nilable(T.any(Parlour::Types::Type, String)), returns: T.nilable(T.any(Parlour::Types::Type, String)), abstract: T::Boolean, implementation: T::Boolean, override: T::Boolean, overridable: T::Boolean, class_method: T::Boolean, final: T::Boolean, type_parameters: T.nilable(T::Array[Symbol]), block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::Method).void)).returns(Parlour::RbiGenerator::Method) }
+  def create_method(name, parameters: T.unsafe(nil), return_type: T.unsafe(nil), returns: T.unsafe(nil), abstract: T.unsafe(nil), implementation: T.unsafe(nil), override: T.unsafe(nil), overridable: T.unsafe(nil), class_method: T.unsafe(nil), final: T.unsafe(nil), type_parameters: T.unsafe(nil), &block); end
+
+  sig { params(name: String, final: T::Boolean, sealed: T::Boolean, interface: T::Boolean, abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::ClassNamespace).void)).returns(Parlour::RbiGenerator::ModuleNamespace) }
+  def create_module(name, final: T.unsafe(nil), sealed: T.unsafe(nil), interface: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
+
+  sig { params(name: String, final: T::Boolean, sealed: T::Boolean, props: T.nilable(T::Array[Parlour::RbiGenerator::StructProp]), abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::StructClassNamespace).void)).returns(Parlour::RbiGenerator::StructClassNamespace) }
+  def create_struct_class(name, final: T.unsafe(nil), sealed: T.unsafe(nil), props: T.unsafe(nil), abstract: T.unsafe(nil), &block); end
+
+  sig { params(name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::TypeAlias).void)).returns(Parlour::RbiGenerator::TypeAlias) }
+  def create_type_alias(name, type:, &block); end
+
+  sig { override.overridable.returns(String) }
+  def describe; end
+
+  sig { returns(T::Array[Parlour::RbiGenerator::Extend]) }
+  def extends; end
+
+  sig { returns(T::Boolean) }
+  def final; end
+
+  sig { override.void }
+  def generalize_from_rbi!; end
+
+  sig { override.overridable.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
+  def generate_rbi(indent_level, options); end
+
+  sig { returns(T::Array[Parlour::RbiGenerator::Include]) }
+  def includes; end
+
+  sig { override.overridable.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
+  def merge_into_self(others); end
+
+  sig { override.overridable.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+  def mergeable?(others); end
+
+  sig { params(constant: Module, block: T.proc.params(x: Parlour::RbiGenerator::Namespace).void).void }
+  def path(constant, &block); end
+
+  sig { returns(T::Boolean) }
+  def sealed; end
+
+  def type_aliases(*args, &blk); end
+
+  private
+
+  sig { overridable.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
+  def generate_body(indent_level, options); end
+
+  sig { params(object: Parlour::RbiGenerator::RbiObject).void }
+  def move_next_comments(object); end
+end
+
+Parlour::RbiGenerator::Options = Parlour::Options
+
+class Parlour::RbiGenerator::Parameter
+  sig { params(name: String, type: T.nilable(T.any(Parlour::Types::Type, String)), default: T.nilable(String)).void }
+  def initialize(name, type: T.unsafe(nil), default: T.unsafe(nil)); end
+
+  sig { params(other: Object).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { returns(T.nilable(String)) }
+  def default; end
+
+  sig { void }
+  def generalize_from_rbi!; end
+
+  sig { returns(Symbol) }
+  def kind; end
+
+  sig { returns(String) }
+  def name; end
+
+  sig { returns(String) }
+  def name_without_kind; end
+
+  sig { returns(String) }
+  def to_def_param; end
+
+  sig { returns(String) }
+  def to_sig_param; end
+
+  sig { returns(T.any(Parlour::Types::Type, String)) }
+  def type; end
+end
+
+Parlour::RbiGenerator::Parameter::PREFIXES = T.let(T.unsafe(nil), Hash)
+
+class Parlour::RbiGenerator::RbiObject < ::Parlour::TypedObject
+  abstract!
+
+  sig { params(generator: Parlour::Generator, name: String).void }
+  def initialize(generator, name); end
+
+  sig { override.overridable.returns(String) }
+  def describe; end
+
+  sig { abstract.void }
+  def generalize_from_rbi!; end
+
+  sig { abstract.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
+  def generate_rbi(indent_level, options); end
+
+  sig { returns(Parlour::Generator) }
+  def generator; end
+
+  sig { abstract.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
+  def merge_into_self(others); end
+
+  sig { abstract.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+  def mergeable?(others); end
+end
+
+class Parlour::RbiGenerator::StructClassNamespace < ::Parlour::RbiGenerator::ClassNamespace
+  sig { params(generator: Parlour::Generator, name: String, final: T::Boolean, sealed: T::Boolean, props: T::Array[Parlour::RbiGenerator::StructProp], abstract: T::Boolean, block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::StructClassNamespace).void)).void }
+  def initialize(generator, name, final, sealed, props, abstract, &block); end
+
+  sig { override.void }
+  def generalize_from_rbi!; end
+
+  sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
+  def generate_body(indent_level, options); end
+
+  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
+  def merge_into_self(others); end
+
+  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+  def mergeable?(others); end
+
+  sig { returns(T::Array[Parlour::RbiGenerator::StructProp]) }
+  def props; end
+end
+
+class Parlour::RbiGenerator::StructProp
+  sig { params(name: String, type: T.any(Parlour::Types::Type, String), optional: T.nilable(T.any(Symbol, T::Boolean)), enum: T.nilable(String), dont_store: T.nilable(T::Boolean), foreign: T.nilable(String), default: T.nilable(String), factory: T.nilable(String), immutable: T.nilable(T::Boolean), array: T.nilable(String), override: T.nilable(T::Boolean), redaction: T.nilable(String)).void }
+  def initialize(name, type, optional: T.unsafe(nil), enum: T.unsafe(nil), dont_store: T.unsafe(nil), foreign: T.unsafe(nil), default: T.unsafe(nil), factory: T.unsafe(nil), immutable: T.unsafe(nil), array: T.unsafe(nil), override: T.unsafe(nil), redaction: T.unsafe(nil)); end
+
+  sig { params(other: Object).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { returns(T.nilable(String)) }
+  def array; end
+
+  sig { returns(T.nilable(String)) }
+  def default; end
+
+  sig { returns(T.nilable(T::Boolean)) }
+  def dont_store; end
+
+  sig { returns(T.nilable(String)) }
+  def enum; end
+
+  sig { returns(T.nilable(String)) }
+  def factory; end
+
+  sig { returns(T.nilable(String)) }
+  def foreign; end
+
+  sig { void }
+  def generalize_from_rbi!; end
+
+  sig { returns(T.nilable(T::Boolean)) }
+  def immutable; end
+
+  sig { returns(String) }
+  def name; end
+
+  sig { returns(T.nilable(T.any(Symbol, T::Boolean))) }
+  def optional; end
+
+  sig { returns(T.nilable(T::Boolean)) }
+  def override; end
+
+  sig { returns(T.nilable(String)) }
+  def redaction; end
+
+  sig { returns(String) }
+  def to_prop_call; end
+
+  sig { returns(T.any(Parlour::Types::Type, String)) }
+  def type; end
+end
+
+Parlour::RbiGenerator::StructProp::EXTRA_PROPERTIES = T.let(T.unsafe(nil), Array)
+
+class Parlour::RbiGenerator::TypeAlias < ::Parlour::RbiGenerator::RbiObject
+  sig { params(generator: Parlour::Generator, name: String, type: T.any(Parlour::Types::Type, String), block: T.nilable(T.proc.params(x: Parlour::RbiGenerator::TypeAlias).void)).void }
+  def initialize(generator, name:, type:, &block); end
+
+  sig { params(other: Object).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.returns(String) }
+  def describe; end
+
+  sig { override.void }
+  def generalize_from_rbi!; end
+
+  sig { override.params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
+  def generate_rbi(indent_level, options); end
+
+  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).void }
+  def merge_into_self(others); end
+
+  sig { override.params(others: T::Array[Parlour::RbiGenerator::RbiObject]).returns(T::Boolean) }
+  def mergeable?(others); end
+
+  sig { returns(T.any(Parlour::Types::Type, String)) }
+  def type; end
+end
+
+class Parlour::TypedObject
+  abstract!
+
+  sig { params(name: String).void }
+  def initialize(name); end
+
+  sig { params(comment: T.any(String, T::Array[String])).void }
+  def add_comment(comment); end
+
+  def add_comments(*args, &blk); end
+
+  sig { returns(T::Array[String]) }
+  def comments; end
+
+  sig { abstract.returns(String) }
+  def describe; end
+
+  sig { returns(T.nilable(Parlour::Plugin)) }
+  def generated_by; end
+
+  sig { returns(String) }
+  def name; end
+
+  protected
+
+  sig { params(indent_level: Integer, options: Parlour::Options).returns(T::Array[String]) }
+  def generate_comments(indent_level, options); end
+end
+
+class String
+  include ::Comparable
+  include ::JSON::Ext::Generator::GeneratorMethods::String
+  include ::Colorize::InstanceMethods
+  extend ::JSON::Ext::Generator::GeneratorMethods::String::Extend
+  extend ::Colorize::ClassMethods
+end
+
+String::BLANK_RE = T.let(T.unsafe(nil), Regexp)
+String::ENCODED_BLANKS = T.let(T.unsafe(nil), Concurrent::Map)
+
+module T::Generic::TypeStoragePatch
+  def [](*types); end
+  def type_member(variance = T.unsafe(nil), fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: T.unsafe(nil)); end
+  def type_template(variance = T.unsafe(nil), fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: T.unsafe(nil)); end
+end
+
+module T::Types::Simple::GenericNamePatch
+  def name; end
+end
+
+module T::Types::Simple::NamePatch
+  def name; end
+end
+
+module Tapioca
+  class << self
+    def silence_warnings(&blk); end
+  end
+end
+
+module Tapioca::Cli; end
+
+class Tapioca::Cli::Main < ::Thor
+  include ::Thor::Actions
+  extend ::Thor::Actions::ClassMethods
+
+  def __print_version; end
+  def dsl(*constants); end
+  def generate(*gems); end
+  def init; end
+  def require; end
+  def sync; end
+  def todo; end
+
+  private
+
+  def create_config; end
+  def create_post_require; end
+  def generate_binstub; end
+  def generator; end
+
+  class << self
+    def exit_on_failure?; end
+  end
+end
+
+module Tapioca::Compilers; end
+module Tapioca::Compilers::Dsl; end
+
+class Tapioca::Compilers::Dsl::Base
+  abstract!
+
+  sig { void }
+  def initialize; end
+
+  sig { abstract.type_parameters(:T).params(root: Parlour::RbiGenerator::Namespace, constant: T.type_parameter(:T)).void }
+  def decorate(root, constant); end
+
+  sig { abstract.returns(T::Enumerable[Module]) }
+  def gather_constants; end
+
+  sig { params(constant: Module).returns(T::Boolean) }
+  def handles?(constant); end
+
+  sig { returns(T::Set[Module]) }
+  def processable_constants; end
+
+  private
+
+  sig { params(method_def: T.any(Method, UnboundMethod)).returns(T::Array[Parlour::RbiGenerator::Parameter]) }
+  def compile_method_parameters_to_parlour(method_def); end
+
+  sig { params(method_def: T.any(Method, UnboundMethod)).returns(T.nilable(String)) }
+  def compile_method_return_type_to_parlour(method_def); end
+
+  sig { params(namespace: Parlour::RbiGenerator::Namespace, name: String, options: T::Hash[T.untyped, T.untyped]).void }
+  def create_method(namespace, name, options = T.unsafe(nil)); end
+
+  sig { params(namespace: Parlour::RbiGenerator::Namespace, method_def: T.any(Method, UnboundMethod), class_method: T::Boolean).void }
+  def create_method_from_def(namespace, method_def, class_method: T.unsafe(nil)); end
+
+  sig { params(method_def: T.any(Method, UnboundMethod), signature: T.untyped).returns(T::Array[String]) }
+  def parameters_types_from_signature(method_def, signature); end
+
+  sig { params(name: String).returns(T::Boolean) }
+  def valid_method_name?(name); end
+end
+
+Tapioca::Compilers::Dsl::Base::SPECIAL_METHOD_NAMES = T.let(T.unsafe(nil), Array)
+
+class Tapioca::Compilers::DslCompiler
+  sig { params(requested_constants: T::Array[Module], requested_generators: T::Array[String], error_handler: T.nilable(T.proc.params(error: String).void)).void }
+  def initialize(requested_constants:, requested_generators: T.unsafe(nil), error_handler: T.unsafe(nil)); end
+
+  sig { returns(T.proc.params(error: String).void) }
+  def error_handler; end
+
+  sig { returns(T::Enumerable[Tapioca::Compilers::Dsl::Base]) }
+  def generators; end
+
+  sig { returns(T::Array[Module]) }
+  def requested_constants; end
+
+  sig { params(blk: T.proc.params(constant: Module, rbi: String).void).void }
+  def run(&blk); end
+
+  private
+
+  sig { params(requested_constants: T::Array[Module]).returns(T::Set[Module]) }
+  def gather_constants(requested_constants); end
+
+  sig { params(requested_generators: T::Array[String]).returns(T::Enumerable[Tapioca::Compilers::Dsl::Base]) }
+  def gather_generators(requested_generators); end
+
+  sig { params(requested_generators: T::Array[String]).returns(T.proc.params(klass: Class).returns(T::Boolean)) }
+  def generator_filter(requested_generators); end
+
+  sig { params(constant: Module).returns(T.nilable(String)) }
+  def rbi_for_constant(constant); end
+
+  sig { params(error: String).returns(T.noreturn) }
+  def report_error(error); end
+
+  sig { params(parlour: Parlour::RbiGenerator).void }
+  def resolve_conflicts(parlour); end
+end
+
+class Tapioca::Compilers::RequiresCompiler
+  sig { params(sorbet_path: String).void }
+  def initialize(sorbet_path); end
+
+  sig { returns(String) }
+  def compile; end
+
+  private
+
+  sig { params(config: Spoom::Sorbet::Config).returns(T::Array[String]) }
+  def collect_files(config); end
+
+  sig { params(file_path: String).returns(T::Enumerable[String]) }
+  def collect_requires(file_path); end
+
+  sig { params(config: Spoom::Sorbet::Config, file_path: Pathname).returns(T::Boolean) }
+  def file_ignored_by_sorbet?(config, file_path); end
+
+  sig { params(files: T::Enumerable[String], name: String).returns(T::Boolean) }
+  def name_in_project?(files, name); end
+
+  sig { params(path: Pathname).returns(T::Array[String]) }
+  def path_parts(path); end
+end
+
+module Tapioca::Compilers::Sorbet
+  class << self
+    sig { params(args: String).returns(String) }
+    def run(*args); end
+
+    sig { returns(String) }
+    def sorbet_path; end
+  end
+end
+
+Tapioca::Compilers::Sorbet::EXE_PATH_ENV_VAR = T.let(T.unsafe(nil), String)
+Tapioca::Compilers::Sorbet::SORBET = T.let(T.unsafe(nil), Pathname)
+module Tapioca::Compilers::SymbolTable; end
+
+class Tapioca::Compilers::SymbolTable::SymbolGenerator
+  sig { params(gem: Tapioca::Gemfile::Gem, indent: Integer).void }
+  def initialize(gem, indent = T.unsafe(nil)); end
+
+  def gem; end
+
+  sig { returns(String) }
+  def generate; end
+
+  def indent; end
+
+  private
+
+  sig { params(name: String).void }
+  def add_to_alias_namespace(name); end
+
+  def add_to_symbol_queue(name); end
+
+  sig { params(name: String).returns(T::Boolean) }
+  def alias_namespaced?(name); end
+
+  sig { params(constant: Module).returns(T::Array[Module]) }
+  def ancestors_of(constant); end
+
+  sig { params(constant: Module, other: BasicObject).returns(T::Boolean) }
+  def are_equal?(constant, other); end
+
+  sig { params(constant: BasicObject).returns(Class) }
+  def class_of(constant); end
+
+  sig { params(tree: Tapioca::RBI::Tree, name: T.nilable(String), constant: BasicObject).void }
+  def compile(tree, name, constant); end
+
+  sig { params(tree: Tapioca::RBI::Tree, name: String, constant: Module).void }
+  def compile_alias(tree, name, constant); end
+
+  sig { params(tree: Tapioca::RBI::Tree, name: String, constant: Module).void }
+  def compile_body(tree, name, constant); end
+
+  sig { params(tree: Tapioca::RBI::Tree, name: String, constant: BasicObject).void }
+  def compile_constant(tree, name, constant); end
+
+  sig { params(tree: Tapioca::RBI::Tree, module_name: String, mod: Module, for_visibility: T::Array[Symbol]).void }
+  def compile_directly_owned_methods(tree, module_name, mod, for_visibility = T.unsafe(nil)); end
+
+  sig { params(tree: Tapioca::RBI::Tree, constant: Module).void }
+  def compile_enums(tree, constant); end
+
+  sig { params(tree: Tapioca::RBI::Tree, symbol_name: String, constant: Module, method: T.nilable(UnboundMethod), visibility: Tapioca::RBI::Visibility).void }
+  def compile_method(tree, symbol_name, constant, method, visibility = T.unsafe(nil)); end
+
+  sig { params(tree: Tapioca::RBI::Tree, name: String, constant: Module).void }
+  def compile_methods(tree, name, constant); end
+
+  sig { params(tree: Tapioca::RBI::Tree, constant: Module).void }
+  def compile_mixes_in_class_methods(tree, constant); end
+
+  sig { params(tree: Tapioca::RBI::Tree, constant: Module).void }
+  def compile_mixins(tree, constant); end
+
+  sig { params(tree: Tapioca::RBI::Tree, name: String, constant: Module).void }
+  def compile_module(tree, name, constant); end
+
+  sig { params(tree: Tapioca::RBI::Tree, constant: Module).void }
+  def compile_module_helpers(tree, constant); end
+
+  sig { params(tree: Tapioca::RBI::Tree, name: String, value: BasicObject).void }
+  def compile_object(tree, name, value); end
+
+  sig { params(tree: Tapioca::RBI::Tree, constant: Module).void }
+  def compile_props(tree, constant); end
+
+  sig { params(signature: T.untyped, parameters: T::Array[[Symbol, String]]).returns(Tapioca::RBI::Sig) }
+  def compile_signature(signature, parameters); end
+
+  sig { params(tree: Tapioca::RBI::Tree, name: String, constant: Module).void }
+  def compile_subconstants(tree, name, constant); end
+
+  sig { params(constant: Class).returns(T.nilable(String)) }
+  def compile_superclass(constant); end
+
+  sig { params(tree: Tapioca::RBI::Tree, constant: Module).void }
+  def compile_type_variable_declarations(tree, constant); end
+
+  sig { params(tree: Tapioca::RBI::Tree, constant: Module).void }
+  def compile_type_variables(tree, constant); end
+
+  sig { params(constant: Module).returns(T::Array[Symbol]) }
+  def constants_of(constant); end
+
+  sig { params(constant: Module, strict: T::Boolean).returns(T::Boolean) }
+  def defined_in_gem?(constant, strict: T.unsafe(nil)); end
+
+  sig { params(symbols: T::Set[String]).returns(T::Set[String]) }
+  def engine_symbols(symbols); end
+
+  sig { params(tree: Tapioca::RBI::Tree, symbol: String).void }
+  def generate_from_symbol(tree, symbol); end
+
+  sig { params(constant: Module).returns(T::Array[String]) }
+  def get_file_candidates(constant); end
+
+  sig { params(constant: Module).returns(T::Array[Module]) }
+  def inherited_ancestors_of(constant); end
+
+  def initialize_method_for(constant); end
+
+  sig { params(constant: Module).returns(T::Array[Module]) }
+  def interesting_ancestors_of(constant); end
+
+  sig { params(name: String).void }
+  def mark_seen(name); end
+
+  sig { params(method: UnboundMethod).returns(T::Boolean) }
+  def method_in_gem?(method); end
+
+  sig { params(mod: Module).returns(T::Hash[Symbol, T::Array[Symbol]]) }
+  def method_names_by_visibility(mod); end
+
+  sig { params(constant: Module).returns(T.nilable(String)) }
+  def name_of(constant); end
+
+  sig { params(constant: Module).returns(T.nilable(String)) }
+  def name_of_proxy_target(constant); end
+
+  sig { params(object: BasicObject).returns(Integer) }
+  def object_id_of(object); end
+
+  sig { params(constant: Module).returns(T.nilable(String)) }
+  def qualified_name_of(constant); end
+
+  sig { params(constant: Module).returns(T.nilable(String)) }
+  def raw_name_of(constant); end
+
+  sig { params(symbol: String, inherit: T::Boolean, namespace: Module).returns(BasicObject) }
+  def resolve_constant(symbol, inherit: T.unsafe(nil), namespace: T.unsafe(nil)); end
+
+  sig { params(sig_string: String).returns(String) }
+  def sanitize_signature_types(sig_string); end
+
+  sig { params(name: String).returns(T::Boolean) }
+  def seen?(name); end
+
+  sig { params(method: T.any(Method, UnboundMethod)).returns(T.untyped) }
+  def signature_of(method); end
+
+  sig { params(constant: Module).returns(Class) }
+  def singleton_class_of(constant); end
+
+  sig { params(constant: Module, method_name: String).returns(T::Boolean) }
+  def struct_method?(constant, method_name); end
+
+  sig { params(constant: Class).returns(T.nilable(Class)) }
+  def superclass_of(constant); end
+
+  sig { params(symbol_name: String).returns(T::Boolean) }
+  def symbol_ignored?(symbol_name); end
+
+  sig { returns(T::Set[String]) }
+  def symbols; end
+
+  sig { params(constant: T::Types::Base).returns(String) }
+  def type_of(constant); end
+
+  sig { params(name: String).returns(T::Boolean) }
+  def valid_method_name?(name); end
+end
+
+Tapioca::Compilers::SymbolTable::SymbolGenerator::IGNORED_SYMBOLS = T.let(T.unsafe(nil), Array)
+Tapioca::Compilers::SymbolTable::SymbolGenerator::SPECIAL_METHOD_NAMES = T.let(T.unsafe(nil), Array)
+Tapioca::Compilers::SymbolTable::SymbolGenerator::TYPE_PARAMETER_MATCHER = T.let(T.unsafe(nil), Regexp)
+
+module Tapioca::Compilers::SymbolTable::SymbolLoader
+  class << self
+    def ignore_symbol?(symbol); end
+
+    sig { params(paths: T::Array[Pathname]).returns(T::Set[String]) }
+    def list_from_paths(paths); end
+
+    private
+
+    def ignored_symbols; end
+
+    sig { params(paths: T::Array[String]).returns(T::Set[String]) }
+    def load_symbols(paths); end
+
+    def symbol_table_json_from(input, table_type: T.unsafe(nil)); end
+  end
+end
+
+class Tapioca::Compilers::SymbolTable::SymbolLoader::SymbolTableParser
+  class << self
+    def parse(object, parents = T.unsafe(nil)); end
+  end
+end
+
+class Tapioca::Compilers::SymbolTableCompiler
+  sig { params(gem: Tapioca::Gemfile::Gem, indent: Integer).returns(String) }
+  def compile(gem, indent = T.unsafe(nil)); end
+end
+
+class Tapioca::Compilers::TodosCompiler
+  sig { returns(String) }
+  def compile; end
+
+  private
+
+  sig { returns(String) }
+  def list_todos; end
+end
+
+class Tapioca::Config < ::T::Struct
+  const :exclude, T::Array[String]
+  const :generators, T::Array[String]
+  const :outdir, String
+  const :postrequire, String
+  const :prerequire, T.nilable(String)
+  const :todos_path, String
+  const :typed_overrides, T::Hash[String, String]
+
+  sig { returns(Pathname) }
+  def outpath; end
+
+  class << self
+    def inherited(s); end
+  end
+end
+
+Tapioca::Config::DEFAULT_COMMAND = T.let(T.unsafe(nil), String)
+Tapioca::Config::DEFAULT_DSLDIR = T.let(T.unsafe(nil), String)
+Tapioca::Config::DEFAULT_GEMDIR = T.let(T.unsafe(nil), String)
+Tapioca::Config::DEFAULT_OVERRIDES = T.let(T.unsafe(nil), Hash)
+Tapioca::Config::DEFAULT_POSTREQUIRE = T.let(T.unsafe(nil), String)
+Tapioca::Config::DEFAULT_RBIDIR = T.let(T.unsafe(nil), String)
+Tapioca::Config::DEFAULT_TODOSPATH = T.let(T.unsafe(nil), String)
+Tapioca::Config::SORBET_CONFIG = T.let(T.unsafe(nil), String)
+Tapioca::Config::SORBET_PATH = T.let(T.unsafe(nil), String)
+Tapioca::Config::TAPIOCA_CONFIG = T.let(T.unsafe(nil), String)
+Tapioca::Config::TAPIOCA_PATH = T.let(T.unsafe(nil), String)
+
+class Tapioca::ConfigBuilder
+  class << self
+    sig { params(command: Symbol, options: T::Hash[String, T.untyped]).returns(Tapioca::Config) }
+    def from_options(command, options); end
+
+    private
+
+    sig { returns(T::Hash[String, T.untyped]) }
+    def config_options; end
+
+    sig { params(command: Symbol).returns(T::Hash[String, T.untyped]) }
+    def default_options(command); end
+
+    sig { params(options: T::Hash[String, T.untyped]).returns(T::Hash[String, T.untyped]) }
+    def merge_options(*options); end
+  end
+end
+
+Tapioca::ConfigBuilder::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+
+module Tapioca::ConstantLocator
+  private
+
+  def files_for(klass); end
+
+  class << self
+    def files_for(klass); end
+  end
+end
+
+Tapioca::ConstantLocator::NAME = T.let(T.unsafe(nil), UnboundMethod)
+class Tapioca::Error < ::StandardError; end
+
+class Tapioca::Gemfile
+  sig { void }
+  def initialize; end
+
+  sig { returns(Bundler::Definition) }
+  def definition; end
+
+  sig { returns(T::Array[Tapioca::Gemfile::Gem]) }
+  def dependencies; end
+
+  sig { params(gem_name: String).returns(T.nilable(Tapioca::Gemfile::Gem)) }
+  def gem(gem_name); end
+
+  sig { returns(T::Array[String]) }
+  def missing_specs; end
+
+  sig { void }
+  def require; end
+
+  private
+
+  sig { returns(String) }
+  def dir; end
+
+  sig { returns(File) }
+  def gemfile; end
+
+  sig { returns(T::Array[Symbol]) }
+  def groups; end
+
+  sig { returns([T::Array[Tapioca::Gemfile::Gem], T::Array[String]]) }
+  def load_dependencies; end
+
+  def lockfile; end
+
+  sig { returns(Bundler::Runtime) }
+  def runtime; end
+end
+
+class Tapioca::Gemfile::Gem
+  sig { params(spec: T.any(Gem::Specification, T.all(Bundler::RemoteSpecification, Bundler::StubSpecification))).void }
+  def initialize(spec); end
+
+  sig { params(path: String).returns(T::Boolean) }
+  def contains_path?(path); end
+
+  sig { returns(T::Array[Pathname]) }
+  def files; end
+
+  sig { returns(String) }
+  def full_gem_path; end
+
+  sig { params(gemfile_dir: String).returns(T::Boolean) }
+  def ignore?(gemfile_dir); end
+
+  sig { returns(String) }
+  def name; end
+
+  sig { returns(String) }
+  def rbi_file_name; end
+
+  def version; end
+
+  private
+
+  sig { returns(T::Boolean) }
+  def gem_ignored?; end
+
+  sig { params(gemfile_dir: String).returns(T::Boolean) }
+  def gem_in_app_dir?(gemfile_dir); end
+
+  sig { returns(T::Boolean) }
+  def gem_in_bundle_path?; end
+
+  sig { params(path: String).returns(T::Boolean) }
+  def has_parent_gemspec?(path); end
+
+  sig { params(path: T.any(Pathname, String)).returns(String) }
+  def to_realpath(path); end
+
+  sig { returns(String) }
+  def version_string; end
+end
+
+Tapioca::Gemfile::Gem::IGNORED_GEMS = T.let(T.unsafe(nil), Array)
+Tapioca::Gemfile::Spec = T.type_alias { T.any(Gem::Specification, T.all(Bundler::RemoteSpecification, Bundler::StubSpecification)) }
+
+class Tapioca::Generator < ::Thor::Shell::Color
+  sig { params(config: Tapioca::Config).void }
+  def initialize(config); end
+
+  sig { params(requested_constants: T::Array[String], should_verify: T::Boolean, quiet: T::Boolean).void }
+  def build_dsl(requested_constants, should_verify: T.unsafe(nil), quiet: T.unsafe(nil)); end
+
+  sig { params(gem_names: T::Array[String]).void }
+  def build_gem_rbis(gem_names); end
+
+  sig { void }
+  def build_requires; end
+
+  sig { void }
+  def build_todos; end
+
+  sig { returns(Tapioca::Config) }
+  def config; end
+
+  sig { void }
+  def sync_rbis_with_gemfile; end
+
+  private
+
+  sig { params(filename: Pathname).void }
+  def add(filename); end
+
+  sig { returns(T::Array[String]) }
+  def added_rbis; end
+
+  sig { params(cause: Symbol, files: T::Array[String]).returns(String) }
+  def build_error_for_files(cause, files); end
+
+  sig { returns(Tapioca::Gemfile) }
+  def bundle; end
+
+  sig { params(constant_name: String, contents: String, outpath: Pathname, quiet: T::Boolean).returns(T.nilable(Pathname)) }
+  def compile_dsl_rbi(constant_name, contents, outpath: T.unsafe(nil), quiet: T.unsafe(nil)); end
+
+  sig { params(gem: Tapioca::Gemfile::Gem).void }
+  def compile_gem_rbi(gem); end
+
+  sig { returns(Tapioca::Compilers::SymbolTableCompiler) }
+  def compiler; end
+
+  sig { params(constant_names: T::Array[String]).returns(T::Array[Module]) }
+  def constantize(constant_names); end
+
+  sig { params(constant_name: String).returns(Pathname) }
+  def dsl_rbi_filename(constant_name); end
+
+  sig { params(gem_name: String).returns(Pathname) }
+  def existing_rbi(gem_name); end
+
+  sig { params(requested_constants: T::Array[String], path: Pathname).returns(T::Set[Pathname]) }
+  def existing_rbi_filenames(requested_constants, path: T.unsafe(nil)); end
+
+  sig { returns(T::Hash[String, String]) }
+  def existing_rbis; end
+
+  sig { params(gem_name: String).returns(Pathname) }
+  def expected_rbi(gem_name); end
+
+  sig { returns(T::Hash[String, String]) }
+  def expected_rbis; end
+
+  sig { params(file: String, error: LoadError).void }
+  def explain_failed_require(file, error); end
+
+  sig { params(gem_name: String).returns(T::Boolean) }
+  def gem_rbi_exists?(gem_name); end
+
+  sig { params(gem_name: String, version: String).returns(Pathname) }
+  def gem_rbi_filename(gem_name, version); end
+
+  sig { params(gem_names: T::Array[String]).returns(T::Array[Tapioca::Gemfile::Gem]) }
+  def gems_to_generate(gem_names); end
+
+  sig { params(eager_load: T::Boolean).void }
+  def load_application(eager_load:); end
+
+  sig { void }
+  def load_dsl_generators; end
+
+  sig { returns(Tapioca::Loader) }
+  def loader; end
+
+  sig { params(old_filename: Pathname, new_filename: Pathname).void }
+  def move(old_filename, new_filename); end
+
+  sig { void }
+  def perform_additions; end
+
+  sig { params(dir: Pathname).void }
+  def perform_dsl_verification(dir); end
+
+  sig { void }
+  def perform_removals; end
+
+  sig { params(files: T::Set[Pathname]).void }
+  def purge_stale_dsl_rbi_files(files); end
+
+  sig { params(path: Pathname).returns(T::Array[Pathname]) }
+  def rbi_files_in(path); end
+
+  sig { params(command: String, reason: T.nilable(String), strictness: T.nilable(String)).returns(String) }
+  def rbi_header(command, reason: T.unsafe(nil), strictness: T.unsafe(nil)); end
+
+  sig { params(filename: Pathname).void }
+  def remove(filename); end
+
+  sig { returns(T::Array[String]) }
+  def removed_rbis; end
+
+  sig { void }
+  def require_gem_file; end
+
+  sig { params(message: String, color: T.any(Symbol, T::Array[Symbol])).void }
+  def say_error(message = T.unsafe(nil), *color); end
+
+  sig { params(tmp_dir: Pathname).returns(T::Hash[String, Symbol]) }
+  def verify_dsl_rbi(tmp_dir:); end
+end
+
+Tapioca::Generator::EMPTY_RBI_COMMENT = T.let(T.unsafe(nil), String)
+
+module Tapioca::GenericTypeRegistry
+  class << self
+    sig { params(constant: Module).returns(T.nilable(T::Hash[Integer, String])) }
+    def lookup_type_variables(constant); end
+
+    sig { params(constant: T.untyped, types: T.untyped).returns(Module) }
+    def register_type(constant, types); end
+
+    sig { params(constant: T.untyped, type_member: T::Types::TypeVariable, fixed: T.untyped, lower: T.untyped, upper: T.untyped).void }
+    def register_type_member(constant, type_member, fixed, lower, upper); end
+
+    sig { params(constant: T.untyped, type_template: T::Types::TypeVariable, fixed: T.untyped, lower: T.untyped, upper: T.untyped).void }
+    def register_type_template(constant, type_template, fixed, lower, upper); end
+
+    private
+
+    sig { params(constant: Module, name: String).returns(Module) }
+    def create_generic_type(constant, name); end
+
+    sig { params(constant: Class).returns(Class) }
+    def create_safe_subclass(constant); end
+
+    sig { params(constant: Module).returns(T::Hash[Integer, String]) }
+    def lookup_or_initialize_type_variables(constant); end
+
+    sig { params(constant: Module).returns(T.nilable(String)) }
+    def name_of(constant); end
+
+    sig { params(object: BasicObject).returns(Integer) }
+    def object_id_of(object); end
+
+    sig { params(constant: T.untyped, type_variable_type: T.enum([:type_member, :type_template]), type_variable: T::Types::TypeVariable, fixed: T.untyped, lower: T.untyped, upper: T.untyped).void }
+    def register_type_variable(constant, type_variable_type, type_variable, fixed, lower, upper); end
+
+    sig { params(type_variable_type: Symbol, variance: Symbol, fixed: T.untyped, lower: T.untyped, upper: T.untyped).returns(String) }
+    def serialize_type_variable(type_variable_type, variance, fixed, lower, upper); end
+  end
+end
+
+class Tapioca::Loader
+  sig { params(gemfile: Tapioca::Gemfile).void }
+  def initialize(gemfile); end
+
+  sig { params(initialize_file: T.nilable(String), require_file: T.nilable(String)).void }
+  def load_bundle(initialize_file, require_file); end
+
+  sig { params(environment_load: T::Boolean, eager_load: T::Boolean).void }
+  def load_rails(environment_load: T.unsafe(nil), eager_load: T.unsafe(nil)); end
+
+  private
+
+  sig { void }
+  def eager_load_rails_app; end
+
+  sig { returns(Tapioca::Gemfile) }
+  def gemfile; end
+
+  sig { void }
+  def load_rails_engines; end
+
+  sig { void }
+  def load_rake; end
+
+  sig { returns(T::Array[T.untyped]) }
+  def rails_engines; end
+
+  sig { void }
+  def require_bundle; end
+
+  sig { params(file: T.nilable(String)).void }
+  def require_helper(file); end
+
+  sig { params(path: String).void }
+  def safe_require(path); end
+
+  sig { void }
+  def silence_deprecations; end
+end
+
+module Tapioca::RBI; end
+
+class Tapioca::RBI::BlockParam < ::Tapioca::RBI::Param
+  sig { override.params(v: Tapioca::RBI::Printer).void }
+  def accept_printer(v); end
+end
+
+class Tapioca::RBI::Class < ::Tapioca::RBI::Scope
+  sig { params(name: String, superclass_name: T.nilable(String)).void }
+  def initialize(name, superclass_name: T.unsafe(nil)); end
+
+  sig { returns(String) }
+  def name; end
+
+  def name=(_arg0); end
+
+  sig { returns(T.nilable(String)) }
+  def superclass_name; end
+
+  def superclass_name=(_arg0); end
+end
+
+class Tapioca::RBI::Const < ::Tapioca::RBI::Node
+  sig { params(name: String, value: String).void }
+  def initialize(name, value); end
+
+  sig { override.params(v: Tapioca::RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(String) }
+  def name; end
+
+  def value; end
+end
+
+class Tapioca::RBI::Extend < ::Tapioca::RBI::Mixin; end
+
+class Tapioca::RBI::Group < ::Tapioca::RBI::Tree
+  sig { params(kind: Tapioca::RBI::Group::Kind).void }
+  def initialize(kind); end
+
+  sig { override.params(v: Tapioca::RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(Tapioca::RBI::Group::Kind) }
+  def kind; end
+end
+
+class Tapioca::RBI::Group::Kind < ::T::Enum
+  enums do
+    Mixins = new
+    Helpers = new
+    TypeMembers = new
+    MixesInClassMethods = new
+    TStructFields = new
+    TEnums = new
+    Inits = new
+    Methods = new
+    Consts = new
+  end
+end
+
+class Tapioca::RBI::Helper < ::Tapioca::RBI::Node
+  sig { params(name: String).void }
+  def initialize(name); end
+
+  sig { override.params(v: Tapioca::RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(String) }
+  def name; end
+end
+
+class Tapioca::RBI::Include < ::Tapioca::RBI::Mixin; end
+
+class Tapioca::RBI::KwOptParam < ::Tapioca::RBI::OptParam
+  sig { override.params(v: Tapioca::RBI::Printer).void }
+  def accept_printer(v); end
+end
+
+class Tapioca::RBI::KwParam < ::Tapioca::RBI::Param
+  sig { override.params(v: Tapioca::RBI::Printer).void }
+  def accept_printer(v); end
+end
+
+class Tapioca::RBI::KwRestParam < ::Tapioca::RBI::Param
+  sig { override.params(v: Tapioca::RBI::Printer).void }
+  def accept_printer(v); end
+end
+
+class Tapioca::RBI::Method < ::Tapioca::RBI::Node
+  sig { params(name: String, params: T::Array[Tapioca::RBI::Param], is_singleton: T::Boolean, visibility: Tapioca::RBI::Visibility, sigs: T::Array[Tapioca::RBI::Sig]).void }
+  def initialize(name, params: T.unsafe(nil), is_singleton: T.unsafe(nil), visibility: T.unsafe(nil), sigs: T.unsafe(nil)); end
+
+  sig { params(param: Tapioca::RBI::Param).void }
+  def <<(param); end
+
+  sig { override.params(v: Tapioca::RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(T::Boolean) }
+  def is_singleton; end
+
+  def is_singleton=(_arg0); end
+
+  sig { returns(String) }
+  def name; end
+
+  def name=(_arg0); end
+
+  sig { override.returns(T::Boolean) }
+  def oneline?; end
+
+  sig { returns(T::Array[Tapioca::RBI::Param]) }
+  def params; end
+
+  sig { returns(T::Array[Tapioca::RBI::Sig]) }
+  def sigs; end
+
+  def sigs=(_arg0); end
+
+  sig { returns(Tapioca::RBI::Visibility) }
+  def visibility; end
+
+  def visibility=(_arg0); end
+end
+
+class Tapioca::RBI::MixesInClassMethods < ::Tapioca::RBI::Mixin; end
+
+class Tapioca::RBI::Mixin < ::Tapioca::RBI::Node
+  abstract!
+
+  sig { params(name: String).void }
+  def initialize(name); end
+
+  sig { override.params(v: Tapioca::RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(String) }
+  def name; end
+end
+
+class Tapioca::RBI::Module < ::Tapioca::RBI::Scope
+  sig { params(name: String).void }
+  def initialize(name); end
+
+  sig { returns(String) }
+  def name; end
+
+  def name=(_arg0); end
+end
+
+class Tapioca::RBI::Node
+  abstract!
+
+  sig { void }
+  def initialize; end
+
+  sig { abstract.params(v: Tapioca::RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { void }
+  def detach; end
+
+  sig { returns(Tapioca::RBI::Group::Kind) }
+  def group_kind; end
+
+  sig { returns(T::Boolean) }
+  def oneline?; end
+
+  sig { returns(T.nilable(Tapioca::RBI::Tree)) }
+  def parent_tree; end
+
+  def parent_tree=(_arg0); end
+
+  sig { params(out: T.any(IO, StringIO), indent: Integer).void }
+  def print(out: T.unsafe(nil), indent: T.unsafe(nil)); end
+
+  sig { params(indent: Integer).returns(String) }
+  def string(indent: T.unsafe(nil)); end
+end
+
+class Tapioca::RBI::OptParam < ::Tapioca::RBI::Param
+  sig { params(name: String, value: String).void }
+  def initialize(name, value); end
+
+  sig { override.params(v: Tapioca::RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(String) }
+  def value; end
+end
+
+class Tapioca::RBI::Param < ::Tapioca::RBI::Node
+  sig { params(name: String).void }
+  def initialize(name); end
+
+  sig { override.params(v: Tapioca::RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(String) }
+  def name; end
+end
+
+class Tapioca::RBI::Printer < ::Tapioca::RBI::Visitor
+  sig { params(out: T.any(IO, StringIO), indent: Integer).void }
+  def initialize(out: T.unsafe(nil), indent: T.unsafe(nil)); end
+
+  sig { void }
+  def dedent; end
+
+  sig { returns(T::Boolean) }
+  def in_visibility_group; end
+
+  def in_visibility_group=(_arg0); end
+
+  sig { void }
+  def indent; end
+
+  sig { returns(T.nilable(Tapioca::RBI::Node)) }
+  def previous_node; end
+
+  sig { params(string: String).void }
+  def print(string); end
+
+  sig { params(string: String).void }
+  def printl(string); end
+
+  sig { params(string: T.nilable(String)).void }
+  def printn(string = T.unsafe(nil)); end
+
+  sig { params(string: T.nilable(String)).void }
+  def printt(string = T.unsafe(nil)); end
+
+  sig { override.params(node: T.nilable(Tapioca::RBI::Node)).void }
+  def visit(node); end
+
+  sig { override.params(nodes: T::Array[Tapioca::RBI::Node]).void }
+  def visit_all(nodes); end
+end
+
+class Tapioca::RBI::RestParam < ::Tapioca::RBI::Param
+  sig { override.params(v: Tapioca::RBI::Printer).void }
+  def accept_printer(v); end
+end
+
+module Tapioca::RBI::Rewriters; end
+
+class Tapioca::RBI::Rewriters::GroupNodes < ::Tapioca::RBI::Visitor
+  sig { override.params(node: T.nilable(Tapioca::RBI::Node)).void }
+  def visit(node); end
+end
+
+class Tapioca::RBI::Rewriters::NestNonPublicMethods < ::Tapioca::RBI::Visitor
+  sig { override.params(node: T.nilable(Tapioca::RBI::Node)).void }
+  def visit(node); end
+end
+
+class Tapioca::RBI::Rewriters::NestSingletonMethods < ::Tapioca::RBI::Visitor
+  sig { override.params(node: T.nilable(Tapioca::RBI::Node)).void }
+  def visit(node); end
+end
+
+class Tapioca::RBI::Rewriters::SortNodes < ::Tapioca::RBI::Visitor
+  sig { override.params(node: T.nilable(Tapioca::RBI::Node)).void }
+  def visit(node); end
+
+  private
+
+  sig { params(kind: Tapioca::RBI::Group::Kind).returns(Integer) }
+  def kind_rank(kind); end
+
+  sig { params(node: Tapioca::RBI::Node).returns(T.nilable(String)) }
+  def node_name(node); end
+
+  sig { params(node: Tapioca::RBI::Node).returns(Integer) }
+  def node_rank(node); end
+end
+
+class Tapioca::RBI::Scope < ::Tapioca::RBI::Tree
+  abstract!
+
+  def initialize(*args, &blk); end
+
+  sig { override.params(v: Tapioca::RBI::Printer).void }
+  def accept_printer(v); end
+end
+
+class Tapioca::RBI::Sig < ::Tapioca::RBI::Node
+  sig { params(params: T::Array[Tapioca::RBI::SigParam], return_type: T.nilable(String), is_abstract: T::Boolean, is_override: T::Boolean, is_overridable: T::Boolean, type_params: T::Array[String]).void }
+  def initialize(params: T.unsafe(nil), return_type: T.unsafe(nil), is_abstract: T.unsafe(nil), is_override: T.unsafe(nil), is_overridable: T.unsafe(nil), type_params: T.unsafe(nil)); end
+
+  sig { params(param: Tapioca::RBI::SigParam).void }
+  def <<(param); end
+
+  sig { override.params(v: Tapioca::RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(T::Boolean) }
+  def is_abstract; end
+
+  def is_abstract=(_arg0); end
+  def is_overridable; end
+  def is_overridable=(_arg0); end
+  def is_override; end
+  def is_override=(_arg0); end
+
+  sig { returns(T::Array[Tapioca::RBI::SigParam]) }
+  def params; end
+
+  sig { returns(T.nilable(String)) }
+  def return_type; end
+
+  def return_type=(_arg0); end
+
+  sig { returns(T::Array[String]) }
+  def type_params; end
+end
+
+class Tapioca::RBI::SigParam < ::Tapioca::RBI::Node
+  sig { params(name: String, type: String).void }
+  def initialize(name, type); end
+
+  sig { override.params(v: Tapioca::RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(String) }
+  def name; end
+
+  def type; end
+end
+
+class Tapioca::RBI::SingletonClass < ::Tapioca::RBI::Scope
+  sig { void }
+  def initialize; end
+end
+
+class Tapioca::RBI::TEnum < ::Tapioca::RBI::Class
+  sig { params(name: String).void }
+  def initialize(name); end
+end
+
+class Tapioca::RBI::TEnumBlock < ::Tapioca::RBI::Node
+  sig { params(names: T::Array[String]).void }
+  def initialize(names = T.unsafe(nil)); end
+
+  sig { override.params(v: Tapioca::RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(T::Boolean) }
+  def empty?; end
+
+  sig { returns(T::Array[String]) }
+  def names; end
+end
+
+class Tapioca::RBI::TStruct < ::Tapioca::RBI::Class
+  sig { params(name: String).void }
+  def initialize(name); end
+end
+
+class Tapioca::RBI::TStructConst < ::Tapioca::RBI::TStructField; end
+
+class Tapioca::RBI::TStructField < ::Tapioca::RBI::Node
+  abstract!
+
+  sig { params(name: String, type: String, default: T.nilable(String)).void }
+  def initialize(name, type, default: T.unsafe(nil)); end
+
+  sig { override.params(v: Tapioca::RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(T.nilable(String)) }
+  def default; end
+
+  def default=(_arg0); end
+
+  sig { returns(String) }
+  def name; end
+
+  def name=(_arg0); end
+  def type; end
+  def type=(_arg0); end
+end
+
+class Tapioca::RBI::TStructProp < ::Tapioca::RBI::TStructField; end
+
+class Tapioca::RBI::Tree < ::Tapioca::RBI::Node
+  sig { void }
+  def initialize; end
+
+  sig { params(node: Tapioca::RBI::Node).void }
+  def <<(node); end
+
+  sig { override.params(v: Tapioca::RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(T::Boolean) }
+  def empty?; end
+
+  sig { void }
+  def group_nodes!; end
+
+  sig { void }
+  def nest_non_public_methods!; end
+
+  sig { void }
+  def nest_singleton_methods!; end
+
+  sig { returns(T::Array[Tapioca::RBI::Node]) }
+  def nodes; end
+
+  sig { override.returns(T::Boolean) }
+  def oneline?; end
+
+  sig { void }
+  def sort_nodes!; end
+end
+
+class Tapioca::RBI::TypeMember < ::Tapioca::RBI::Node
+  sig { params(name: String, value: String).void }
+  def initialize(name, value); end
+
+  sig { override.params(v: Tapioca::RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(String) }
+  def name; end
+
+  def value; end
+end
+
+class Tapioca::RBI::Visibility < ::Tapioca::RBI::Node
+  abstract!
+
+  sig { params(visibility: Symbol).void }
+  def initialize(visibility); end
+
+  sig { override.params(v: Tapioca::RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(T::Boolean) }
+  def public?; end
+
+  sig { returns(Symbol) }
+  def visibility; end
+end
+
+Tapioca::RBI::Visibility::Private = T.let(T.unsafe(nil), Tapioca::RBI::Visibility)
+Tapioca::RBI::Visibility::Protected = T.let(T.unsafe(nil), Tapioca::RBI::Visibility)
+Tapioca::RBI::Visibility::Public = T.let(T.unsafe(nil), Tapioca::RBI::Visibility)
+
+class Tapioca::RBI::VisibilityGroup < ::Tapioca::RBI::Tree
+  sig { params(visibility: Tapioca::RBI::Visibility).void }
+  def initialize(visibility); end
+
+  sig { override.params(v: Tapioca::RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(Tapioca::RBI::Visibility) }
+  def visibility; end
+end
+
+class Tapioca::RBI::Visitor
+  abstract!
+
+  def initialize(*args, &blk); end
+
+  sig { abstract.params(node: T.nilable(Tapioca::RBI::Node)).void }
+  def visit(node); end
+
+  sig { params(nodes: T::Array[Tapioca::RBI::Node]).void }
+  def visit_all(nodes); end
+end
+
+Tapioca::VERSION = T.let(T.unsafe(nil), String)
diff --git a/Library/Homebrew/vendor/bundle/bundler/setup.rb b/Library/Homebrew/vendor/bundle/bundler/setup.rb
index 44b4c6bfee8c2..44c22fb54e9cc 100644
--- a/Library/Homebrew/vendor/bundle/bundler/setup.rb
+++ b/Library/Homebrew/vendor/bundle/bundler/setup.rb
@@ -92,5 +92,5 @@
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/sorbet-runtime-stub-0.2.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/thor-1.1.0/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/spoom-1.0.9/lib"
-$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/tapioca-0.4.21/lib"
+$:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/tapioca-0.4.22/lib"
 $:.unshift "#{path}/../#{ruby_engine}/#{ruby_version}/gems/warning-1.2.0/lib"