From ca69b3816e028c1eda3eaa862c3334f60ff067d6 Mon Sep 17 00:00:00 2001
From: Andy Waite <13400+andyw8@users.noreply.github.com>
Date: Tue, 7 Jan 2025 10:22:20 -0500
Subject: [PATCH 1/8] Use Ruby 3.4

---
 .github/workflows/ci.yml | 2 +-
 .ruby-version            | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 8b6e308d..a75954fa 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -12,7 +12,7 @@ jobs:
         gemfile:
           - Gemfile
           - gemfiles/Gemfile-rails-main
-        ruby: ["3.2", "3.3"]
+        ruby: ["3.3", "3.4"]
         include:
           - gemfile: "gemfiles/Gemfile-rails-main"
             experimental: true
diff --git a/.ruby-version b/.ruby-version
index a0891f56..47b322c9 100644
--- a/.ruby-version
+++ b/.ruby-version
@@ -1 +1 @@
-3.3.4
+3.4.1

From 8baa8877149b6b71d96e921165a7812833a2bc5b Mon Sep 17 00:00:00 2001
From: Andy Waite <13400+andyw8@users.noreply.github.com>
Date: Tue, 7 Jan 2025 10:26:01 -0500
Subject: [PATCH 2/8] $ bundle lock --normalize-platforms

---
 Gemfile.lock | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/Gemfile.lock b/Gemfile.lock
index 30905b2f..eab1308f 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -127,6 +127,8 @@ GEM
       net-protocol
     netrc (0.11.0)
     nio4r (2.7.4)
+    nokogiri (1.16.7-aarch64-linux)
+      racc (~> 1.4)
     nokogiri (1.16.7-arm64-darwin)
       racc (~> 1.4)
     nokogiri (1.16.7-x64-mingw-ucrt)
@@ -235,10 +237,13 @@ GEM
       prism (>= 0.28.0)
       sorbet-static-and-runtime (>= 0.5.10187)
       thor (>= 0.19.2)
+    sqlite3 (2.1.0-aarch64-linux-gnu)
+    sqlite3 (2.1.0-aarch64-linux-musl)
     sqlite3 (2.1.0-arm64-darwin)
     sqlite3 (2.1.0-x64-mingw-ucrt)
     sqlite3 (2.1.0-x86_64-darwin)
     sqlite3 (2.1.0-x86_64-linux-gnu)
+    sqlite3 (2.1.0-x86_64-linux-musl)
     stringio (3.1.2)
     tapioca (0.16.8)
       benchmark
@@ -254,8 +259,6 @@ GEM
     timeout (0.4.2)
     tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
-    tzinfo-data (1.2024.2)
-      tzinfo (>= 1.0.0)
     unicode-display_width (2.6.0)
     uri (1.0.1)
     useragent (0.16.10)
@@ -269,10 +272,16 @@ GEM
     zeitwerk (2.7.1)
 
 PLATFORMS
+  aarch64-linux
+  aarch64-linux-gnu
+  aarch64-linux-musl
   arm64-darwin
+  universal-darwin
   x64-mingw-ucrt
   x86_64-darwin
   x86_64-linux
+  x86_64-linux-gnu
+  x86_64-linux-musl
 
 DEPENDENCIES
   debug (>= 1.7.0)

From 39dcc934ed5395807631d77794dbedceae7350dd Mon Sep 17 00:00:00 2001
From: Andy Waite <13400+andyw8@users.noreply.github.com>
Date: Tue, 7 Jan 2025 10:26:50 -0500
Subject: [PATCH 3/8] Update Nokogiri

---
 Gemfile.lock | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/Gemfile.lock b/Gemfile.lock
index eab1308f..c6997202 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -127,15 +127,17 @@ GEM
       net-protocol
     netrc (0.11.0)
     nio4r (2.7.4)
-    nokogiri (1.16.7-aarch64-linux)
+    nokogiri (1.18.1-aarch64-linux-gnu)
       racc (~> 1.4)
-    nokogiri (1.16.7-arm64-darwin)
+    nokogiri (1.18.1-aarch64-linux-musl)
       racc (~> 1.4)
-    nokogiri (1.16.7-x64-mingw-ucrt)
+    nokogiri (1.18.1-arm64-darwin)
       racc (~> 1.4)
-    nokogiri (1.16.7-x86_64-darwin)
+    nokogiri (1.18.1-x86_64-darwin)
       racc (~> 1.4)
-    nokogiri (1.16.7-x86_64-linux)
+    nokogiri (1.18.1-x86_64-linux-gnu)
+      racc (~> 1.4)
+    nokogiri (1.18.1-x86_64-linux-musl)
       racc (~> 1.4)
     parallel (1.26.3)
     parser (3.3.6.0)
@@ -240,7 +242,6 @@ GEM
     sqlite3 (2.1.0-aarch64-linux-gnu)
     sqlite3 (2.1.0-aarch64-linux-musl)
     sqlite3 (2.1.0-arm64-darwin)
-    sqlite3 (2.1.0-x64-mingw-ucrt)
     sqlite3 (2.1.0-x86_64-darwin)
     sqlite3 (2.1.0-x86_64-linux-gnu)
     sqlite3 (2.1.0-x86_64-linux-musl)
@@ -277,7 +278,6 @@ PLATFORMS
   aarch64-linux-musl
   arm64-darwin
   universal-darwin
-  x64-mingw-ucrt
   x86_64-darwin
   x86_64-linux
   x86_64-linux-gnu

From 0b581be432197cc8d70139084780bb9beb6e6378 Mon Sep 17 00:00:00 2001
From: Andy Waite <13400+andyw8@users.noreply.github.com>
Date: Tue, 7 Jan 2025 13:40:21 -0500
Subject: [PATCH 4/8] Update sqlite3

---
 Gemfile.lock | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/Gemfile.lock b/Gemfile.lock
index c6997202..453f00a1 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -239,12 +239,12 @@ GEM
       prism (>= 0.28.0)
       sorbet-static-and-runtime (>= 0.5.10187)
       thor (>= 0.19.2)
-    sqlite3 (2.1.0-aarch64-linux-gnu)
-    sqlite3 (2.1.0-aarch64-linux-musl)
-    sqlite3 (2.1.0-arm64-darwin)
-    sqlite3 (2.1.0-x86_64-darwin)
-    sqlite3 (2.1.0-x86_64-linux-gnu)
-    sqlite3 (2.1.0-x86_64-linux-musl)
+    sqlite3 (2.5.0-aarch64-linux-gnu)
+    sqlite3 (2.5.0-aarch64-linux-musl)
+    sqlite3 (2.5.0-arm64-darwin)
+    sqlite3 (2.5.0-x86_64-darwin)
+    sqlite3 (2.5.0-x86_64-linux-gnu)
+    sqlite3 (2.5.0-x86_64-linux-musl)
     stringio (3.1.2)
     tapioca (0.16.8)
       benchmark

From 543a0c996c84a09c0b330047dee97685f3edb0a0 Mon Sep 17 00:00:00 2001
From: Andy Waite <13400+andyw8@users.noreply.github.com>
Date: Tue, 7 Jan 2025 13:41:25 -0500
Subject: [PATCH 5/8] Update Tapioca

---
 sorbet/rbi/gems/tapioca@0.16.6.rbi | 3628 ++++++++++++++++++++++++++++
 sorbet/rbi/gems/tapioca@0.16.8.rbi |   30 +
 2 files changed, 3658 insertions(+)
 create mode 100644 sorbet/rbi/gems/tapioca@0.16.6.rbi

diff --git a/sorbet/rbi/gems/tapioca@0.16.6.rbi b/sorbet/rbi/gems/tapioca@0.16.6.rbi
new file mode 100644
index 00000000..fb3b20f4
--- /dev/null
+++ b/sorbet/rbi/gems/tapioca@0.16.6.rbi
@@ -0,0 +1,3628 @@
+# typed: true
+
+# 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 gem tapioca`.
+
+
+class Bundler::Dependency < ::Gem::Dependency
+  include ::Tapioca::BundlerExt::AutoRequireHook
+end
+
+# source://tapioca/lib/tapioca/helpers/git_attributes.rb#4
+class GitAttributes
+  class << self
+    # source://tapioca/lib/tapioca/helpers/git_attributes.rb#9
+    sig { params(path: ::Pathname).void }
+    def create_generated_attribute_file(path); end
+
+    # source://tapioca/lib/tapioca/helpers/git_attributes.rb#16
+    sig { params(path: ::Pathname).void }
+    def create_vendored_attribute_file(path); end
+
+    private
+
+    # source://tapioca/lib/tapioca/helpers/git_attributes.rb#25
+    sig { params(path: ::Pathname, content: ::String).void }
+    def create_gitattributes_file(path, content); end
+  end
+end
+
+# We need to do the alias-method-chain dance since Bootsnap does the same,
+# and prepended modules and alias-method-chain don't play well together.
+#
+# So, why does Bootsnap do alias-method-chain and not prepend? Glad you asked!
+# That's because RubyGems does alias-method-chain for Kernel#require and such,
+# so, if Bootsnap were to do prepend, it might end up breaking RubyGems.
+#
+# source://tapioca/lib/tapioca/runtime/trackers/autoload.rb#68
+class Module
+  # source://tapioca/lib/tapioca/runtime/trackers/mixin.rb#101
+  def append_features(constant); end
+
+  # source://tapioca/lib/tapioca/runtime/trackers/autoload.rb#71
+  def autoload(const_name, path); end
+
+  # source://tapioca/lib/tapioca/runtime/trackers/mixin.rb#111
+  def extend_object(obj); end
+
+  # source://tapioca/lib/tapioca/runtime/trackers/mixin.rb#91
+  def prepend_features(constant); end
+end
+
+# source://tapioca/lib/tapioca/rbi_ext/model.rb#4
+module RBI; end
+
+# source://tapioca/lib/tapioca/rbi_ext/model.rb#5
+class RBI::Tree < ::RBI::NodeWithComments
+  # source://rbi/0.2.3lib/rbi/model.rb#121
+  sig do
+    params(
+      loc: T.nilable(::RBI::Loc),
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::Tree).void)
+    ).void
+  end
+  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://rbi/0.2.3lib/rbi/model.rb#128
+  sig { params(node: ::RBI::Node).void }
+  def <<(node); end
+
+  # source://rbi/0.2.3lib/rbi/rewriters/add_sig_templates.rb#66
+  sig { params(with_todo_comment: T::Boolean).void }
+  def add_sig_templates!(with_todo_comment: T.unsafe(nil)); end
+
+  # source://rbi/0.2.3lib/rbi/rewriters/annotate.rb#49
+  sig { params(annotation: ::String, annotate_scopes: T::Boolean, annotate_properties: T::Boolean).void }
+  def annotate!(annotation, annotate_scopes: T.unsafe(nil), annotate_properties: T.unsafe(nil)); end
+
+  # source://tapioca/lib/tapioca/rbi_ext/model.rb#38
+  sig do
+    params(
+      name: ::String,
+      superclass_name: T.nilable(::String),
+      block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)
+    ).returns(::RBI::Scope)
+  end
+  def create_class(name, superclass_name: T.unsafe(nil), &block); end
+
+  # source://tapioca/lib/tapioca/rbi_ext/model.rb#45
+  sig { params(name: ::String, value: ::String).void }
+  def create_constant(name, value:); end
+
+  # source://tapioca/lib/tapioca/rbi_ext/model.rb#55
+  sig { params(name: ::String).void }
+  def create_extend(name); end
+
+  # source://tapioca/lib/tapioca/rbi_ext/model.rb#50
+  sig { params(name: ::String).void }
+  def create_include(name); end
+
+  # source://tapioca/lib/tapioca/rbi_ext/model.rb#90
+  sig do
+    params(
+      name: ::String,
+      parameters: T::Array[::RBI::TypedParam],
+      return_type: T.nilable(::String),
+      class_method: T::Boolean,
+      visibility: ::RBI::Visibility,
+      comments: T::Array[::RBI::Comment],
+      block: T.nilable(T.proc.params(node: ::RBI::Method).void)
+    ).void
+  end
+  def create_method(name, parameters: T.unsafe(nil), return_type: T.unsafe(nil), class_method: T.unsafe(nil), visibility: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  # source://tapioca/lib/tapioca/rbi_ext/model.rb#60
+  sig { params(name: ::String).void }
+  def create_mixes_in_class_methods(name); end
+
+  # source://tapioca/lib/tapioca/rbi_ext/model.rb#25
+  sig { params(name: ::String, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).returns(::RBI::Scope) }
+  def create_module(name, &block); end
+
+  # source://tapioca/lib/tapioca/rbi_ext/model.rb#9
+  sig { params(constant: ::Module, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).returns(::RBI::Scope) }
+  def create_path(constant, &block); end
+
+  # source://tapioca/lib/tapioca/rbi_ext/model.rb#74
+  sig do
+    params(
+      name: ::String,
+      type: ::String,
+      variance: ::Symbol,
+      fixed: T.nilable(::String),
+      upper: T.nilable(::String),
+      lower: T.nilable(::String)
+    ).void
+  end
+  def create_type_variable(name, type:, variance: T.unsafe(nil), fixed: T.unsafe(nil), upper: T.unsafe(nil), lower: T.unsafe(nil)); end
+
+  # source://rbi/0.2.3lib/rbi/rewriters/deannotate.rb#41
+  sig { params(annotation: ::String).void }
+  def deannotate!(annotation); end
+
+  # source://rbi/0.2.3lib/rbi/model.rb#134
+  sig { returns(T::Boolean) }
+  def empty?; end
+
+  # source://rbi/0.2.3lib/rbi/rewriters/filter_versions.rb#118
+  sig { params(version: ::Gem::Version).void }
+  def filter_versions!(version); end
+
+  # source://rbi/0.2.3lib/rbi/rewriters/flatten_singleton_methods.rb#60
+  sig { void }
+  def flatten_singleton_methods!; end
+
+  # source://rbi/0.2.3lib/rbi/rewriters/flatten_visibilities.rb#60
+  sig { void }
+  def flatten_visibilities!; end
+
+  # source://rbi/0.2.3lib/rbi/rewriters/group_nodes.rb#81
+  sig { void }
+  def group_nodes!; end
+
+  # source://rbi/0.2.3lib/rbi/index.rb#68
+  sig { returns(::RBI::Index) }
+  def index; end
+
+  # source://rbi/0.2.3lib/rbi/rewriters/merge_trees.rb#324
+  sig do
+    params(
+      other: ::RBI::Tree,
+      left_name: ::String,
+      right_name: ::String,
+      keep: ::RBI::Rewriters::Merge::Keep
+    ).returns(::RBI::MergeTree)
+  end
+  def merge(other, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
+
+  # source://rbi/0.2.3lib/rbi/rewriters/nest_non_public_members.rb#46
+  sig { void }
+  def nest_non_public_members!; end
+
+  # source://rbi/0.2.3lib/rbi/rewriters/nest_singleton_methods.rb#36
+  sig { void }
+  def nest_singleton_methods!; end
+
+  # source://rbi/0.2.3lib/rbi/rewriters/nest_top_level_members.rb#63
+  sig { void }
+  def nest_top_level_members!; end
+
+  # source://rbi/0.2.3lib/rbi/model.rb#112
+  sig { returns(T::Array[::RBI::Node]) }
+  def nodes; end
+
+  # source://rbi/0.2.3lib/rbi/rewriters/attr_to_methods.rb#53
+  sig { void }
+  def replace_attributes_with_methods!; end
+
+  # source://rbi/0.2.3lib/rbi/rewriters/sort_nodes.rb#119
+  sig { void }
+  def sort_nodes!; end
+
+  private
+
+  # source://tapioca/lib/tapioca/rbi_ext/model.rb#123
+  sig { params(node: ::RBI::Node).returns(::RBI::Node) }
+  def create_node(node); end
+
+  # source://tapioca/lib/tapioca/rbi_ext/model.rb#118
+  sig { returns(T::Hash[::String, ::RBI::Node]) }
+  def nodes_cache; end
+end
+
+# source://tapioca/lib/tapioca/rbi_ext/model.rb#133
+class RBI::TypedParam < ::T::Struct
+  const :param, ::RBI::Param
+  const :type, ::String
+
+  class << self
+<<<<<<<< HEAD:sorbet/rbi/gems/tapioca@0.16.8.rbi
+    # source://sorbet-runtime/0.5.11761lib/types/struct.rb#13
+|||||||| parent of 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.5.rbi
+    # source://sorbet-runtime/0.5.11635lib/types/struct.rb#13
+========
+    # source://sorbet-runtime/0.5.11725lib/types/struct.rb#13
+>>>>>>>> 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.6.rbi
+    def inherited(s); end
+  end
+end
+
+# source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#5
+module T::Generic
+  include ::Kernel
+
+  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#13
+  def [](*types); end
+
+  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#47
+  def has_attached_class!(variance = T.unsafe(nil), &bounds_proc); end
+
+  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#21
+  def type_member(variance = T.unsafe(nil), &bounds_proc); end
+
+  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#34
+  def type_template(variance = T.unsafe(nil), &bounds_proc); end
+end
+
+# This module intercepts calls to generic type instantiations and type variable definitions.
+# Tapioca stores the data from those calls in a `GenericTypeRegistry` which can then be used
+# to look up the original call details when we are trying to do code generation.
+#
+# We are interested in the data of the `[]`, `type_member` and `type_template` calls which
+# are all needed to generate good generic information at runtime.
+#
+# source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#12
+module T::Generic::TypeStoragePatch
+  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#13
+  def [](*types); end
+
+  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#47
+  def has_attached_class!(variance = T.unsafe(nil), &bounds_proc); end
+
+  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#21
+  def type_member(variance = T.unsafe(nil), &bounds_proc); end
+
+  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#34
+  def type_template(variance = T.unsafe(nil), &bounds_proc); end
+end
+
+# source://tapioca/lib/tapioca/sorbet_ext/proc_bind_patch.rb#28
+module T::Private::Methods
+  class << self
+    # source://tapioca/lib/tapioca/sorbet_ext/proc_bind_patch.rb#30
+    def finalize_proc(decl); end
+  end
+end
+
+class T::Private::Methods::Declaration < ::Struct
+  def bind; end
+  def bind=(_); end
+  def checked; end
+  def checked=(_); end
+  def finalized; end
+  def finalized=(_); end
+  def mod; end
+  def mod=(_); end
+  def mode; end
+  def mode=(_); end
+  def on_failure; end
+  def on_failure=(_); end
+  def override_allow_incompatible; end
+  def override_allow_incompatible=(_); end
+  def params; end
+  def params=(_); end
+  def raw; end
+  def raw=(_); end
+  def returns; end
+  def returns=(_); end
+  def type_parameters; end
+  def type_parameters=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class T::Private::Methods::DeclarationBlock < ::Struct
+  def blk; end
+  def blk=(_); end
+  def final; end
+  def final=(_); end
+  def loc; end
+  def loc=(_); end
+  def mod; end
+  def mod=(_); end
+  def raw; end
+  def raw=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def keyword_init?; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+# source://tapioca/lib/tapioca/sorbet_ext/proc_bind_patch.rb#29
+module T::Private::Methods::ProcBindPatch
+  # source://tapioca/lib/tapioca/sorbet_ext/proc_bind_patch.rb#30
+  def finalize_proc(decl); end
+end
+
+class T::Types::Proc < ::T::Types::Base; end
+
+# source://tapioca/lib/tapioca/sorbet_ext/proc_bind_patch.rb#6
+module T::Types::ProcBindPatch
+  # source://tapioca/lib/tapioca/sorbet_ext/proc_bind_patch.rb#7
+  def initialize(arg_types, returns, bind = T.unsafe(nil)); end
+
+  # source://tapioca/lib/tapioca/sorbet_ext/proc_bind_patch.rb#15
+  def name; end
+end
+
+# source://tapioca/lib/tapioca/sorbet_ext/name_patch.rb#6
+class T::Types::Simple < ::T::Types::Base
+  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#70
+  def name; end
+end
+
+# source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#65
+module T::Types::Simple::GenericPatch
+  # This method intercepts calls to the `name` method for simple types, so that
+  # it can ask the name to the type if the type is generic, since, by this point,
+  # we've created a clone of that type with the `name` method returning the
+  # appropriate name for that specific concrete type.
+  #
+  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#70
+  def name; end
+end
+
+# source://tapioca/lib/tapioca/sorbet_ext/name_patch.rb#7
+module T::Types::Simple::NamePatch
+  # source://tapioca/lib/tapioca/sorbet_ext/name_patch.rb#10
+  def name; end
+
+  # source://tapioca/lib/tapioca/sorbet_ext/name_patch.rb#16
+  def qualified_name_of(constant); end
+end
+
+# source://tapioca/lib/tapioca/sorbet_ext/name_patch.rb#8
+T::Types::Simple::NamePatch::NAME_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#87
+module T::Utils::Private
+  class << self
+    # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#89
+    def coerce_and_check_module_types(val, check_val, check_module_type); end
+  end
+end
+
+# source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#88
+module T::Utils::Private::PrivateCoercePatch
+  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#89
+  def coerce_and_check_module_types(val, check_val, check_module_type); end
+end
+
+# source://tapioca/lib/tapioca/runtime/trackers/autoload.rb#4
+module Tapioca
+  class << self
+    # source://tapioca/lib/tapioca.rb#20
+    sig do
+      type_parameters(:Result)
+        .params(
+          blk: T.proc.returns(T.type_parameter(:Result))
+        ).returns(T.type_parameter(:Result))
+    end
+    def silence_warnings(&blk); end
+  end
+end
+
+# source://tapioca/lib/tapioca.rb#39
+Tapioca::BINARY_FILE = T.let(T.unsafe(nil), String)
+
+# source://tapioca/lib/tapioca/bundler_ext/auto_require_hook.rb#5
+module Tapioca::BundlerExt; end
+
+# This is a module that gets prepended to `Bundler::Dependency` and
+# makes sure even gems marked as `require: false` are required during
+# `Bundler.require`.
+#
+# source://tapioca/lib/tapioca/bundler_ext/auto_require_hook.rb#9
+module Tapioca::BundlerExt::AutoRequireHook
+  requires_ancestor { Bundler::Dependency }
+
+  # source://tapioca/lib/tapioca/bundler_ext/auto_require_hook.rb#46
+  sig { returns(T.untyped) }
+  def autorequire; end
+
+  class << self
+    # @return [Boolean]
+    #
+    # source://tapioca/lib/tapioca/bundler_ext/auto_require_hook.rb#26
+    def enabled?; end
+
+    # source://tapioca/lib/tapioca/bundler_ext/auto_require_hook.rb#22
+    sig { params(name: T.untyped).returns(T::Boolean) }
+    def excluded?(name); end
+
+    # source://tapioca/lib/tapioca/bundler_ext/auto_require_hook.rb#36
+    sig do
+      type_parameters(:Result)
+        .params(
+          exclude: T::Array[::String],
+          blk: T.proc.returns(T.type_parameter(:Result))
+        ).returns(T.type_parameter(:Result))
+    end
+    def override_require_false(exclude:, &blk); end
+  end
+end
+
+# source://tapioca/lib/tapioca.rb#62
+Tapioca::CENTRAL_REPO_ANNOTATIONS_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca/lib/tapioca.rb#61
+Tapioca::CENTRAL_REPO_INDEX_PATH = T.let(T.unsafe(nil), String)
+
+# source://tapioca/lib/tapioca.rb#60
+Tapioca::CENTRAL_REPO_ROOT_URI = T.let(T.unsafe(nil), String)
+
+# source://tapioca/lib/tapioca/cli.rb#5
+class Tapioca::Cli < ::Thor
+  include ::Tapioca::CliHelper
+  include ::Tapioca::ConfigHelper
+  include ::Tapioca::EnvHelper
+
+  # source://tapioca/lib/tapioca/cli.rb#377
+  def __print_version; end
+
+  # source://tapioca/lib/tapioca/cli.rb#359
+  def annotations; end
+
+  # source://tapioca/lib/tapioca/cli.rb#331
+  def check_shims; end
+
+  # source://tapioca/lib/tapioca/cli.rb#46
+  def configure; end
+
+  # source://tapioca/lib/tapioca/cli.rb#151
+  def dsl(*constant_or_paths); end
+
+  # @raise [MalformattedArgumentError]
+  #
+  # source://tapioca/lib/tapioca/cli.rb#274
+  def gem(*gems); end
+
+  # source://tapioca/lib/tapioca/cli.rb#27
+  def init; end
+
+  # source://tapioca/lib/tapioca/cli.rb#57
+  def require; end
+
+  # source://tapioca/lib/tapioca/cli.rb#74
+  def todo; end
+
+  private
+
+  # source://tapioca/lib/tapioca/cli.rb#391
+  def print_init_next_steps; end
+
+  class << self
+    # source://tapioca/lib/tapioca/cli.rb#383
+    def exit_on_failure?; end
+  end
+end
+
+# source://tapioca/lib/tapioca/cli.rb#10
+Tapioca::Cli::FILE_HEADER_OPTION_DESC = T.let(T.unsafe(nil), String)
+
+# source://tapioca/lib/tapioca/helpers/cli_helper.rb#5
+module Tapioca::CliHelper
+  requires_ancestor { Thor::Shell }
+
+  # source://tapioca/lib/tapioca/helpers/cli_helper.rb#33
+  sig { params(options: T::Hash[::Symbol, T.untyped]).returns(T.nilable(::String)) }
+  def netrc_file(options); end
+
+  # source://tapioca/lib/tapioca/helpers/cli_helper.rb#26
+  sig { params(options: T::Hash[::Symbol, T.untyped]).returns(::Tapioca::RBIFormatter) }
+  def rbi_formatter(options); end
+
+  # source://tapioca/lib/tapioca/helpers/cli_helper.rb#12
+  sig { params(message: ::String, color: T.any(::Symbol, T::Array[::Symbol])).void }
+  def say_error(message = T.unsafe(nil), *color); end
+end
+
+# source://tapioca/lib/tapioca/commands.rb#5
+module Tapioca::Commands; end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://tapioca/lib/tapioca/commands/abstract_dsl.rb#6
+class Tapioca::Commands::AbstractDsl < ::Tapioca::Commands::CommandWithoutTracker
+  include ::Tapioca::SorbetHelper
+  include ::Tapioca::RBIFilesHelper
+
+  abstract!
+
+  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#34
+  sig do
+    params(
+      requested_constants: T::Array[::String],
+      requested_paths: T::Array[::Pathname],
+      outpath: ::Pathname,
+      only: T::Array[::String],
+      exclude: T::Array[::String],
+      file_header: T::Boolean,
+      tapioca_path: ::String,
+      skip_constant: T::Array[::String],
+      quiet: T::Boolean,
+      verbose: T::Boolean,
+      number_of_workers: T.nilable(::Integer),
+      auto_strictness: T::Boolean,
+      gem_dir: ::String,
+      rbi_formatter: ::Tapioca::RBIFormatter,
+      app_root: ::String,
+      halt_upon_load_error: T::Boolean,
+      compiler_options: T::Hash[::String, T.untyped],
+      lsp_addon: T::Boolean
+    ).void
+  end
+  def initialize(requested_constants:, requested_paths:, outpath:, only:, exclude:, file_header:, tapioca_path:, skip_constant: T.unsafe(nil), quiet: T.unsafe(nil), verbose: T.unsafe(nil), number_of_workers: T.unsafe(nil), auto_strictness: T.unsafe(nil), gem_dir: T.unsafe(nil), rbi_formatter: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil), compiler_options: T.unsafe(nil), lsp_addon: T.unsafe(nil)); end
+
+  private
+
+  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#107
+  sig { returns(T::Array[::String]) }
+  def all_requested_constants; end
+
+  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#306
+  sig { params(cause: ::Symbol, files: T::Array[::String]).returns(::String) }
+  def build_error_for_files(cause, files); end
+
+  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#230
+  sig do
+    params(
+      constant_name: ::String,
+      rbi: ::RBI::File,
+      outpath: ::Pathname,
+      quiet: T::Boolean
+    ).returns(T.nilable(::Pathname))
+  end
+  def compile_dsl_rbi(constant_name, rbi, outpath: T.unsafe(nil), quiet: T.unsafe(nil)); end
+
+  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#165
+  sig { params(constant_names: T::Array[::String], ignore_missing: T::Boolean).returns(T::Array[::Module]) }
+  def constantize(constant_names, ignore_missing: T.unsafe(nil)); end
+
+  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#190
+  sig { params(compiler_names: T::Array[::String]).returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) }
+  def constantize_compilers(compiler_names); end
+
+  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#366
+  sig { returns(T::Array[::String]) }
+  def constants_from_requested_paths; end
+
+  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#133
+  sig { returns(::Tapioca::Dsl::Pipeline) }
+  def create_pipeline; end
+
+  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#269
+  sig { params(constant_name: ::String).returns(::Pathname) }
+  def dsl_rbi_filename(constant_name); end
+
+  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#151
+  sig { params(requested_constants: T::Array[::String], path: ::Pathname).returns(T::Set[::Pathname]) }
+  def existing_rbi_filenames(requested_constants, path: T.unsafe(nil)); end
+
+  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#361
+  sig { params(constant: ::String).returns(::String) }
+  def generate_command_for(constant); end
+
+  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#79
+  sig { params(outpath: ::Pathname, quiet: T::Boolean).returns(T::Set[::Pathname]) }
+  def generate_dsl_rbi_files(outpath, quiet:); end
+
+  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#120
+  sig { void }
+  def load_application; end
+
+  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#248
+  sig { params(dir: ::Pathname).void }
+  def perform_dsl_verification(dir); end
+
+  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#115
+  sig { returns(::Tapioca::Dsl::Pipeline) }
+  def pipeline; end
+
+  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#257
+  sig { params(files: T::Set[::Pathname]).void }
+  def purge_stale_dsl_rbi_files(files); end
+
+  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#356
+  sig { params(constant: ::String).returns(::String) }
+  def rbi_filename_for(constant); end
+
+  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#337
+  sig { params(path: ::Pathname).returns(T::Array[::Pathname]) }
+  def rbi_files_in(path); end
+
+  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#315
+  sig { params(diff: T::Hash[::String, ::Symbol], command: ::Symbol).void }
+  def report_diff_and_exit_if_out_of_date(diff, command); end
+
+  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#210
+  sig { params(name: ::String).returns(T.nilable(T.class_of(Tapioca::Dsl::Compiler))) }
+  def resolve(name); end
+
+  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#344
+  sig { params(class_name: ::String).returns(::String) }
+  def underscore(class_name); end
+
+  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#274
+  sig { params(tmp_dir: ::Pathname).returns(T::Hash[::String, ::Symbol]) }
+  def verify_dsl_rbi(tmp_dir:); end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://tapioca/lib/tapioca/commands/abstract_gem.rb#6
+class Tapioca::Commands::AbstractGem < ::Tapioca::Commands::Command
+  include ::Tapioca::SorbetHelper
+  include ::Tapioca::RBIFilesHelper
+
+  abstract!
+
+  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#33
+  sig do
+    params(
+      gem_names: T::Array[::String],
+      exclude: T::Array[::String],
+      include_dependencies: T::Boolean,
+      prerequire: T.nilable(::String),
+      postrequire: ::String,
+      typed_overrides: T::Hash[::String, ::String],
+      outpath: ::Pathname,
+      file_header: T::Boolean,
+      include_doc: T::Boolean,
+      include_loc: T::Boolean,
+      include_exported_rbis: T::Boolean,
+      number_of_workers: T.nilable(::Integer),
+      auto_strictness: T::Boolean,
+      dsl_dir: ::String,
+      rbi_formatter: ::Tapioca::RBIFormatter,
+      halt_upon_load_error: T::Boolean,
+      lsp_addon: T.nilable(T::Boolean)
+    ).void
+  end
+  def initialize(gem_names:, exclude:, include_dependencies:, prerequire:, postrequire:, typed_overrides:, outpath:, file_header:, include_doc:, include_loc:, include_exported_rbis:, number_of_workers: T.unsafe(nil), auto_strictness: T.unsafe(nil), dsl_dir: T.unsafe(nil), rbi_formatter: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil), lsp_addon: T.unsafe(nil)); end
+
+  private
+
+  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#200
+  sig { returns(T::Array[::String]) }
+  def added_rbis; end
+
+  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#261
+  sig { params(cause: ::Symbol, files: T::Array[::String]).returns(::String) }
+  def build_error_for_files(cause, files); end
+
+  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#80
+  sig { params(gem: ::Tapioca::Gemfile::GemSpec).void }
+  def compile_gem_rbi(gem); end
+
+  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#195
+  sig { params(gem_name: ::String).returns(::Pathname) }
+  def existing_rbi(gem_name); end
+
+  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#243
+  sig { returns(T::Hash[::String, ::String]) }
+  def existing_rbis; end
+
+  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#207
+  sig { params(gem_name: ::String).returns(::Pathname) }
+  def expected_rbi(gem_name); end
+
+  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#249
+  sig { returns(T::Hash[::String, ::String]) }
+  def expected_rbis; end
+
+  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#212
+  sig { params(gem_name: ::String).returns(T::Boolean) }
+  def gem_rbi_exists?(gem_name); end
+
+  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#256
+  sig { params(gem_name: ::String, version: ::String).returns(::Pathname) }
+  def gem_rbi_filename(gem_name, version); end
+
+  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#266
+  sig { params(gem: ::Tapioca::Gemfile::GemSpec, file: ::RBI::File).void }
+  def merge_with_exported_rbi(gem, file); end
+
+  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#237
+  sig { params(old_filename: ::Pathname, new_filename: ::Pathname).void }
+  def move(old_filename, new_filename); end
+
+  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#147
+  sig { void }
+  def perform_additions; end
+
+  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#120
+  sig { void }
+  def perform_removals; end
+
+  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#190
+  sig { returns(T::Array[::String]) }
+  def removed_rbis; end
+
+  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#217
+  sig { params(diff: T::Hash[::String, ::Symbol], command: ::Symbol).void }
+  def report_diff_and_exit_if_out_of_date(diff, command); end
+end
+
+# source://tapioca/lib/tapioca/commands/annotations.rb#6
+class Tapioca::Commands::Annotations < ::Tapioca::Commands::CommandWithoutTracker
+  # source://tapioca/lib/tapioca/commands/annotations.rb#18
+  sig do
+    params(
+      central_repo_root_uris: T::Array[::String],
+      auth: T.nilable(::String),
+      netrc_file: T.nilable(::String),
+      central_repo_index_path: ::String,
+      typed_overrides: T::Hash[::String, ::String]
+    ).void
+  end
+  def initialize(central_repo_root_uris:, auth: T.unsafe(nil), netrc_file: T.unsafe(nil), central_repo_index_path: T.unsafe(nil), typed_overrides: T.unsafe(nil)); end
+
+  private
+
+  # source://tapioca/lib/tapioca/commands/annotations.rb#197
+  sig { params(name: ::String, content: ::String).returns(::String) }
+  def add_header(name, content); end
+
+  # source://tapioca/lib/tapioca/commands/annotations.rb#217
+  sig { params(name: ::String, content: ::String).returns(::String) }
+  def apply_typed_override(name, content); end
+
+  # source://tapioca/lib/tapioca/commands/annotations.rb#39
+  sig { override.void }
+  def execute; end
+
+  # source://tapioca/lib/tapioca/commands/annotations.rb#136
+  sig { params(repo_uris: T::Array[::String], gem_info: ::Tapioca::GemInfo).void }
+  def fetch_annotation(repo_uris, gem_info); end
+
+  # source://tapioca/lib/tapioca/commands/annotations.rb#113
+  sig { params(project_gems: T::Array[::Tapioca::GemInfo]).returns(T::Array[::String]) }
+  def fetch_annotations(project_gems); end
+
+  # source://tapioca/lib/tapioca/commands/annotations.rb#156
+  sig { params(repo_uri: ::String, path: ::String).returns(T.nilable(::String)) }
+  def fetch_file(repo_uri, path); end
+
+  # source://tapioca/lib/tapioca/commands/annotations.rb#173
+  sig { params(repo_uri: ::String, path: ::String).returns(T.nilable(::String)) }
+  def fetch_http_file(repo_uri, path); end
+
+  # source://tapioca/lib/tapioca/commands/annotations.rb#102
+  sig { params(repo_uri: ::String, repo_number: T.nilable(::Integer)).returns(T.nilable(Tapioca::RepoIndex)) }
+  def fetch_index(repo_uri, repo_number:); end
+
+  # source://tapioca/lib/tapioca/commands/annotations.rb#81
+  sig { returns(T::Hash[::String, Tapioca::RepoIndex]) }
+  def fetch_indexes; end
+
+  # source://tapioca/lib/tapioca/commands/annotations.rb#165
+  sig { params(repo_uri: ::String, path: ::String).returns(T.nilable(::String)) }
+  def fetch_local_file(repo_uri, path); end
+
+  # source://tapioca/lib/tapioca/commands/annotations.rb#229
+  sig { params(gem_version: ::Gem::Version, content: ::String).returns(::String) }
+  def filter_versions(gem_version, content); end
+
+  # source://tapioca/lib/tapioca/commands/annotations.rb#50
+  sig { returns(T::Array[::Tapioca::GemInfo]) }
+  def list_gemfile_gems; end
+
+  # source://tapioca/lib/tapioca/commands/annotations.rb#237
+  sig { params(gem_name: ::String, contents: T::Array[::String]).returns(T.nilable(::String)) }
+  def merge_files(gem_name, contents); end
+
+  # source://tapioca/lib/tapioca/commands/annotations.rb#60
+  sig { params(project_gems: T::Array[::Tapioca::GemInfo]).void }
+  def remove_expired_annotations(project_gems); end
+
+  # source://tapioca/lib/tapioca/commands/annotations.rb#264
+  sig { returns(T::Hash[::String, T.nilable(::String)]) }
+  def repo_tokens; end
+
+  # source://tapioca/lib/tapioca/commands/annotations.rb#292
+  sig { params(path: ::String, repo_uri: ::String, message: ::String).void }
+  def say_http_error(path, repo_uri, message:); end
+
+  # source://tapioca/lib/tapioca/commands/annotations.rb#276
+  sig { params(repo_uri: ::String).returns(T.nilable(::String)) }
+  def token_for(repo_uri); end
+end
+
+# source://tapioca/lib/tapioca/commands/check_shims.rb#6
+class Tapioca::Commands::CheckShims < ::Tapioca::Commands::CommandWithoutTracker
+  include ::Tapioca::SorbetHelper
+  include ::Tapioca::RBIFilesHelper
+
+  # source://tapioca/lib/tapioca/commands/check_shims.rb#22
+  sig do
+    params(
+      gem_rbi_dir: ::String,
+      dsl_rbi_dir: ::String,
+      annotations_rbi_dir: ::String,
+      shim_rbi_dir: ::String,
+      todo_rbi_file: ::String,
+      payload: T::Boolean,
+      number_of_workers: T.nilable(::Integer)
+    ).void
+  end
+  def initialize(gem_rbi_dir:, dsl_rbi_dir:, annotations_rbi_dir:, shim_rbi_dir:, todo_rbi_file:, payload:, number_of_workers:); end
+
+  private
+
+  # source://tapioca/lib/tapioca/commands/check_shims.rb#44
+  sig { override.void }
+  def execute; end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://tapioca/lib/tapioca/commands/command.rb#6
+class Tapioca::Commands::Command
+  include ::Thor::Base
+  include ::Thor::Invocation
+  include ::Thor::Shell
+  include ::Tapioca::CliHelper
+  extend ::Thor::Base::ClassMethods
+  extend ::Thor::Invocation::ClassMethods
+
+  abstract!
+
+  # source://tapioca/lib/tapioca/commands/command.rb#20
+  sig { void }
+  def initialize; end
+
+  # source://thor/1.3.2lib/thor/base.rb#155
+  sig { returns(::Thor::Actions) }
+  def file_writer; end
+
+  # source://tapioca/lib/tapioca/commands/command.rb#25
+  sig(:final) { void }
+  def run; end
+
+  private
+
+  # source://tapioca/lib/tapioca/commands/command.rb#53
+  sig do
+    params(
+      path: T.any(::Pathname, ::String),
+      content: ::String,
+      force: T::Boolean,
+      skip: T::Boolean,
+      verbose: T::Boolean
+    ).void
+  end
+  def create_file(path, content, force: T.unsafe(nil), skip: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  # source://tapioca/lib/tapioca/commands/command.rb#37
+  sig { params(command: ::Symbol, args: ::String).returns(::String) }
+  def default_command(command, *args); end
+
+  # @abstract
+  #
+  # source://tapioca/lib/tapioca/commands/command.rb#34
+  sig { abstract.void }
+  def execute; end
+
+  # source://tapioca/lib/tapioca/commands/command.rb#63
+  sig { params(path: T.any(::Pathname, ::String), verbose: T::Boolean).void }
+  def remove_file(path, verbose: T.unsafe(nil)); end
+end
+
+# source://tapioca/lib/tapioca/commands/command.rb#10
+class Tapioca::Commands::Command::FileWriter < ::Thor
+  include ::Thor::Actions
+  extend ::Thor::Actions::ClassMethods
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://tapioca/lib/tapioca/commands/command_without_tracker.rb#6
+class Tapioca::Commands::CommandWithoutTracker < ::Tapioca::Commands::Command
+  abstract!
+
+  # source://tapioca/lib/tapioca/commands/command_without_tracker.rb#12
+  sig { void }
+  def initialize; end
+end
+
+# source://tapioca/lib/tapioca/commands/configure.rb#6
+class Tapioca::Commands::Configure < ::Tapioca::Commands::CommandWithoutTracker
+  # source://tapioca/lib/tapioca/commands/configure.rb#14
+  sig { params(sorbet_config: ::String, tapioca_config: ::String, default_postrequire: ::String).void }
+  def initialize(sorbet_config:, tapioca_config:, default_postrequire:); end
+
+  private
+
+  # source://tapioca/lib/tapioca/commands/configure.rb#79
+  sig { void }
+  def create_binstub; end
+
+  # source://tapioca/lib/tapioca/commands/configure.rb#69
+  sig { void }
+  def create_post_require; end
+
+  # source://tapioca/lib/tapioca/commands/configure.rb#40
+  sig { void }
+  def create_sorbet_config; end
+
+  # source://tapioca/lib/tapioca/commands/configure.rb#50
+  sig { void }
+  def create_tapioca_config; end
+
+  # source://tapioca/lib/tapioca/commands/configure.rb#32
+  sig { override.void }
+  def execute; end
+
+  # source://tapioca/lib/tapioca/commands/configure.rb#92
+  sig { returns(::Bundler::Installer) }
+  def installer; end
+
+  # source://tapioca/lib/tapioca/commands/configure.rb#97
+  sig { returns(T.any(::Bundler::StubSpecification, ::Gem::Specification)) }
+  def spec; end
+end
+
+# source://tapioca/lib/tapioca/commands/dsl_compiler_list.rb#6
+class Tapioca::Commands::DslCompilerList < ::Tapioca::Commands::AbstractDsl
+  private
+
+  # source://tapioca/lib/tapioca/commands/dsl_compiler_list.rb#10
+  sig { override.void }
+  def execute; end
+end
+
+# source://tapioca/lib/tapioca/commands/dsl_generate.rb#6
+class Tapioca::Commands::DslGenerate < ::Tapioca::Commands::AbstractDsl
+  private
+
+  # source://tapioca/lib/tapioca/commands/dsl_generate.rb#10
+  sig { override.void }
+  def execute; end
+end
+
+# source://tapioca/lib/tapioca/commands/dsl_verify.rb#6
+class Tapioca::Commands::DslVerify < ::Tapioca::Commands::AbstractDsl
+  private
+
+  # source://tapioca/lib/tapioca/commands/dsl_verify.rb#10
+  sig { override.void }
+  def execute; end
+end
+
+# source://tapioca/lib/tapioca/commands/gem_generate.rb#6
+class Tapioca::Commands::GemGenerate < ::Tapioca::Commands::AbstractGem
+  private
+
+  # source://tapioca/lib/tapioca/commands/gem_generate.rb#10
+  sig { override.void }
+  def execute; end
+
+  # source://tapioca/lib/tapioca/commands/gem_generate.rb#74
+  sig do
+    params(
+      gem: ::Tapioca::Gemfile::GemSpec,
+      dependencies: T::Array[::Tapioca::Gemfile::GemSpec]
+    ).returns(T::Array[::Tapioca::Gemfile::GemSpec])
+  end
+  def gem_dependencies(gem, dependencies = T.unsafe(nil)); end
+
+  # source://tapioca/lib/tapioca/commands/gem_generate.rb#51
+  sig { params(gem_names: T::Array[::String]).returns(T::Array[::Tapioca::Gemfile::GemSpec]) }
+  def gems_to_generate(gem_names); end
+end
+
+# source://tapioca/lib/tapioca/commands/gem_sync.rb#6
+class Tapioca::Commands::GemSync < ::Tapioca::Commands::AbstractGem
+  private
+
+  # source://tapioca/lib/tapioca/commands/gem_sync.rb#10
+  sig { override.void }
+  def execute; end
+end
+
+# source://tapioca/lib/tapioca/commands/gem_verify.rb#6
+class Tapioca::Commands::GemVerify < ::Tapioca::Commands::AbstractGem
+  private
+
+  # source://tapioca/lib/tapioca/commands/gem_verify.rb#10
+  sig { override.void }
+  def execute; end
+
+  # source://tapioca/lib/tapioca/commands/gem_verify.rb#17
+  sig { void }
+  def perform_sync_verification; end
+end
+
+# source://tapioca/lib/tapioca/commands/require.rb#6
+class Tapioca::Commands::Require < ::Tapioca::Commands::CommandWithoutTracker
+  # source://tapioca/lib/tapioca/commands/require.rb#13
+  sig { params(requires_path: ::String, sorbet_config_path: ::String).void }
+  def initialize(requires_path:, sorbet_config_path:); end
+
+  private
+
+  # source://tapioca/lib/tapioca/commands/require.rb#23
+  sig { override.void }
+  def execute; end
+end
+
+# source://tapioca/lib/tapioca/commands/todo.rb#6
+class Tapioca::Commands::Todo < ::Tapioca::Commands::CommandWithoutTracker
+  include ::Tapioca::SorbetHelper
+
+  # source://tapioca/lib/tapioca/commands/todo.rb#26
+  sig { params(todo_file: ::String, file_header: T::Boolean).void }
+  def initialize(todo_file:, file_header:); end
+
+  # source://tapioca/lib/tapioca/commands/todo.rb#34
+  sig { void }
+  def run_with_deprecation; end
+
+  private
+
+  # source://tapioca/lib/tapioca/commands/todo.rb#44
+  sig { override.void }
+  def execute; end
+
+  # source://tapioca/lib/tapioca/commands/todo.rb#68
+  sig { params(constants: T::Array[::String], command: ::String).returns(::RBI::File) }
+  def rbi(constants, command:); end
+
+  # source://tapioca/lib/tapioca/commands/todo.rb#88
+  sig { returns(T::Array[::String]) }
+  def unresolved_constants; end
+end
+
+# source://tapioca/lib/tapioca/commands/todo.rb#9
+Tapioca::Commands::Todo::DEPRECATION_MESSAGE = T.let(T.unsafe(nil), String)
+
+# source://tapioca/lib/tapioca/helpers/config_helper.rb#5
+module Tapioca::ConfigHelper
+  requires_ancestor { Thor }
+
+  # source://tapioca/lib/tapioca/helpers/config_helper.rb#18
+  sig { params(args: T.untyped, local_options: T.untyped, config: T.untyped).void }
+  def initialize(args = T.unsafe(nil), local_options = T.unsafe(nil), config = T.unsafe(nil)); end
+
+  # source://tapioca/lib/tapioca/helpers/config_helper.rb#12
+  sig { returns(::String) }
+  def command_name; end
+
+  # source://tapioca/lib/tapioca/helpers/config_helper.rb#15
+  sig { returns(::Thor::CoreExt::HashWithIndifferentAccess) }
+  def defaults; end
+
+  # source://tapioca/lib/tapioca/helpers/config_helper.rb#34
+  sig { returns(::Thor::CoreExt::HashWithIndifferentAccess) }
+  def options; end
+
+  private
+
+  # source://tapioca/lib/tapioca/helpers/config_helper.rb#153
+  sig { params(msg: ::String).returns(::Tapioca::ConfigHelper::ConfigError) }
+  def build_error(msg); end
+
+  # source://tapioca/lib/tapioca/helpers/config_helper.rb#178
+  sig { params(config_file: ::String, errors: T::Array[::Tapioca::ConfigHelper::ConfigError]).returns(::String) }
+  def build_error_message(config_file, errors); end
+
+  # source://tapioca/lib/tapioca/helpers/config_helper.rb#56
+  sig do
+    params(
+      options: ::Thor::CoreExt::HashWithIndifferentAccess
+    ).returns(::Thor::CoreExt::HashWithIndifferentAccess)
+  end
+  def config_options(options); end
+
+  # source://tapioca/lib/tapioca/helpers/config_helper.rb#46
+  sig { params(options: T::Hash[::Symbol, ::Thor::Option]).void }
+  def filter_defaults(options); end
+
+  # source://tapioca/lib/tapioca/helpers/config_helper.rb#196
+  sig do
+    params(
+      options: T.nilable(::Thor::CoreExt::HashWithIndifferentAccess)
+    ).returns(::Thor::CoreExt::HashWithIndifferentAccess)
+  end
+  def merge_options(*options); end
+
+  # source://tapioca/lib/tapioca/helpers/config_helper.rb#70
+  sig { params(config_file: ::String, config: T::Hash[T.untyped, T.untyped]).void }
+  def validate_config!(config_file, config); end
+
+  # source://tapioca/lib/tapioca/helpers/config_helper.rb#102
+  sig do
+    params(
+      command_options: T::Hash[::Symbol, ::Thor::Option],
+      config_key: ::String,
+      config_options: T::Hash[T.untyped, T.untyped]
+    ).returns(T::Array[::Tapioca::ConfigHelper::ConfigError])
+  end
+  def validate_config_options(command_options, config_key, config_options); end
+end
+
+# source://tapioca/lib/tapioca/helpers/config_helper.rb#148
+class Tapioca::ConfigHelper::ConfigError < ::T::Struct
+  const :message_parts, T::Array[::Tapioca::ConfigHelper::ConfigErrorMessagePart]
+
+  class << self
+<<<<<<<< HEAD:sorbet/rbi/gems/tapioca@0.16.8.rbi
+    # source://sorbet-runtime/0.5.11761lib/types/struct.rb#13
+|||||||| parent of 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.5.rbi
+    # source://sorbet-runtime/0.5.11635lib/types/struct.rb#13
+========
+    # source://sorbet-runtime/0.5.11725lib/types/struct.rb#13
+>>>>>>>> 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.6.rbi
+    def inherited(s); end
+  end
+end
+
+# source://tapioca/lib/tapioca/helpers/config_helper.rb#143
+class Tapioca::ConfigHelper::ConfigErrorMessagePart < ::T::Struct
+  const :message, ::String
+  const :colors, T::Array[::Symbol]
+
+  class << self
+<<<<<<<< HEAD:sorbet/rbi/gems/tapioca@0.16.8.rbi
+    # source://sorbet-runtime/0.5.11761lib/types/struct.rb#13
+|||||||| parent of 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.5.rbi
+    # source://sorbet-runtime/0.5.11635lib/types/struct.rb#13
+========
+    # source://sorbet-runtime/0.5.11725lib/types/struct.rb#13
+>>>>>>>> 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.6.rbi
+    def inherited(s); end
+  end
+end
+
+# source://tapioca/lib/tapioca.rb#46
+Tapioca::DEFAULT_ANNOTATIONS_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca/lib/tapioca.rb#42
+Tapioca::DEFAULT_DSL_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca/lib/tapioca.rb#58
+Tapioca::DEFAULT_ENVIRONMENT = T.let(T.unsafe(nil), String)
+
+# source://tapioca/lib/tapioca.rb#43
+Tapioca::DEFAULT_GEM_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca/lib/tapioca.rb#48
+Tapioca::DEFAULT_OVERRIDES = T.let(T.unsafe(nil), Hash)
+
+# source://tapioca/lib/tapioca.rb#40
+Tapioca::DEFAULT_POSTREQUIRE_FILE = T.let(T.unsafe(nil), String)
+
+# source://tapioca/lib/tapioca.rb#41
+Tapioca::DEFAULT_RBI_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca/lib/tapioca/rbi_formatter.rb#31
+Tapioca::DEFAULT_RBI_FORMATTER = T.let(T.unsafe(nil), Tapioca::RBIFormatter)
+
+# source://tapioca/lib/tapioca.rb#57
+Tapioca::DEFAULT_RBI_MAX_LINE_LENGTH = T.let(T.unsafe(nil), Integer)
+
+# source://tapioca/lib/tapioca.rb#44
+Tapioca::DEFAULT_SHIM_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca/lib/tapioca.rb#45
+Tapioca::DEFAULT_TODO_FILE = T.let(T.unsafe(nil), String)
+
+# source://tapioca/lib/tapioca/dsl/compilers.rb#5
+module Tapioca::Dsl; end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://tapioca/lib/tapioca/dsl/compiler.rb#6
+class Tapioca::Dsl::Compiler
+  extend T::Generic
+  include ::Tapioca::SorbetHelper
+  include ::Tapioca::RBIHelper
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+  extend ::Tapioca::Runtime::AttachedClassOf
+  extend ::Tapioca::Runtime::Reflection
+
+  abstract!
+
+  ConstantType = type_member { { upper: Module } }
+
+  # source://tapioca/lib/tapioca/dsl/compiler.rb#110
+  sig do
+    params(
+      pipeline: ::Tapioca::Dsl::Pipeline,
+      root: ::RBI::Tree,
+      constant: ConstantType,
+      options: T::Hash[::String, T.untyped]
+    ).void
+  end
+  def initialize(pipeline, root, constant, options = T.unsafe(nil)); end
+
+  # NOTE: This should eventually accept an `Error` object or `Exception` rather than simply a `String`.
+  #
+  # source://tapioca/lib/tapioca/dsl/compiler.rb#128
+  sig { params(error: ::String).void }
+  def add_error(error); end
+
+  # source://tapioca/lib/tapioca/dsl/compiler.rb#119
+  sig { params(compiler_name: ::String).returns(T::Boolean) }
+  def compiler_enabled?(compiler_name); end
+
+  # source://tapioca/lib/tapioca/dsl/compiler.rb#20
+  sig { returns(ConstantType) }
+  def constant; end
+
+  # @abstract
+  #
+  # source://tapioca/lib/tapioca/dsl/compiler.rb#124
+  sig { abstract.void }
+  def decorate; end
+
+  # source://tapioca/lib/tapioca/dsl/compiler.rb#26
+  sig { returns(T::Hash[::String, T.untyped]) }
+  def options; end
+
+  # source://tapioca/lib/tapioca/dsl/compiler.rb#23
+  sig { returns(::RBI::Tree) }
+  def root; end
+
+  private
+
+  # source://tapioca/lib/tapioca/dsl/compiler.rb#177
+  sig { params(method_def: T.any(::Method, ::UnboundMethod)).returns(T::Array[::RBI::TypedParam]) }
+  def compile_method_parameters_to_rbi(method_def); end
+
+  # source://tapioca/lib/tapioca/dsl/compiler.rb#213
+  sig { params(method_def: T.any(::Method, ::UnboundMethod)).returns(::String) }
+  def compile_method_return_type_to_rbi(method_def); end
+
+  # source://tapioca/lib/tapioca/dsl/compiler.rb#167
+  sig { params(scope: ::RBI::Scope, method_def: T.any(::Method, ::UnboundMethod), class_method: T::Boolean).void }
+  def create_method_from_def(scope, method_def, class_method: T.unsafe(nil)); end
+
+  # Get the types of each parameter from a method signature
+  #
+  # source://tapioca/lib/tapioca/dsl/compiler.rb#141
+  sig { params(method_def: T.any(::Method, ::UnboundMethod), signature: T.untyped).returns(T::Array[::String]) }
+  def parameters_types_from_signature(method_def, signature); end
+
+  class << self
+    # @abstract
+    #
+    # source://tapioca/lib/tapioca/dsl/compiler.rb#39
+    sig { abstract.returns(T::Enumerable[::Module]) }
+    def gather_constants; end
+
+    # source://tapioca/lib/tapioca/dsl/compiler.rb#34
+    sig { params(constant: ::Module).returns(T::Boolean) }
+    def handles?(constant); end
+
+    # source://tapioca/lib/tapioca/dsl/compiler.rb#42
+    sig { returns(T::Set[::Module]) }
+    def processable_constants; end
+
+    # source://tapioca/lib/tapioca/dsl/compiler.rb#50
+    sig { params(constants: T::Array[::Module]).void }
+    def requested_constants=(constants); end
+
+    # source://tapioca/lib/tapioca/dsl/compiler.rb#55
+    sig { void }
+    def reset_state; end
+
+    private
+
+    # source://tapioca/lib/tapioca/dsl/compiler.rb#82
+    sig { returns(T::Enumerable[T::Class[T.anything]]) }
+    def all_classes; end
+
+    # source://tapioca/lib/tapioca/dsl/compiler.rb#90
+    sig { returns(T::Enumerable[::Module]) }
+    def all_modules; end
+
+    # source://tapioca/lib/tapioca/dsl/compiler.rb#68
+    sig do
+      type_parameters(:U)
+        .params(
+          klass: T.all(T.type_parameter(:U), T::Class[T.anything])
+        ).returns(T::Array[T.type_parameter(:U)])
+    end
+    def descendants_of(klass); end
+  end
+end
+
+# source://tapioca/lib/tapioca/dsl/compilers.rb#6
+module Tapioca::Dsl::Compilers; end
+
+# DSL compilers are either built-in to Tapioca and live under the
+# `Tapioca::Dsl::Compilers` namespace (i.e. this namespace), and
+# can be referred to by just using the class name, or they live in
+# a different namespace and can only be referred to using their fully
+# qualified name. This constant encapsulates that dual lookup when
+# a compiler needs to be resolved by name.
+#
+# source://tapioca/lib/tapioca/dsl/compilers.rb#13
+Tapioca::Dsl::Compilers::NAMESPACES = T.let(T.unsafe(nil), Array)
+
+# source://tapioca/lib/tapioca/dsl/pipeline.rb#6
+class Tapioca::Dsl::Pipeline
+  # source://tapioca/lib/tapioca/dsl/pipeline.rb#40
+  sig do
+    params(
+      requested_constants: T::Array[::Module],
+      requested_paths: T::Array[::Pathname],
+      requested_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)],
+      excluded_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)],
+      error_handler: T.proc.params(error: ::String).void,
+      skipped_constants: T::Array[::Module],
+      number_of_workers: T.nilable(::Integer),
+      compiler_options: T::Hash[::String, T.untyped],
+      lsp_addon: T::Boolean
+    ).void
+  end
+  def initialize(requested_constants:, requested_paths: T.unsafe(nil), requested_compilers: T.unsafe(nil), excluded_compilers: T.unsafe(nil), error_handler: T.unsafe(nil), skipped_constants: T.unsafe(nil), number_of_workers: T.unsafe(nil), compiler_options: T.unsafe(nil), lsp_addon: T.unsafe(nil)); end
+
+  # source://tapioca/lib/tapioca/dsl/pipeline.rb#10
+  sig { returns(T::Enumerable[T.class_of(Tapioca::Dsl::Compiler)]) }
+  def active_compilers; end
+
+  # source://tapioca/lib/tapioca/dsl/pipeline.rb#105
+  sig { params(error: ::String).void }
+  def add_error(error); end
+
+  # source://tapioca/lib/tapioca/dsl/pipeline.rb#110
+  sig { params(compiler_name: ::String).returns(T::Boolean) }
+  def compiler_enabled?(compiler_name); end
+
+  # source://tapioca/lib/tapioca/dsl/pipeline.rb#119
+  sig { returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) }
+  def compilers; end
+
+  # source://tapioca/lib/tapioca/dsl/pipeline.rb#22
+  sig { returns(T.proc.params(error: ::String).void) }
+  def error_handler; end
+
+  # source://tapioca/lib/tapioca/dsl/pipeline.rb#25
+  sig { returns(T::Array[::String]) }
+  def errors; end
+
+  # source://tapioca/lib/tapioca/dsl/pipeline.rb#13
+  sig { returns(T::Array[::Module]) }
+  def requested_constants; end
+
+  # source://tapioca/lib/tapioca/dsl/pipeline.rb#16
+  sig { returns(T::Array[::Pathname]) }
+  def requested_paths; end
+
+  # source://tapioca/lib/tapioca/dsl/pipeline.rb#70
+  sig do
+    type_parameters(:T)
+      .params(
+        blk: T.proc.params(constant: ::Module, rbi: ::RBI::File).returns(T.type_parameter(:T))
+      ).returns(T::Array[T.type_parameter(:T)])
+  end
+  def run(&blk); end
+
+  # source://tapioca/lib/tapioca/dsl/pipeline.rb#19
+  sig { returns(T::Array[::Module]) }
+  def skipped_constants; end
+
+  private
+
+  # source://tapioca/lib/tapioca/dsl/pipeline.rb#227
+  sig { void }
+  def abort_if_pending_migrations!; end
+
+  # source://tapioca/lib/tapioca/dsl/pipeline.rb#172
+  sig { params(constants: T::Set[::Module]).returns(T::Set[::Module]) }
+  def filter_anonymous_and_reloaded_constants(constants); end
+
+  # source://tapioca/lib/tapioca/dsl/pipeline.rb#136
+  sig do
+    params(
+      requested_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)],
+      excluded_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)]
+    ).returns(T::Enumerable[T.class_of(Tapioca::Dsl::Compiler)])
+  end
+  def gather_active_compilers(requested_compilers, excluded_compilers); end
+
+  # source://tapioca/lib/tapioca/dsl/pipeline.rb#150
+  sig do
+    params(
+      requested_constants: T::Array[::Module],
+      requested_paths: T::Array[::Pathname],
+      skipped_constants: T::Array[::Module]
+    ).returns(T::Set[::Module])
+  end
+  def gather_constants(requested_constants, requested_paths, skipped_constants); end
+
+  # source://tapioca/lib/tapioca/dsl/pipeline.rb#201
+  sig { params(constant: ::Module).returns(T.nilable(::RBI::File)) }
+  def rbi_for_constant(constant); end
+
+  # source://tapioca/lib/tapioca/dsl/pipeline.rb#220
+  sig { params(error: ::String).returns(T.noreturn) }
+  def report_error(error); end
+end
+
+# source://tapioca/lib/tapioca/helpers/env_helper.rb#5
+module Tapioca::EnvHelper
+  requires_ancestor { Thor }
+
+  # source://tapioca/lib/tapioca/helpers/env_helper.rb#12
+  sig { params(options: T::Hash[::Symbol, T.untyped]).void }
+  def set_environment(options); end
+end
+
+class Tapioca::Error < ::StandardError; end
+
+# source://tapioca/lib/tapioca/executor.rb#5
+class Tapioca::Executor
+  # source://tapioca/lib/tapioca/executor.rb#11
+  sig { params(queue: T::Array[T.untyped], number_of_workers: T.nilable(::Integer)).void }
+  def initialize(queue, number_of_workers: T.unsafe(nil)); end
+
+  # source://tapioca/lib/tapioca/executor.rb#28
+  sig do
+    type_parameters(:T)
+      .params(
+        block: T.proc.params(item: T.untyped).returns(T.type_parameter(:T))
+      ).returns(T::Array[T.type_parameter(:T)])
+  end
+  def run_in_parallel(&block); end
+
+  private
+
+  # source://tapioca/lib/tapioca/executor.rb#37
+  sig { returns(::Integer) }
+  def max_processors; end
+end
+
+# source://tapioca/lib/tapioca/executor.rb#8
+Tapioca::Executor::MINIMUM_ITEMS_PER_WORKER = T.let(T.unsafe(nil), Integer)
+
+# source://tapioca/lib/tapioca/gem/events.rb#5
+module Tapioca::Gem; end
+
+# source://tapioca/lib/tapioca/gem/events.rb#77
+class Tapioca::Gem::ConstNodeAdded < ::Tapioca::Gem::NodeAdded
+  # source://tapioca/lib/tapioca/gem/events.rb#84
+  sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Const).void }
+  def initialize(symbol, constant, node); end
+
+  # source://tapioca/lib/tapioca/gem/events.rb#81
+  sig { returns(::RBI::Const) }
+  def node; end
+end
+
+# source://tapioca/lib/tapioca/gem/events.rb#26
+class Tapioca::Gem::ConstantFound < ::Tapioca::Gem::Event
+  # source://tapioca/lib/tapioca/gem/events.rb#36
+  sig { params(symbol: ::String, constant: ::BasicObject).void }
+  def initialize(symbol, constant); end
+
+  # source://tapioca/lib/tapioca/gem/events.rb#33
+  sig { returns(::BasicObject) }
+  def constant; end
+
+  # source://tapioca/lib/tapioca/gem/events.rb#30
+  sig { returns(::String) }
+  def symbol; end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://tapioca/lib/tapioca/gem/events.rb#6
+class Tapioca::Gem::Event
+  abstract!
+end
+
+# source://tapioca/lib/tapioca/gem/events.rb#43
+class Tapioca::Gem::ForeignConstantFound < ::Tapioca::Gem::ConstantFound
+  # source://tapioca/lib/tapioca/gem/events.rb#52
+  sig { params(symbol: ::String, constant: ::Module).void }
+  def initialize(symbol, constant); end
+
+  # source://tapioca/lib/tapioca/gem/events.rb#47
+  sig { override.returns(::Module) }
+  def constant; end
+end
+
+# source://tapioca/lib/tapioca/gem/events.rb#103
+class Tapioca::Gem::ForeignScopeNodeAdded < ::Tapioca::Gem::ScopeNodeAdded; end
+
+# source://tapioca/lib/tapioca/gem/listeners/base.rb#6
+module Tapioca::Gem::Listeners; end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://tapioca/lib/tapioca/gem/listeners/base.rb#7
+class Tapioca::Gem::Listeners::Base
+  abstract!
+
+  # source://tapioca/lib/tapioca/gem/listeners/base.rb#14
+  sig { params(pipeline: ::Tapioca::Gem::Pipeline).void }
+  def initialize(pipeline); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/base.rb#19
+  sig { params(event: ::Tapioca::Gem::NodeAdded).void }
+  def dispatch(event); end
+
+  private
+
+  # source://tapioca/lib/tapioca/gem/listeners/base.rb#49
+  sig { params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/base.rb#37
+  sig { params(event: ::Tapioca::Gem::ConstNodeAdded).void }
+  def on_const(event); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/base.rb#45
+  sig { params(event: ::Tapioca::Gem::MethodNodeAdded).void }
+  def on_method(event); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/base.rb#41
+  sig { params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca/lib/tapioca/gem/listeners/dynamic_mixins.rb#7
+class Tapioca::Gem::Listeners::DynamicMixins < ::Tapioca::Gem::Listeners::Base
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+
+  private
+
+  # source://tapioca/lib/tapioca/gem/listeners/dynamic_mixins.rb#31
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/dynamic_mixins.rb#15
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca/lib/tapioca/gem/listeners/foreign_constants.rb#7
+class Tapioca::Gem::Listeners::ForeignConstants < ::Tapioca::Gem::Listeners::Base
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+
+  private
+
+  # source://tapioca/lib/tapioca/gem/listeners/foreign_constants.rb#60
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/foreign_constants.rb#55
+  sig { params(location: ::String).returns(T::Boolean) }
+  def mixed_in_by_gem?(location); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/foreign_constants.rb#15
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca/lib/tapioca/gem/listeners/methods.rb#7
+class Tapioca::Gem::Listeners::Methods < ::Tapioca::Gem::Listeners::Base
+  include ::Tapioca::SorbetHelper
+  include ::Tapioca::RBIHelper
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+
+  private
+
+  # source://tapioca/lib/tapioca/gem/listeners/methods.rb#35
+  sig do
+    params(
+      tree: ::RBI::Tree,
+      module_name: ::String,
+      mod: ::Module,
+      for_visibility: T::Array[::Symbol],
+      attached_class: T.nilable(::Module)
+    ).void
+  end
+  def compile_directly_owned_methods(tree, module_name, mod, for_visibility = T.unsafe(nil), attached_class: T.unsafe(nil)); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/methods.rb#71
+  sig do
+    params(
+      tree: ::RBI::Tree,
+      symbol_name: ::String,
+      constant: ::Module,
+      method: T.nilable(::UnboundMethod),
+      visibility: ::RBI::Visibility
+    ).void
+  end
+  def compile_method(tree, symbol_name, constant, method, visibility = T.unsafe(nil)); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/methods.rb#211
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/methods.rb#204
+  sig { params(constant: ::Module).returns(T.nilable(::UnboundMethod)) }
+  def initialize_method_for(constant); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/methods.rb#216
+  sig { params(method: ::UnboundMethod).returns(T.untyped) }
+  def lookup_signature_of(method); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/methods.rb#172
+  sig { params(mod: ::Module).returns(T::Hash[::Symbol, T::Array[::Symbol]]) }
+  def method_names_by_visibility(mod); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/methods.rb#196
+  sig { params(attached_class: T.nilable(::Module), method_name: ::Symbol).returns(T.nilable(T::Boolean)) }
+  def method_new_in_abstract_class?(attached_class, method_name); end
+
+  # Check whether the method is defined by the constant.
+  #
+  # In most cases, it works to check that the constant is the method owner. However,
+  # in the case that a method is also defined in a module prepended to the constant, it
+  # will be owned by the prepended module, not the constant.
+  #
+  # This method implements a better way of checking whether a constant defines a method.
+  # It walks up the ancestor tree via the `super_method` method; if any of the super
+  # methods are owned by the constant, it means that the constant declares the method.
+  #
+  # source://tapioca/lib/tapioca/gem/listeners/methods.rb#158
+  sig { params(method: ::UnboundMethod, constant: ::Module).returns(T::Boolean) }
+  def method_owned_by_constant?(method, constant); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/methods.rb#16
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/methods.rb#181
+  sig { params(constant: ::Module, method_name: ::String).returns(T::Boolean) }
+  def struct_method?(constant, method_name); end
+end
+
+# source://tapioca/lib/tapioca/gem/listeners/mixins.rb#7
+class Tapioca::Gem::Listeners::Mixins < ::Tapioca::Gem::Listeners::Base
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+
+  private
+
+  # source://tapioca/lib/tapioca/gem/listeners/mixins.rb#42
+  sig do
+    params(
+      tree: ::RBI::Tree,
+      constant: ::Module,
+      mods: T::Array[::Module],
+      mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type
+    ).void
+  end
+  def add_mixins(tree, constant, mods, mixin_type); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/mixins.rb#84
+  sig { params(mixin_name: ::String).returns(T::Boolean) }
+  def filtered_mixin?(mixin_name); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/mixins.rb#91
+  sig { params(constant: ::Module).returns(T::Array[::Module]) }
+  def interesting_ancestors_of(constant); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/mixins.rb#75
+  sig do
+    params(
+      constant: ::Module,
+      mixin: ::Module,
+      mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type
+    ).returns(T::Boolean)
+  end
+  def mixed_in_by_gem?(constant, mixin, mixin_type); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/mixins.rb#15
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca/lib/tapioca/gem/listeners/remove_empty_payload_scopes.rb#7
+class Tapioca::Gem::Listeners::RemoveEmptyPayloadScopes < ::Tapioca::Gem::Listeners::Base
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+
+  private
+
+  # source://tapioca/lib/tapioca/gem/listeners/remove_empty_payload_scopes.rb#20
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/remove_empty_payload_scopes.rb#15
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca/lib/tapioca/gem/listeners/sorbet_enums.rb#7
+class Tapioca::Gem::Listeners::SorbetEnums < ::Tapioca::Gem::Listeners::Base
+  private
+
+  # source://tapioca/lib/tapioca/gem/listeners/sorbet_enums.rb#28
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/sorbet_enums.rb#13
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca/lib/tapioca/gem/listeners/sorbet_helpers.rb#7
+class Tapioca::Gem::Listeners::SorbetHelpers < ::Tapioca::Gem::Listeners::Base
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+
+  private
+
+  # source://tapioca/lib/tapioca/gem/listeners/sorbet_helpers.rb#27
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/sorbet_helpers.rb#15
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca/lib/tapioca/gem/listeners/sorbet_props.rb#7
+class Tapioca::Gem::Listeners::SorbetProps < ::Tapioca::Gem::Listeners::Base
+  include ::Tapioca::SorbetHelper
+  include ::Tapioca::RBIHelper
+
+  private
+
+  # source://tapioca/lib/tapioca/gem/listeners/sorbet_props.rb#33
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/sorbet_props.rb#14
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca/lib/tapioca/gem/listeners/sorbet_required_ancestors.rb#7
+class Tapioca::Gem::Listeners::SorbetRequiredAncestors < ::Tapioca::Gem::Listeners::Base
+  private
+
+  # source://tapioca/lib/tapioca/gem/listeners/sorbet_required_ancestors.rb#23
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/sorbet_required_ancestors.rb#13
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca/lib/tapioca/gem/listeners/sorbet_signatures.rb#7
+class Tapioca::Gem::Listeners::SorbetSignatures < ::Tapioca::Gem::Listeners::Base
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+  include ::Tapioca::SorbetHelper
+  include ::Tapioca::RBIHelper
+
+  private
+
+  # source://tapioca/lib/tapioca/gem/listeners/sorbet_signatures.rb#26
+  sig { params(signature: T.untyped, parameters: T::Array[[::Symbol, ::String]]).returns(::RBI::Sig) }
+  def compile_signature(signature, parameters); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/sorbet_signatures.rb#79
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/sorbet_signatures.rb#18
+  sig { override.params(event: ::Tapioca::Gem::MethodNodeAdded).void }
+  def on_method(event); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/sorbet_signatures.rb#68
+  sig { params(signature: T.untyped).returns(T::Boolean) }
+  def signature_final?(signature); end
+end
+
+# source://tapioca/lib/tapioca/gem/listeners/sorbet_signatures.rb#13
+Tapioca::Gem::Listeners::SorbetSignatures::TYPE_PARAMETER_MATCHER = T.let(T.unsafe(nil), Regexp)
+
+# source://tapioca/lib/tapioca/gem/listeners/sorbet_type_variables.rb#7
+class Tapioca::Gem::Listeners::SorbetTypeVariables < ::Tapioca::Gem::Listeners::Base
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+
+  private
+
+  # source://tapioca/lib/tapioca/gem/listeners/sorbet_type_variables.rb#27
+  sig { params(tree: ::RBI::Tree, constant: ::Module).void }
+  def compile_type_variable_declarations(tree, constant); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/sorbet_type_variables.rb#63
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/sorbet_type_variables.rb#50
+  sig { params(type_variable: ::Tapioca::TypeVariableModule).returns(T.nilable(::RBI::Node)) }
+  def node_from_type_variable(type_variable); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/sorbet_type_variables.rb#15
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca/lib/tapioca/gem/listeners/source_location.rb#7
+class Tapioca::Gem::Listeners::SourceLocation < ::Tapioca::Gem::Listeners::Base
+  private
+
+  # source://tapioca/lib/tapioca/gem/listeners/source_location.rb#41
+  sig { params(node: ::RBI::NodeWithComments, file: T.nilable(::String), line: T.nilable(::Integer)).void }
+  def add_source_location_comment(node, file, line); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/source_location.rb#13
+  sig { override.params(event: ::Tapioca::Gem::ConstNodeAdded).void }
+  def on_const(event); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/source_location.rb#35
+  sig { override.params(event: ::Tapioca::Gem::MethodNodeAdded).void }
+  def on_method(event); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/source_location.rb#19
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca/lib/tapioca/gem/listeners/subconstants.rb#7
+class Tapioca::Gem::Listeners::Subconstants < ::Tapioca::Gem::Listeners::Base
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+
+  private
+
+  # source://tapioca/lib/tapioca/gem/listeners/subconstants.rb#36
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/subconstants.rb#15
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca/lib/tapioca/gem/listeners/yard_doc.rb#7
+class Tapioca::Gem::Listeners::YardDoc < ::Tapioca::Gem::Listeners::Base
+  # source://tapioca/lib/tapioca/gem/listeners/yard_doc.rb#27
+  sig { params(pipeline: ::Tapioca::Gem::Pipeline).void }
+  def initialize(pipeline); end
+
+  private
+
+  # source://tapioca/lib/tapioca/gem/listeners/yard_doc.rb#55
+  sig { params(name: ::String, sigs: T::Array[::RBI::Sig]).returns(T::Array[::RBI::Comment]) }
+  def documentation_comments(name, sigs: T.unsafe(nil)); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/yard_doc.rb#99
+  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
+  def ignore?(event); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/yard_doc.rb#36
+  sig { override.params(event: ::Tapioca::Gem::ConstNodeAdded).void }
+  def on_const(event); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/yard_doc.rb#46
+  sig { override.params(event: ::Tapioca::Gem::MethodNodeAdded).void }
+  def on_method(event); end
+
+  # source://tapioca/lib/tapioca/gem/listeners/yard_doc.rb#41
+  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
+  def on_scope(event); end
+end
+
+# source://tapioca/lib/tapioca/gem/listeners/yard_doc.rb#10
+Tapioca::Gem::Listeners::YardDoc::IGNORED_COMMENTS = T.let(T.unsafe(nil), Array)
+
+# source://tapioca/lib/tapioca/gem/listeners/yard_doc.rb#24
+Tapioca::Gem::Listeners::YardDoc::IGNORED_SIG_TAGS = T.let(T.unsafe(nil), Array)
+
+# source://tapioca/lib/tapioca/gem/events.rb#105
+class Tapioca::Gem::MethodNodeAdded < ::Tapioca::Gem::NodeAdded
+  # source://tapioca/lib/tapioca/gem/events.rb#130
+  sig do
+    params(
+      symbol: ::String,
+      constant: ::Module,
+      method: ::UnboundMethod,
+      node: ::RBI::Method,
+      signature: T.untyped,
+      parameters: T::Array[[::Symbol, ::String]]
+    ).void
+  end
+  def initialize(symbol, constant, method, node, signature, parameters); end
+
+  # source://tapioca/lib/tapioca/gem/events.rb#109
+  sig { returns(::UnboundMethod) }
+  def method; end
+
+  # source://tapioca/lib/tapioca/gem/events.rb#112
+  sig { returns(::RBI::Method) }
+  def node; end
+
+  # source://tapioca/lib/tapioca/gem/events.rb#118
+  sig { returns(T::Array[[::Symbol, ::String]]) }
+  def parameters; end
+
+  # source://tapioca/lib/tapioca/gem/events.rb#115
+  sig { returns(T.untyped) }
+  def signature; end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://tapioca/lib/tapioca/gem/events.rb#57
+class Tapioca::Gem::NodeAdded < ::Tapioca::Gem::Event
+  abstract!
+
+  # source://tapioca/lib/tapioca/gem/events.rb#70
+  sig { params(symbol: ::String, constant: ::Module).void }
+  def initialize(symbol, constant); end
+
+  # source://tapioca/lib/tapioca/gem/events.rb#67
+  sig { returns(::Module) }
+  def constant; end
+
+  # source://tapioca/lib/tapioca/gem/events.rb#64
+  sig { returns(::String) }
+  def symbol; end
+end
+
+# source://tapioca/lib/tapioca/gem/pipeline.rb#6
+class Tapioca::Gem::Pipeline
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+  include ::Tapioca::SorbetHelper
+  include ::Tapioca::RBIHelper
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#27
+  sig do
+    params(
+      gem: ::Tapioca::Gemfile::GemSpec,
+      error_handler: T.proc.params(error: ::String).void,
+      include_doc: T::Boolean,
+      include_loc: T::Boolean
+    ).void
+  end
+  def initialize(gem, error_handler:, include_doc: T.unsafe(nil), include_loc: T.unsafe(nil)); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#64
+  sig { returns(::RBI::Tree) }
+  def compile; end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#135
+  sig { params(name: T.any(::String, ::Symbol)).returns(T::Boolean) }
+  def constant_in_gem?(name); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#17
+  sig { returns(T.proc.params(error: ::String).void) }
+  def error_handler; end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#14
+  sig { returns(::Tapioca::Gemfile::GemSpec) }
+  def gem; end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#153
+  sig { params(method: ::UnboundMethod).returns(T::Boolean) }
+  def method_in_gem?(method); end
+
+  # Helpers
+  #
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#163
+  sig { params(constant: ::Module).returns(T.nilable(::String)) }
+  def name_of(constant); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#87
+  sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Const).void }
+  def push_const(symbol, constant, node); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#77
+  sig { params(symbol: ::String, constant: ::BasicObject).void }
+  def push_constant(symbol, constant); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#82
+  sig { params(symbol: ::String, constant: ::Module).void }
+  def push_foreign_constant(symbol, constant); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#101
+  sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Scope).void }
+  def push_foreign_scope(symbol, constant, node); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#115
+  sig do
+    params(
+      symbol: ::String,
+      constant: ::Module,
+      method: ::UnboundMethod,
+      node: ::RBI::Method,
+      signature: T.untyped,
+      parameters: T::Array[[::Symbol, ::String]]
+    ).void
+  end
+  def push_method(symbol, constant, method, node, signature, parameters); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#94
+  sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Scope).void }
+  def push_scope(symbol, constant, node); end
+
+  # Events handling
+  #
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#72
+  sig { params(symbol: ::String).void }
+  def push_symbol(symbol); end
+
+  # Constants and properties filtering
+  #
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#122
+  sig { params(symbol_name: ::String).returns(T::Boolean) }
+  def symbol_in_payload?(symbol_name); end
+
+  private
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#456
+  sig { params(name: ::String).void }
+  def add_to_alias_namespace(name); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#461
+  sig { params(name: ::String).returns(T::Boolean) }
+  def alias_namespaced?(name); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#260
+  sig { params(name: ::String, constant: ::Module).void }
+  def compile_alias(name, constant); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#246
+  sig { params(symbol: ::String, constant: ::BasicObject).void }
+  def compile_constant(symbol, constant); end
+
+  # Compiling
+  #
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#235
+  sig { params(symbol: ::String, constant: ::Module).void }
+  def compile_foreign_constant(symbol, constant); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#314
+  sig { params(name: ::String, constant: ::Module).void }
+  def compile_module(name, constant); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#281
+  sig { params(name: ::String, value: ::BasicObject).void }
+  def compile_object(name, value); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#325
+  sig { params(name: ::String, constant: ::Module).returns(::RBI::Scope) }
+  def compile_scope(name, constant); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#339
+  sig { params(constant: T::Class[T.anything]).returns(T.nilable(::String)) }
+  def compile_superclass(constant); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#437
+  sig { params(constant: ::Module, strict: T::Boolean).returns(T::Boolean) }
+  def defined_in_gem?(constant, strict: T.unsafe(nil)); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#193
+  sig { params(event: ::Tapioca::Gem::Event).void }
+  def dispatch(event); end
+
+  # Helpers
+  #
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#480
+  sig { params(constant: T.all(::Module, ::T::Generic)).returns(::String) }
+  def generic_name_of(constant); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#449
+  sig { params(constant: ::Module).returns(T::Set[::String]) }
+  def get_file_candidates(constant); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#178
+  sig { params(gem: ::Tapioca::Gemfile::GemSpec).returns(T::Set[::String]) }
+  def load_bootstrap_symbols(gem); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#496
+  sig { params(constant: ::Module, class_name: T.nilable(::String)).returns(T.nilable(::String)) }
+  def name_of_proxy_target(constant, class_name); end
+
+  # Events handling
+  #
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#188
+  sig { returns(::Tapioca::Gem::Event) }
+  def next_event; end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#216
+  sig { params(event: ::Tapioca::Gem::ConstantFound).void }
+  def on_constant(event); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#228
+  sig { params(event: ::Tapioca::Gem::NodeAdded).void }
+  def on_node(event); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#207
+  sig { params(event: ::Tapioca::Gem::SymbolFound).void }
+  def on_symbol(event); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#468
+  sig { params(name: ::String).void }
+  def seen!(name); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#473
+  sig { params(name: ::String).returns(T::Boolean) }
+  def seen?(name); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#407
+  sig { params(name: ::String, constant: ::Module).returns(T::Boolean) }
+  def skip_alias?(name, constant); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#395
+  sig { params(name: ::String, constant: T.anything).returns(T::Boolean) }
+  def skip_constant?(name, constant); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#424
+  sig { params(name: ::String, constant: ::Module).returns(T::Boolean) }
+  def skip_foreign_constant?(name, constant); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#429
+  sig { params(name: ::String, constant: ::Module).returns(T::Boolean) }
+  def skip_module?(name, constant); end
+
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#416
+  sig { params(name: ::String, constant: ::BasicObject).returns(T::Boolean) }
+  def skip_object?(name, constant); end
+
+  # Constants and properties filtering
+  #
+  # source://tapioca/lib/tapioca/gem/pipeline.rb#390
+  sig { params(name: ::String).returns(T::Boolean) }
+  def skip_symbol?(name); end
+end
+
+# this looks something like:
+# "(eval at /path/to/file.rb:123)"
+# and we are just interested in the "/path/to/file.rb" part
+#
+# source://tapioca/lib/tapioca/gem/pipeline.rb#132
+Tapioca::Gem::Pipeline::EVAL_SOURCE_FILE_PATTERN = T.let(T.unsafe(nil), Regexp)
+
+# source://tapioca/lib/tapioca/gem/pipeline.rb#11
+Tapioca::Gem::Pipeline::IGNORED_SYMBOLS = T.let(T.unsafe(nil), Array)
+
+# source://tapioca/lib/tapioca/gem/events.rb#90
+class Tapioca::Gem::ScopeNodeAdded < ::Tapioca::Gem::NodeAdded
+  # source://tapioca/lib/tapioca/gem/events.rb#97
+  sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Scope).void }
+  def initialize(symbol, constant, node); end
+
+  # source://tapioca/lib/tapioca/gem/events.rb#94
+  sig { returns(::RBI::Scope) }
+  def node; end
+end
+
+# source://tapioca/lib/tapioca/gem/events.rb#13
+class Tapioca::Gem::SymbolFound < ::Tapioca::Gem::Event
+  # source://tapioca/lib/tapioca/gem/events.rb#20
+  sig { params(symbol: ::String).void }
+  def initialize(symbol); end
+
+  # source://tapioca/lib/tapioca/gem/events.rb#17
+  sig { returns(::String) }
+  def symbol; end
+end
+
+# source://tapioca/lib/tapioca/helpers/gem_helper.rb#5
+module Tapioca::GemHelper
+  # source://tapioca/lib/tapioca/helpers/gem_helper.rb#9
+  sig { params(app_dir: T.any(::Pathname, ::String), full_gem_path: ::String).returns(T::Boolean) }
+  def gem_in_app_dir?(app_dir, full_gem_path); end
+
+  # source://tapioca/lib/tapioca/helpers/gem_helper.rb#17
+  sig { params(full_gem_path: ::String).returns(T::Boolean) }
+  def gem_in_bundle_path?(full_gem_path); end
+
+  # source://tapioca/lib/tapioca/helpers/gem_helper.rb#22
+  sig { params(full_gem_path: ::String).returns(T::Boolean) }
+  def gem_in_ruby_path?(full_gem_path); end
+
+  # source://tapioca/lib/tapioca/helpers/gem_helper.rb#27
+  sig { params(path: T.any(::Pathname, ::String)).returns(::String) }
+  def to_realpath(path); end
+
+  private
+
+  # source://tapioca/lib/tapioca/helpers/gem_helper.rb#36
+  sig { params(path: T.any(::Pathname, ::String), dir: T.any(::Pathname, ::String)).returns(T::Boolean) }
+  def path_in_dir?(path, dir); end
+end
+
+# source://tapioca/lib/tapioca/gem_info.rb#5
+class Tapioca::GemInfo < ::T::Struct
+  const :name, ::String
+  const :version, ::Gem::Version
+
+  class << self
+    # source://tapioca/lib/tapioca/gem_info.rb#13
+    sig { params(spec: ::Bundler::LazySpecification).returns(::Tapioca::GemInfo) }
+    def from_spec(spec); end
+
+<<<<<<<< HEAD:sorbet/rbi/gems/tapioca@0.16.8.rbi
+    # source://sorbet-runtime/0.5.11761lib/types/struct.rb#13
+|||||||| parent of 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.5.rbi
+    # source://sorbet-runtime/0.5.11635lib/types/struct.rb#13
+========
+    # source://sorbet-runtime/0.5.11725lib/types/struct.rb#13
+>>>>>>>> 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.6.rbi
+    def inherited(s); end
+  end
+end
+
+# source://tapioca/lib/tapioca/gemfile.rb#7
+class Tapioca::Gemfile
+  # source://tapioca/lib/tapioca/gemfile.rb#27
+  sig { params(excluded_gems: T::Array[::String]).void }
+  def initialize(excluded_gems); end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#18
+  sig { returns(::Bundler::Definition) }
+  def definition; end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#21
+  sig { returns(T::Array[::Tapioca::Gemfile::GemSpec]) }
+  def dependencies; end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#40
+  sig { params(gem_name: ::String).returns(T.nilable(::Tapioca::Gemfile::GemSpec)) }
+  def gem(gem_name); end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#24
+  sig { returns(T::Array[::String]) }
+  def missing_specs; end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#45
+  sig { void }
+  def require_bundle; end
+
+  private
+
+  # source://tapioca/lib/tapioca/gemfile.rb#101
+  sig { returns(::String) }
+  def dir; end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#54
+  sig { returns(::File) }
+  def gemfile; end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#96
+  sig { returns(T::Array[::Symbol]) }
+  def groups; end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#57
+  sig { returns([T::Array[::Tapioca::Gemfile::GemSpec], T::Array[::String]]) }
+  def load_dependencies; end
+
+  # @return [File]
+  #
+  # source://tapioca/lib/tapioca/gemfile.rb#54
+  def lockfile; end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#68
+  sig { returns([T::Enumerable[T.any(::Bundler::StubSpecification, ::Gem::Specification)], T::Array[::String]]) }
+  def materialize_deps; end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#91
+  sig { returns(::Bundler::Runtime) }
+  def runtime; end
+end
+
+# source://tapioca/lib/tapioca/gemfile.rb#105
+class Tapioca::Gemfile::GemSpec
+  include ::Tapioca::GemHelper
+
+  # source://tapioca/lib/tapioca/gemfile.rb#145
+  sig { params(spec: T.any(::Bundler::StubSpecification, ::Gem::Specification)).void }
+  def initialize(spec); end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#155
+  sig { params(other: ::BasicObject).returns(T::Boolean) }
+  def ==(other); end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#180
+  sig { params(path: ::String).returns(T::Boolean) }
+  def contains_path?(path); end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#170
+  sig { returns(T::Array[::Gem::Dependency]) }
+  def dependencies; end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#210
+  sig { returns(T::Boolean) }
+  def export_rbi_files?; end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#205
+  sig { returns(T::Array[::String]) }
+  def exported_rbi_files; end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#215
+  sig { returns(::RBI::MergeTree) }
+  def exported_rbi_tree; end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#142
+  sig { returns(T::Array[::Pathname]) }
+  def files; end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#139
+  sig { returns(::String) }
+  def full_gem_path; end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#160
+  sig { params(gemfile_dir: ::String).returns(T::Boolean) }
+  def ignore?(gemfile_dir); end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#165
+  sig { returns(::String) }
+  def name; end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#189
+  sig { void }
+  def parse_yard_docs; end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#175
+  sig { returns(::String) }
+  def rbi_file_name; end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#227
+  sig { params(file: ::Pathname).returns(::Pathname) }
+  def relative_path_for(file); end
+
+  # @return [String]
+  #
+  # source://tapioca/lib/tapioca/gemfile.rb#139
+  def version; end
+
+  private
+
+  # source://tapioca/lib/tapioca/gemfile.rb#238
+  sig { returns(T::Array[::Pathname]) }
+  def collect_files; end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#253
+  sig { returns(T.nilable(T::Boolean)) }
+  def default_gem?; end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#312
+  sig { returns(T::Boolean) }
+  def gem_ignored?; end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#291
+  sig { params(path: ::String).returns(T::Boolean) }
+  def has_parent_gemspec?(path); end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#258
+  sig { returns(::Regexp) }
+  def require_paths_prefix_matcher; end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#270
+  sig { params(file: ::String).returns(::Pathname) }
+  def resolve_to_ruby_lib_dir(file); end
+
+  # source://tapioca/lib/tapioca/gemfile.rb#284
+  sig { returns(::String) }
+  def version_string; end
+
+  class << self
+    # source://tapioca/lib/tapioca/gemfile.rb#113
+    sig { returns(T::Hash[::String, ::Tapioca::Gemfile::GemSpec]) }
+    def spec_lookup_by_file_path; end
+  end
+end
+
+# source://tapioca/lib/tapioca/gemfile.rb#125
+Tapioca::Gemfile::GemSpec::IGNORED_GEMS = T.let(T.unsafe(nil), Array)
+
+# source://tapioca/lib/tapioca/gemfile.rb#10
+Tapioca::Gemfile::Spec = T.type_alias { T.any(::Bundler::StubSpecification, ::Gem::Specification) }
+
+# source://tapioca/lib/tapioca.rb#33
+Tapioca::LIB_ROOT_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca/lib/tapioca/loaders/loader.rb#5
+module Tapioca::Loaders; end
+
+# source://tapioca/lib/tapioca/loaders/dsl.rb#6
+class Tapioca::Loaders::Dsl < ::Tapioca::Loaders::Loader
+  # source://tapioca/lib/tapioca/loaders/dsl.rb#53
+  sig do
+    params(
+      tapioca_path: ::String,
+      eager_load: T::Boolean,
+      app_root: ::String,
+      halt_upon_load_error: T::Boolean
+    ).void
+  end
+  def initialize(tapioca_path:, eager_load: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil)); end
+
+  # source://tapioca/lib/tapioca/loaders/dsl.rb#36
+  sig { override.void }
+  def load; end
+
+  # source://tapioca/lib/tapioca/loaders/dsl.rb#43
+  sig { void }
+  def load_dsl_extensions_and_compilers; end
+
+  protected
+
+<<<<<<<< HEAD:sorbet/rbi/gems/tapioca@0.16.8.rbi
+  # source://tapioca/lib/tapioca/loaders/dsl.rb#103
+|||||||| parent of 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.5.rbi
+  # source://tapioca/lib/tapioca/loaders/dsl.rb#105
+========
+  # source://tapioca/lib/tapioca/loaders/dsl.rb#110
+>>>>>>>> 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.6.rbi
+  sig { void }
+  def load_application; end
+
+  # source://tapioca/lib/tapioca/loaders/dsl.rb#78
+  sig { void }
+  def load_dsl_compilers; end
+
+  # source://tapioca/lib/tapioca/loaders/dsl.rb#63
+  sig { void }
+  def load_dsl_extensions; end
+
+  class << self
+    # source://tapioca/lib/tapioca/loaders/dsl.rb#20
+    sig do
+      params(
+        tapioca_path: ::String,
+        eager_load: T::Boolean,
+        app_root: ::String,
+        halt_upon_load_error: T::Boolean
+      ).void
+    end
+    def load_application(tapioca_path:, eager_load: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil)); end
+  end
+end
+
+# source://tapioca/lib/tapioca/loaders/gem.rb#6
+class Tapioca::Loaders::Gem < ::Tapioca::Loaders::Loader
+  # source://tapioca/lib/tapioca/loaders/gem.rb#49
+  sig do
+    params(
+      bundle: ::Tapioca::Gemfile,
+      prerequire: T.nilable(::String),
+      postrequire: ::String,
+      default_command: ::String,
+      halt_upon_load_error: T::Boolean
+    ).void
+  end
+  def initialize(bundle:, prerequire:, postrequire:, default_command:, halt_upon_load_error:); end
+
+  # source://tapioca/lib/tapioca/loaders/gem.rb#34
+  sig { override.void }
+  def load; end
+
+  protected
+
+  # source://tapioca/lib/tapioca/loaders/gem.rb#80
+  sig { params(file: ::String, error: ::LoadError).void }
+  def explain_failed_require(file, error); end
+
+  # source://tapioca/lib/tapioca/loaders/gem.rb#60
+  sig { void }
+  def require_gem_file; end
+
+  class << self
+    # source://tapioca/lib/tapioca/loaders/gem.rb#21
+    sig do
+      params(
+        bundle: ::Tapioca::Gemfile,
+        prerequire: T.nilable(::String),
+        postrequire: ::String,
+        default_command: ::String,
+        halt_upon_load_error: T::Boolean
+      ).void
+    end
+    def load_application(bundle:, prerequire:, postrequire:, default_command:, halt_upon_load_error:); end
+  end
+end
+
+# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
+#
+# source://tapioca/lib/tapioca/loaders/loader.rb#6
+class Tapioca::Loaders::Loader
+  include ::Thor::Base
+  include ::Thor::Invocation
+  include ::Thor::Shell
+  include ::Tapioca::CliHelper
+  include ::Tapioca::GemHelper
+  extend ::Thor::Base::ClassMethods
+  extend ::Thor::Invocation::ClassMethods
+
+  abstract!
+
+  # @abstract
+  #
+  # source://tapioca/lib/tapioca/loaders/loader.rb#17
+  sig { abstract.void }
+  def load; end
+
+  private
+
+  # Rails 7.2 renamed `eager_load_paths` to `all_eager_load_paths`, which maintains the same original functionality.
+  # The `eager_load_paths` method still exists, but doesn't return all paths anymore and causes Tapioca to miss some
+  # engine paths. The following commit is the change:
+  # https://github.com/rails/rails/commit/ebfca905db14020589c22e6937382e6f8f687664
+  #
+  # @param engine [T.class_of(Rails::Engine)]
+  # @return [Array<String>]
+  #
+  # source://tapioca/lib/tapioca/loaders/loader.rb#234
+  def eager_load_paths(engine); end
+
+  # source://tapioca/lib/tapioca/loaders/loader.rb#199
+  sig { void }
+  def eager_load_rails_app; end
+
+  # @return [Array<T.class_of(Rails::Engine)>]
+  #
+  # source://tapioca/lib/tapioca/loaders/loader.rb#178
+  def engines; end
+
+  # source://tapioca/lib/tapioca/loaders/loader.rb#29
+  sig do
+    params(
+      gemfile: ::Tapioca::Gemfile,
+      initialize_file: T.nilable(::String),
+      require_file: T.nilable(::String),
+      halt_upon_load_error: T::Boolean
+    ).void
+  end
+  def load_bundle(gemfile, initialize_file, require_file, halt_upon_load_error); end
+
+  # source://tapioca/lib/tapioca/loaders/loader.rb#136
+  sig { void }
+  def load_engines_in_classic_mode; end
+
+  # source://tapioca/lib/tapioca/loaders/loader.rb#114
+  sig { void }
+  def load_engines_in_zeitwerk_mode; end
+
+  # source://tapioca/lib/tapioca/loaders/loader.rb#49
+  sig do
+    params(
+      environment_load: T::Boolean,
+      eager_load: T::Boolean,
+      app_root: ::String,
+      halt_upon_load_error: T::Boolean
+    ).void
+  end
+  def load_rails_application(environment_load: T.unsafe(nil), eager_load: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil)); end
+
+  # source://tapioca/lib/tapioca/loaders/loader.rb#89
+  sig { void }
+  def load_rails_engines; end
+
+  # source://tapioca/lib/tapioca/loaders/loader.rb#220
+  sig { params(file: T.nilable(::String)).void }
+  def require_helper(file); end
+
+  # source://tapioca/lib/tapioca/loaders/loader.rb#103
+  def run_initializers; end
+
+  # source://tapioca/lib/tapioca/loaders/loader.rb#192
+  sig { params(path: ::String).void }
+  def safe_require(path); end
+
+  # source://tapioca/lib/tapioca/loaders/loader.rb#161
+  sig { params(blk: T.proc.void).void }
+  def with_rails_application(&blk); end
+
+  # source://tapioca/lib/tapioca/loaders/loader.rb#154
+  sig { returns(T::Boolean) }
+  def zeitwerk_mode?; end
+end
+
+# source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#5
+module Tapioca::RBIFilesHelper
+  requires_ancestor { Tapioca::SorbetHelper }
+  requires_ancestor { Thor::Shell }
+
+  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#48
+  sig do
+    params(
+      index: ::RBI::Index,
+      shim_rbi_dir: ::String,
+      todo_rbi_file: ::String
+    ).returns(T::Hash[::String, T::Array[::RBI::Node]])
+  end
+  def duplicated_nodes_from_index(index, shim_rbi_dir:, todo_rbi_file:); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#13
+  sig { params(index: ::RBI::Index, kind: ::String, file: ::String).void }
+  def index_rbi(index, kind, file); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#25
+  sig { params(index: ::RBI::Index, kind: ::String, dir: ::String, number_of_workers: T.nilable(::Integer)).void }
+  def index_rbis(index, kind, dir, number_of_workers:); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#65
+  sig { params(loc: ::RBI::Loc, path_prefix: T.nilable(::String)).returns(::String) }
+  def location_to_payload_url(loc, path_prefix:); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#86
+  sig do
+    params(
+      command: ::String,
+      gem_dir: ::String,
+      dsl_dir: ::String,
+      auto_strictness: T::Boolean,
+      gems: T::Array[::Tapioca::Gemfile::GemSpec],
+      compilers: T::Enumerable[T.class_of(Tapioca::Dsl::Compiler)]
+    ).void
+  end
+  def validate_rbi_files(command:, gem_dir:, dsl_dir:, auto_strictness:, gems: T.unsafe(nil), compilers: T.unsafe(nil)); end
+
+  private
+
+  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#223
+  sig { params(nodes: T::Array[::RBI::Node]).returns(T::Array[::RBI::Scope]) }
+  def extract_empty_scopes(nodes); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#228
+  sig { params(nodes: T::Array[::RBI::Node]).returns(T::Array[T.any(::RBI::Attr, ::RBI::Method)]) }
+  def extract_methods_and_attrs(nodes); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#238
+  sig { params(nodes: T::Array[::RBI::Node]).returns(T::Array[T.any(::RBI::Mixin, ::RBI::RequiresAncestor)]) }
+  def extract_mixins(nodes); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#248
+  sig do
+    params(
+      nodes: T::Array[T.any(::RBI::Attr, ::RBI::Method)]
+    ).returns(T::Array[T.any(::RBI::Attr, ::RBI::Method)])
+  end
+  def extract_nodes_with_sigs(nodes); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#216
+  sig do
+    params(
+      nodes: T::Array[::RBI::Node],
+      shim_rbi_dir: ::String,
+      todo_rbi_file: ::String
+    ).returns(T::Array[::RBI::Node])
+  end
+  def extract_shims_and_todos(nodes, shim_rbi_dir:, todo_rbi_file:); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#280
+  sig { params(path: ::String).returns(::String) }
+  def gem_name_from_rbi_path(path); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#155
+  sig { params(index: ::RBI::Index, files: T::Array[::String], number_of_workers: T.nilable(::Integer)).void }
+  def parse_and_index_files(index, files, number_of_workers:); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#171
+  sig { params(nodes: T::Array[::RBI::Node], shim_rbi_dir: ::String, todo_rbi_file: ::String).returns(T::Boolean) }
+  def shims_or_todos_have_duplicates?(nodes, shim_rbi_dir:, todo_rbi_file:); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#253
+  sig { params(errors: T::Array[::Spoom::Sorbet::Errors::Error], gem_dir: ::String).void }
+  def update_gem_rbis_strictnesses(errors, gem_dir); end
+end
+
+# source://tapioca/lib/tapioca/rbi_formatter.rb#5
+class Tapioca::RBIFormatter < ::RBI::Formatter
+  # source://tapioca/lib/tapioca/rbi_formatter.rb#24
+  sig { params(file: ::RBI::File).void }
+  def write_empty_body_comment!(file); end
+
+  # source://tapioca/lib/tapioca/rbi_formatter.rb#15
+  sig { params(file: ::RBI::File, command: ::String, reason: T.nilable(::String)).void }
+  def write_header!(file, command, reason: T.unsafe(nil)); end
+end
+
+# source://tapioca/lib/tapioca/helpers/rbi_helper.rb#5
+module Tapioca::RBIHelper
+  include ::Tapioca::SorbetHelper
+  extend ::Tapioca::SorbetHelper
+  extend ::Tapioca::RBIHelper
+
+  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#91
+  sig { params(type: ::String).returns(::String) }
+  def as_nilable_type(type); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#100
+  sig { params(type: ::String).returns(::String) }
+  def as_non_nilable_type(type); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#72
+  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
+  def create_block_param(name, type:); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#62
+  sig { params(name: ::String, type: ::String, default: ::String).returns(::RBI::TypedParam) }
+  def create_kw_opt_param(name, type:, default:); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#57
+  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
+  def create_kw_param(name, type:); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#67
+  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
+  def create_kw_rest_param(name, type:); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#47
+  sig { params(name: ::String, type: ::String, default: ::String).returns(::RBI::TypedParam) }
+  def create_opt_param(name, type:, default:); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#42
+  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
+  def create_param(name, type:); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#52
+  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
+  def create_rest_param(name, type:); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#77
+  sig { params(param: ::RBI::Param, type: ::String).returns(::RBI::TypedParam) }
+  def create_typed_param(param, type); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#82
+  sig { params(sig_string: ::String).returns(::String) }
+  def sanitize_signature_types(sig_string); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#109
+  sig { params(name: ::String).returns(T::Boolean) }
+  def valid_method_name?(name); end
+
+  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#114
+  sig { params(name: ::String).returns(T::Boolean) }
+  def valid_parameter_name?(name); end
+
+  class << self
+    # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#23
+    sig do
+      params(
+        type: ::String,
+        variance: ::Symbol,
+        fixed: T.nilable(::String),
+        upper: T.nilable(::String),
+        lower: T.nilable(::String)
+      ).returns(::String)
+    end
+    def serialize_type_variable(type, variance, fixed, upper, lower); end
+  end
+end
+
+# source://tapioca/lib/tapioca/repo_index.rb#5
+class Tapioca::RepoIndex
+  # source://tapioca/lib/tapioca/repo_index.rb#26
+  sig { void }
+  def initialize; end
+
+  # source://tapioca/lib/tapioca/repo_index.rb#31
+  sig { params(gem_name: ::String).void }
+  def <<(gem_name); end
+
+  # source://tapioca/lib/tapioca/repo_index.rb#36
+  sig { returns(T::Enumerable[::String]) }
+  def gems; end
+
+  # source://tapioca/lib/tapioca/repo_index.rb#41
+  sig { params(gem_name: ::String).returns(T::Boolean) }
+  def has_gem?(gem_name); end
+
+  class << self
+    # source://tapioca/lib/tapioca/repo_index.rb#18
+    sig { params(hash: T::Hash[::String, T::Hash[T.untyped, T.untyped]]).returns(Tapioca::RepoIndex) }
+    def from_hash(hash); end
+
+    # source://tapioca/lib/tapioca/repo_index.rb#13
+    sig { params(json: ::String).returns(Tapioca::RepoIndex) }
+    def from_json(json); end
+  end
+end
+
+# source://tapioca/lib/tapioca/runtime/trackers/autoload.rb#5
+module Tapioca::Runtime; end
+
+# This module should only be included when running versions of Ruby
+# older than 3.2. Because the Class#attached_object method is not
+# available, it implements finding the attached class of a singleton
+# class by iterating through ObjectSpace.
+module Tapioca::Runtime::AttachedClassOf
+  # source://tapioca/lib/tapioca/runtime/attached_class_of_32.rb#14
+  sig { params(singleton_class: ::Class).returns(T.nilable(::Module)) }
+  def attached_class_of(singleton_class); end
+end
+
+# source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#6
+class Tapioca::Runtime::DynamicMixinCompiler
+  include ::Tapioca::Runtime::AttachedClassOf
+  include ::Tapioca::Runtime::Reflection
+
+  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#20
+  sig { params(constant: ::Module).void }
+  def initialize(constant); end
+
+  # @return [Array<Symbol>]
+  #
+  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#14
+  def class_attribute_predicates; end
+
+  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#14
+  sig { returns(T::Array[::Symbol]) }
+  def class_attribute_readers; end
+
+  # @return [Array<Symbol>]
+  #
+  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#14
+  def class_attribute_writers; end
+
+  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#137
+  sig { params(tree: ::RBI::Tree).void }
+  def compile_class_attributes(tree); end
+
+  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#180
+  sig { params(tree: ::RBI::Tree).returns([T::Array[::Module], T::Array[::Module]]) }
+  def compile_mixes_in_class_methods(tree); end
+
+  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#11
+  sig { returns(T::Array[::Module]) }
+  def dynamic_extends; end
+
+  # @return [Array<Module>]
+  #
+  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#11
+  def dynamic_includes; end
+
+  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#132
+  sig { returns(T::Boolean) }
+  def empty_attributes?; end
+
+  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#222
+  sig { params(qualified_mixin_name: ::String).returns(T::Boolean) }
+  def filtered_mixin?(qualified_mixin_name); end
+
+  # @return [Array<Symbol>]
+  #
+  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#17
+  def instance_attribute_predicates; end
+
+  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#17
+  sig { returns(T::Array[::Symbol]) }
+  def instance_attribute_readers; end
+
+  # @return [Array<Symbol>]
+  #
+  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#17
+  def instance_attribute_writers; end
+
+  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#215
+  sig { params(mod: ::Module, dynamic_extends: T::Array[::Module]).returns(T::Boolean) }
+  def module_included_by_another_dynamic_extend?(mod, dynamic_extends); end
+end
+
+# This class is responsible for storing and looking up information related to generic types.
+#
+# The class stores 2 different kinds of data, in two separate lookup tables:
+#   1. a lookup of generic type instances by name: `@generic_instances`
+#   2. a lookup of type variable serializer by constant and type variable
+#      instance: `@type_variables`
+#
+# By storing the above data, we can cheaply query each constant against this registry
+# to see if it declares any generic type variables. This becomes a simple lookup in the
+# `@type_variables` hash table with the given constant.
+#
+# If there is no entry, then we can cheaply know that we can skip generic type
+# information generation for this type.
+#
+# On the other hand, if we get a result, then the result will be a hash of type
+# variable to type variable serializers. This allows us to associate type variables
+# to the constant names that represent them, easily.
+#
+# source://tapioca/lib/tapioca/runtime/generic_type_registry.rb#23
+module Tapioca::Runtime::GenericTypeRegistry
+  class << self
+    # source://tapioca/lib/tapioca/runtime/generic_type_registry.rb#80
+    sig { params(instance: ::Object).returns(T::Boolean) }
+    def generic_type_instance?(instance); end
+
+    # source://tapioca/lib/tapioca/runtime/generic_type_registry.rb#85
+    sig { params(constant: ::Module).returns(T.nilable(T::Array[::Tapioca::TypeVariableModule])) }
+    def lookup_type_variables(constant); end
+
+    # This method is responsible for building the name of the instantiated concrete type
+    # and cloning the given constant so that we can return a type that is the same
+    # as the current type but is a different instance and has a different name method.
+    #
+    # We cache those cloned instances by their name in `@generic_instances`, so that
+    # we don't keep instantiating a new type every single time it is referenced.
+    # For example, `[Foo[Integer], Foo[Integer], Foo[Integer], Foo[String]]` will only
+    # result in 2 clones (1 for `Foo[Integer]` and another for `Foo[String]`) and
+    # 2 hash lookups (for the other two `Foo[Integer]`s).
+    #
+    # This method returns the created or cached clone of the constant.
+    #
+    # source://tapioca/lib/tapioca/runtime/generic_type_registry.rb#65
+    sig { params(constant: T.untyped, types: T.untyped).returns(::Module) }
+    def register_type(constant, types); end
+
+    # This method is called from intercepted calls to `type_member` and `type_template`.
+    # We get passed all the arguments to those methods, as well as the `T::Types::TypeVariable`
+    # instance generated by the Sorbet defined `type_member`/`type_template` call on `T::Generic`.
+    #
+    # This method creates a `String` with that data and stores it in the
+    # `@type_variables` lookup table, keyed by the `constant` and `type_variable`.
+    #
+    # Finally, the original `type_variable` is returned from this method, so that the caller
+    # can return it from the original methods as well.
+    #
+    # source://tapioca/lib/tapioca/runtime/generic_type_registry.rb#104
+    sig { params(constant: T.untyped, type_variable: ::Tapioca::TypeVariableModule).void }
+    def register_type_variable(constant, type_variable); end
+
+    private
+
+    # source://tapioca/lib/tapioca/runtime/generic_type_registry.rb#113
+    sig { params(constant: ::Module, name: ::String).returns(::Module) }
+    def create_generic_type(constant, name); end
+
+    # source://tapioca/lib/tapioca/runtime/generic_type_registry.rb#155
+    sig { params(constant: T::Class[T.anything]).returns(T::Class[T.anything]) }
+    def create_safe_subclass(constant); end
+
+    # source://tapioca/lib/tapioca/runtime/generic_type_registry.rb#182
+    sig { params(constant: ::Module).returns(T::Array[::Tapioca::TypeVariableModule]) }
+    def lookup_or_initialize_type_variables(constant); end
+  end
+end
+
+# source://tapioca/lib/tapioca/runtime/generic_type_registry.rb#34
+class Tapioca::Runtime::GenericTypeRegistry::GenericType < ::T::Types::Simple
+  # source://tapioca/lib/tapioca/runtime/generic_type_registry.rb#38
+  sig { params(raw_type: ::Module, underlying_type: ::Module).void }
+  def initialize(raw_type, underlying_type); end
+
+  # source://tapioca/lib/tapioca/runtime/generic_type_registry.rb#45
+  sig { override.params(obj: T.untyped).returns(T::Boolean) }
+  def valid?(obj); end
+end
+
+module Tapioca::Runtime::Reflection
+  include ::Tapioca::Runtime::AttachedClassOf
+  extend ::Tapioca::Runtime::AttachedClassOf
+  extend ::Tapioca::Runtime::Reflection
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#207
+  sig { params(constant: ::Module).returns(T.untyped) }
+  def abstract_type_of(constant); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#77
+  sig { params(constant: ::Module).returns(T::Array[::Module]) }
+  def ancestors_of(constant); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#92
+  sig { params(object: ::BasicObject, other: ::BasicObject).returns(T::Boolean) }
+  def are_equal?(object, other); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#56
+  sig { params(object: ::BasicObject).returns(T::Class[T.anything]) }
+  def class_of(object); end
+
+  # @param constant [BasicObject]
+  # @return [Boolean]
+  #
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#38
+  def constant_defined?(constant); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#49
+  sig { params(symbol: ::String, inherit: T::Boolean, namespace: ::Module).returns(::BasicObject) }
+  def constantize(symbol, inherit: T.unsafe(nil), namespace: T.unsafe(nil)); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#61
+  sig { params(constant: ::Module).returns(T::Array[::Symbol]) }
+  def constants_of(constant); end
+
+  # Returns an array with all classes that are < than the supplied class.
+  #
+  #   class C; end
+  #   descendants_of(C) # => []
+  #
+  #   class B < C; end
+  #   descendants_of(C) # => [B]
+  #
+  #   class A < B; end
+  #   descendants_of(C) # => [B, A]
+  #
+  #   class D < C; end
+  #   descendants_of(C) # => [B, A, D]
+  #
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#172
+  sig do
+    type_parameters(:U)
+      .params(
+        klass: T.all(T.type_parameter(:U), T::Class[T.anything])
+      ).returns(T::Array[T.type_parameter(:U)])
+  end
+  def descendants_of(klass); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#200
+  sig { params(constant: ::Module).returns(T::Set[::String]) }
+  def file_candidates_for(constant); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#213
+  sig { params(constant: ::Module).returns(T::Boolean) }
+  def final_module?(constant); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#112
+  sig { params(constant: ::Module).returns(T::Array[::Module]) }
+  def inherited_ancestors_of(constant); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#150
+  sig { params(constant: ::Module, method: ::Symbol).returns(::Method) }
+  def method_of(constant, method); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#66
+  sig { params(constant: ::Module).returns(T.nilable(::String)) }
+  def name_of(constant); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#145
+  sig { params(type: ::T::Types::Base).returns(::String) }
+  def name_of_type(type); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#87
+  sig { params(object: ::BasicObject).returns(::Integer) }
+  def object_id_of(object); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#107
+  sig { params(constant: ::Module).returns(T::Array[::Symbol]) }
+  def private_instance_methods_of(constant); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#102
+  sig { params(constant: ::Module).returns(T::Array[::Symbol]) }
+  def protected_instance_methods_of(constant); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#97
+  sig { params(constant: ::Module).returns(T::Array[::Symbol]) }
+  def public_instance_methods_of(constant); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#121
+  sig { params(constant: ::Module).returns(T.nilable(::String)) }
+  def qualified_name_of(constant); end
+
+  # Examines the call stack to identify the closest location where a "require" is performed
+  # by searching for the label "<top (required)>" or "block in <class:...>" in the
+  # case of an ActiveSupport.on_load hook. If none is found, it returns the location
+  # labeled "<main>", which is the original call site.
+  #
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#185
+  sig { params(locations: T.nilable(T::Array[::Thread::Backtrace::Location])).returns(::String) }
+  def resolve_loc(locations); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#218
+  sig { params(constant: ::Module).returns(T::Boolean) }
+  def sealed_module?(constant); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#138
+  sig { params(method: T.any(::Method, ::UnboundMethod)).returns(T.untyped) }
+  def signature_of(method); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#133
+  sig { params(method: T.any(::Method, ::UnboundMethod)).returns(T.untyped) }
+  def signature_of!(method); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#72
+  sig { params(constant: ::Module).returns(T::Class[T.anything]) }
+  def singleton_class_of(constant); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#82
+  sig { params(constant: T::Class[T.anything]).returns(T.nilable(T::Class[T.anything])) }
+  def superclass_of(constant); end
+
+  private
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#255
+  sig { params(parent: ::Module, name: ::String).returns(T.nilable(::Module)) }
+  def child_module_for_parent_with_name(parent, name); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#271
+  sig { params(name: ::String).returns(T::Boolean) }
+  def has_aliased_namespace?(name); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#266
+  sig { params(method: ::UnboundMethod).returns(T::Boolean) }
+  def method_defined_by_forwardable_module?(method); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#241
+  sig { params(constant: ::Module).returns(T::Array[::UnboundMethod]) }
+  def methods_for(constant); end
+
+  # source://tapioca/lib/tapioca/runtime/reflection.rb#225
+  sig { params(constant: ::Module).returns(T::Array[::UnboundMethod]) }
+  def relevant_methods_for(constant); end
+end
+
+# source://tapioca/lib/tapioca/runtime/reflection.rb#25
+Tapioca::Runtime::Reflection::ANCESTORS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca/lib/tapioca/runtime/reflection.rb#21
+Tapioca::Runtime::Reflection::CLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca/lib/tapioca/runtime/reflection.rb#22
+Tapioca::Runtime::Reflection::CONSTANTS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca/lib/tapioca/runtime/reflection.rb#28
+Tapioca::Runtime::Reflection::EQUAL_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca/lib/tapioca/runtime/reflection.rb#32
+Tapioca::Runtime::Reflection::METHOD_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca/lib/tapioca/runtime/reflection.rb#23
+Tapioca::Runtime::Reflection::NAME_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca/lib/tapioca/runtime/reflection.rb#27
+Tapioca::Runtime::Reflection::OBJECT_ID_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca/lib/tapioca/runtime/reflection.rb#31
+Tapioca::Runtime::Reflection::PRIVATE_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca/lib/tapioca/runtime/reflection.rb#30
+Tapioca::Runtime::Reflection::PROTECTED_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca/lib/tapioca/runtime/reflection.rb#29
+Tapioca::Runtime::Reflection::PUBLIC_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca/lib/tapioca/runtime/reflection.rb#35
+Tapioca::Runtime::Reflection::REQUIRED_FROM_LABELS = T.let(T.unsafe(nil), Array)
+
+# source://tapioca/lib/tapioca/runtime/reflection.rb#24
+Tapioca::Runtime::Reflection::SINGLETON_CLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca/lib/tapioca/runtime/reflection.rb#26
+Tapioca::Runtime::Reflection::SUPERCLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+# source://tapioca/lib/tapioca/runtime/trackers/autoload.rb#6
+module Tapioca::Runtime::Trackers
+  class << self
+    # source://tapioca/lib/tapioca/runtime/trackers.rb#34
+    sig { void }
+    def disable_all!; end
+
+    # source://tapioca/lib/tapioca/runtime/trackers.rb#39
+    sig { params(tracker: ::Tapioca::Runtime::Trackers::Tracker).void }
+    def register_tracker(tracker); end
+
+    # source://tapioca/lib/tapioca/runtime/trackers.rb#21
+    sig do
+      type_parameters(:Return)
+        .params(
+          blk: T.proc.returns(T.type_parameter(:Return))
+        ).returns(T.type_parameter(:Return))
+    end
+    def with_trackers_enabled(&blk); end
+  end
+end
+
+# source://tapioca/lib/tapioca/runtime/trackers/autoload.rb#7
+module Tapioca::Runtime::Trackers::Autoload
+  extend ::Tapioca::Runtime::Trackers::Tracker
+
+  class << self
+    # source://tapioca/lib/tapioca/runtime/trackers/autoload.rb#19
+    sig { void }
+    def eager_load_all!; end
+
+    # source://tapioca/lib/tapioca/runtime/trackers/autoload.rb#31
+    sig { params(constant_name: ::String).void }
+    def register(constant_name); end
+
+    # source://tapioca/lib/tapioca/runtime/trackers/autoload.rb#42
+    sig do
+      type_parameters(:Result)
+        .params(
+          block: T.proc.returns(T.type_parameter(:Result))
+        ).returns(T.type_parameter(:Result))
+    end
+    def with_disabled_exits(&block); end
+  end
+end
+
+# source://tapioca/lib/tapioca/runtime/trackers/autoload.rb#11
+Tapioca::Runtime::Trackers::Autoload::NOOP_METHOD = T.let(T.unsafe(nil), Proc)
+
+# Registers a TracePoint immediately upon load to track points at which
+# classes and modules are opened for definition. This is used to track
+# correspondence between classes/modules and files, as this information isn't
+# available in the ruby runtime without extra accounting.
+module Tapioca::Runtime::Trackers::ConstantDefinition
+  extend ::Tapioca::Runtime::Trackers::Tracker
+  extend ::Tapioca::Runtime::AttachedClassOf
+  extend ::Tapioca::Runtime::Reflection
+
+  class << self
+    # source://tapioca/lib/tapioca/runtime/trackers/constant_definition.rb#61
+    def build_constant_location(tp, locations); end
+
+    # source://tapioca/lib/tapioca/runtime/trackers/constant_definition.rb#55
+    def disable!; end
+
+    # Returns the files in which this class or module was opened. Doesn't know
+    # about situations where the class was opened prior to +require+ing,
+    # or where metaprogramming was used via +eval+, etc.
+    #
+    # source://tapioca/lib/tapioca/runtime/trackers/constant_definition.rb#71
+    def files_for(klass); end
+
+    # source://tapioca/lib/tapioca/runtime/trackers/constant_definition.rb#75
+    def locations_for(klass); end
+  end
+end
+
+module Tapioca::Runtime::Trackers::Mixin
+  extend ::Tapioca::Runtime::Trackers::Tracker
+
+  class << self
+    # source://tapioca/lib/tapioca/runtime/trackers/mixin.rb#56
+    sig do
+      params(
+        mixin: ::Module
+      ).returns(T::Hash[::Tapioca::Runtime::Trackers::Mixin::Type, T::Hash[::Module, ::String]])
+    end
+    def constants_with_mixin(mixin); end
+
+    # source://tapioca/lib/tapioca/runtime/trackers/mixin.rb#61
+    sig do
+      params(
+        mixin: ::Module,
+        mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type,
+        constant: ::Module
+      ).returns(T.nilable(::String))
+    end
+    def mixin_location(mixin, mixin_type, constant); end
+
+    # source://tapioca/lib/tapioca/runtime/trackers/mixin.rb#35
+    sig { params(constant: ::Module, mixin: ::Module, mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type).void }
+    def register(constant, mixin, mixin_type); end
+
+    # source://tapioca/lib/tapioca/runtime/trackers/mixin.rb#43
+    def resolve_to_attached_class(constant, mixin, mixin_type); end
+
+    # source://tapioca/lib/tapioca/runtime/trackers/mixin.rb#30
+    sig do
+      type_parameters(:Result)
+        .params(
+          block: T.proc.returns(T.type_parameter(:Result))
+        ).returns(T.type_parameter(:Result))
+    end
+    def with_disabled_registration(&block); end
+
+    private
+
+    # source://tapioca/lib/tapioca/runtime/trackers/mixin.rb#76
+    sig do
+      params(
+        mixin: ::Module
+      ).returns(T::Hash[::Tapioca::Runtime::Trackers::Mixin::Type, T::Hash[::Module, ::String]])
+    end
+    def find_or_initialize_mixin_lookup(mixin); end
+
+    # source://tapioca/lib/tapioca/runtime/trackers/mixin.rb#68
+    sig do
+      params(
+        constant: ::Module,
+        mixin: ::Module,
+        mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type,
+        location: ::String
+      ).void
+    end
+    def register_with_location(constant, mixin, mixin_type, location); end
+  end
+end
+
+class Tapioca::Runtime::Trackers::Mixin::Type < ::T::Enum
+  enums do
+    Extend = new
+    Include = new
+    Prepend = new
+  end
+end
+
+# source://tapioca/lib/tapioca/runtime/trackers/required_ancestor.rb#7
+module Tapioca::Runtime::Trackers::RequiredAncestor
+  extend ::Tapioca::Runtime::Trackers::Tracker
+
+  class << self
+    # source://tapioca/lib/tapioca/runtime/trackers/required_ancestor.rb#15
+    sig { params(requiring: ::T::Helpers, block: T.proc.void).void }
+    def register(requiring, block); end
+
+    # source://tapioca/lib/tapioca/runtime/trackers/required_ancestor.rb#23
+    sig { params(mod: ::Module).returns(T::Array[T.proc.void]) }
+    def required_ancestors_blocks_by(mod); end
+
+    # source://tapioca/lib/tapioca/runtime/trackers/required_ancestor.rb#28
+    sig { params(mod: ::Module).returns(T::Array[T.untyped]) }
+    def required_ancestors_by(mod); end
+  end
+end
+
+# @abstract Subclasses must implement the `abstract` methods below.
+module Tapioca::Runtime::Trackers::Tracker
+  abstract!
+
+  # source://tapioca/lib/tapioca/runtime/trackers/tracker.rb#26
+  sig { void }
+  def disable!; end
+
+  # @return [Boolean]
+  #
+  # source://tapioca/lib/tapioca/runtime/trackers/tracker.rb#30
+  def enabled?; end
+
+  # source://tapioca/lib/tapioca/runtime/trackers/tracker.rb#34
+  def with_disabled_tracker(&block); end
+
+  class << self
+    # source://tapioca/lib/tapioca/runtime/trackers/tracker.rb#17
+    sig { params(base: T.all(::Module, ::Tapioca::Runtime::Trackers::Tracker)).void }
+    def extended(base); end
+  end
+end
+
+# source://tapioca/lib/tapioca.rb#35
+Tapioca::SORBET_CONFIG_FILE = T.let(T.unsafe(nil), String)
+
+# source://tapioca/lib/tapioca.rb#34
+Tapioca::SORBET_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca/lib/tapioca/helpers/sorbet_helper.rb#5
+module Tapioca::SorbetHelper
+  # source://tapioca/lib/tapioca/helpers/sorbet_helper.rb#32
+  sig { params(sorbet_args: ::String).returns(::Spoom::ExecResult) }
+  def sorbet(*sorbet_args); end
+
+  # source://tapioca/lib/tapioca/helpers/sorbet_helper.rb#37
+  sig { returns(::String) }
+  def sorbet_path; end
+
+  # source://tapioca/lib/tapioca/helpers/sorbet_helper.rb#44
+  sig { params(feature: ::Symbol, version: T.nilable(::Gem::Version)).returns(T::Boolean) }
+  def sorbet_supports?(feature, version: T.unsafe(nil)); end
+end
+
+# source://tapioca/lib/tapioca/helpers/sorbet_helper.rb#24
+Tapioca::SorbetHelper::FEATURE_REQUIREMENTS = T.let(T.unsafe(nil), Hash)
+
+# source://tapioca/lib/tapioca/helpers/sorbet_helper.rb#13
+Tapioca::SorbetHelper::SORBET_BIN = T.let(T.unsafe(nil), Pathname)
+
+# source://tapioca/lib/tapioca/helpers/sorbet_helper.rb#18
+Tapioca::SorbetHelper::SORBET_EXE_PATH_ENV_VAR = T.let(T.unsafe(nil), String)
+
+# source://tapioca/lib/tapioca/helpers/sorbet_helper.rb#8
+Tapioca::SorbetHelper::SORBET_GEM_SPEC = T.let(T.unsafe(nil), Gem::Specification)
+
+# source://tapioca/lib/tapioca/helpers/sorbet_helper.rb#20
+Tapioca::SorbetHelper::SORBET_PAYLOAD_URL = T.let(T.unsafe(nil), String)
+
+# source://tapioca/lib/tapioca/helpers/sorbet_helper.rb#22
+Tapioca::SorbetHelper::SPOOM_CONTEXT = T.let(T.unsafe(nil), Spoom::Context)
+
+# source://tapioca/lib/tapioca/static/symbol_table_parser.rb#5
+module Tapioca::Static; end
+
+# source://tapioca/lib/tapioca/static/requires_compiler.rb#6
+class Tapioca::Static::RequiresCompiler
+  # source://tapioca/lib/tapioca/static/requires_compiler.rb#10
+  sig { params(sorbet_path: ::String).void }
+  def initialize(sorbet_path); end
+
+  # source://tapioca/lib/tapioca/static/requires_compiler.rb#15
+  sig { returns(::String) }
+  def compile; end
+
+  private
+
+  # source://tapioca/lib/tapioca/static/requires_compiler.rb#29
+  sig { params(config: ::Spoom::Sorbet::Config).returns(T::Array[::String]) }
+  def collect_files(config); end
+
+  # source://tapioca/lib/tapioca/static/requires_compiler.rb#44
+  sig { params(file_path: ::String).returns(T::Enumerable[::String]) }
+  def collect_requires(file_path); end
+
+  # source://tapioca/lib/tapioca/static/requires_compiler.rb#51
+  sig { params(config: ::Spoom::Sorbet::Config, file_path: ::Pathname).returns(T::Boolean) }
+  def file_ignored_by_sorbet?(config, file_path); end
+
+  # source://tapioca/lib/tapioca/static/requires_compiler.rb#80
+  sig { params(path: ::Pathname).returns(T::Array[::String]) }
+  def path_parts(path); end
+end
+
+# source://tapioca/lib/tapioca/static/symbol_loader.rb#6
+module Tapioca::Static::SymbolLoader
+  extend ::Tapioca::SorbetHelper
+  extend ::Tapioca::Runtime::AttachedClassOf
+  extend ::Tapioca::Runtime::Reflection
+
+  class << self
+    # source://tapioca/lib/tapioca/static/symbol_loader.rb#23
+    sig { params(gem: ::Tapioca::Gemfile::GemSpec).returns(T::Set[::String]) }
+    def engine_symbols(gem); end
+
+    # source://tapioca/lib/tapioca/static/symbol_loader.rb#48
+    sig { params(gem: ::Tapioca::Gemfile::GemSpec).returns(T::Set[::String]) }
+    def gem_symbols(gem); end
+
+    # source://tapioca/lib/tapioca/static/symbol_loader.rb#13
+    sig { returns(T::Set[::String]) }
+    def payload_symbols; end
+
+    # source://tapioca/lib/tapioca/static/symbol_loader.rb#53
+    sig { params(paths: T::Array[::Pathname]).returns(T::Set[::String]) }
+    def symbols_from_paths(paths); end
+
+    private
+
+    # @return [Array<T.class_of(Rails::Engine)>]
+    #
+    # source://tapioca/lib/tapioca/static/symbol_loader.rb#71
+    def engines; end
+
+    # source://tapioca/lib/tapioca/static/symbol_loader.rb#84
+    sig { params(input: ::String, table_type: ::String).returns(::String) }
+    def symbol_table_json_from(input, table_type: T.unsafe(nil)); end
+  end
+end
+
+# source://tapioca/lib/tapioca/static/symbol_table_parser.rb#6
+class Tapioca::Static::SymbolTableParser
+  # source://tapioca/lib/tapioca/static/symbol_table_parser.rb#30
+  sig { void }
+  def initialize; end
+
+  # source://tapioca/lib/tapioca/static/symbol_table_parser.rb#65
+  sig { params(name: ::String).returns(::String) }
+  def fully_qualified_name(name); end
+
+  # source://tapioca/lib/tapioca/static/symbol_table_parser.rb#36
+  sig { params(object: T::Hash[::String, T.untyped]).void }
+  def parse_object(object); end
+
+  # source://tapioca/lib/tapioca/static/symbol_table_parser.rb#27
+  sig { returns(T::Set[::String]) }
+  def symbols; end
+
+  class << self
+    # source://tapioca/lib/tapioca/static/symbol_table_parser.rb#15
+    sig { params(json_string: ::String).returns(T::Set[::String]) }
+    def parse_json(json_string); end
+  end
+end
+
+# source://tapioca/lib/tapioca/static/symbol_table_parser.rb#9
+Tapioca::Static::SymbolTableParser::SKIP_PARSE_KINDS = T.let(T.unsafe(nil), Array)
+
+# source://tapioca/lib/tapioca.rb#37
+Tapioca::TAPIOCA_CONFIG_FILE = T.let(T.unsafe(nil), String)
+
+# source://tapioca/lib/tapioca.rb#36
+Tapioca::TAPIOCA_DIR = T.let(T.unsafe(nil), String)
+
+# source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#108
+class Tapioca::TypeVariable < ::T::Types::TypeVariable
+  # @return [TypeVariable] a new instance of TypeVariable
+  #
+  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#109
+  def initialize(name, variance); end
+
+  # Returns the value of attribute name.
+  #
+  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#114
+  def name; end
+end
+
+# This is subclassing from `Module` so that instances of this type will be modules.
+# The reason why we want that is because that means those instances will automatically
+# get bound to the constant names they are assigned to by Ruby. As a result, we don't
+# need to do any matching of constants to type variables to bind their names, Ruby will
+# do that automatically for us and we get the `name` method for free from `Module`.
+#
+# source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#122
+class Tapioca::TypeVariableModule < ::Module
+  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#146
+  sig do
+    params(
+      context: ::Module,
+      type: ::Tapioca::TypeVariableModule::Type,
+      variance: ::Symbol,
+      bounds_proc: T.nilable(T.proc.returns(T::Hash[::Symbol, T.untyped]))
+    ).void
+  end
+  def initialize(context, type, variance, bounds_proc); end
+
+  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#181
+  sig { returns(::Tapioca::TypeVariable) }
+  def coerce_to_type_variable; end
+
+  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#161
+  sig { returns(T::Boolean) }
+  def fixed?; end
+
+  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#155
+  sig { returns(T.nilable(::String)) }
+  def name; end
+
+  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#166
+  sig { returns(::String) }
+  def serialize; end
+
+  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#136
+  sig { returns(::Tapioca::TypeVariableModule::Type) }
+  def type; end
+
+  private
+
+  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#188
+  sig { returns(T::Hash[::Symbol, T.untyped]) }
+  def bounds; end
+end
+
+# source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#133
+Tapioca::TypeVariableModule::DEFAULT_BOUNDS_PROC = T.let(T.unsafe(nil), Proc)
+
+# source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#125
+class Tapioca::TypeVariableModule::Type < ::T::Enum
+  enums do
+    HasAttachedClass = new
+    Member = new
+    Template = new
+  end
+end
+
+# source://tapioca/lib/tapioca/version.rb#5
+Tapioca::VERSION = T.let(T.unsafe(nil), String)
+
+# source://tapioca/lib/tapioca/helpers/source_uri.rb#7
+class URI::Source < ::URI::File
+  # source://ruby-lsp/0.23.6lib/ruby_lsp/requests/support/source_uri.rb#69
+  sig { params(v: T.nilable(::String)).returns(T::Boolean) }
+  def check_host(v); end
+
+  # source://tapioca/lib/tapioca/helpers/source_uri.rb#55
+  sig { returns(T.nilable(::String)) }
+  def gem_name; end
+
+  # source://ruby-lsp/0.23.6lib/ruby_lsp/requests/support/source_uri.rb#33
+  sig { returns(T.nilable(::String)) }
+  def gem_version; end
+
+  # source://tapioca/lib/tapioca/helpers/source_uri.rb#60
+  sig { returns(T.nilable(::String)) }
+  def line_number; end
+
+  # source://ruby-lsp/0.23.6lib/ruby_lsp/requests/support/source_uri.rb#59
+  sig { params(v: T.nilable(::String)).void }
+  def set_path(v); end
+
+  # source://ruby-lsp/0.23.6lib/ruby_lsp/requests/support/source_uri.rb#81
+  sig { returns(::String) }
+  def to_s; end
+
+  class << self
+    # source://ruby-lsp/0.23.6lib/ruby_lsp/requests/support/source_uri.rb#46
+    sig do
+      params(
+        gem_name: ::String,
+        gem_version: T.nilable(::String),
+        path: ::String,
+        line_number: T.nilable(::String)
+      ).returns(::URI::Source)
+    end
+    def build(gem_name:, gem_version:, path:, line_number:); end
+  end
+end
diff --git a/sorbet/rbi/gems/tapioca@0.16.8.rbi b/sorbet/rbi/gems/tapioca@0.16.8.rbi
index 5e1e4573..fb3b20f4 100644
--- a/sorbet/rbi/gems/tapioca@0.16.8.rbi
+++ b/sorbet/rbi/gems/tapioca@0.16.8.rbi
@@ -218,7 +218,13 @@ class RBI::TypedParam < ::T::Struct
   const :type, ::String
 
   class << self
+<<<<<<<< HEAD:sorbet/rbi/gems/tapioca@0.16.8.rbi
     # source://sorbet-runtime/0.5.11761lib/types/struct.rb#13
+|||||||| parent of 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.5.rbi
+    # source://sorbet-runtime/0.5.11635lib/types/struct.rb#13
+========
+    # source://sorbet-runtime/0.5.11725lib/types/struct.rb#13
+>>>>>>>> 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.6.rbi
     def inherited(s); end
   end
 end
@@ -1143,7 +1149,13 @@ class Tapioca::ConfigHelper::ConfigError < ::T::Struct
   const :message_parts, T::Array[::Tapioca::ConfigHelper::ConfigErrorMessagePart]
 
   class << self
+<<<<<<<< HEAD:sorbet/rbi/gems/tapioca@0.16.8.rbi
     # source://sorbet-runtime/0.5.11761lib/types/struct.rb#13
+|||||||| parent of 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.5.rbi
+    # source://sorbet-runtime/0.5.11635lib/types/struct.rb#13
+========
+    # source://sorbet-runtime/0.5.11725lib/types/struct.rb#13
+>>>>>>>> 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.6.rbi
     def inherited(s); end
   end
 end
@@ -1154,7 +1166,13 @@ class Tapioca::ConfigHelper::ConfigErrorMessagePart < ::T::Struct
   const :colors, T::Array[::Symbol]
 
   class << self
+<<<<<<<< HEAD:sorbet/rbi/gems/tapioca@0.16.8.rbi
     # source://sorbet-runtime/0.5.11761lib/types/struct.rb#13
+|||||||| parent of 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.5.rbi
+    # source://sorbet-runtime/0.5.11635lib/types/struct.rb#13
+========
+    # source://sorbet-runtime/0.5.11725lib/types/struct.rb#13
+>>>>>>>> 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.6.rbi
     def inherited(s); end
   end
 end
@@ -2228,7 +2246,13 @@ class Tapioca::GemInfo < ::T::Struct
     sig { params(spec: ::Bundler::LazySpecification).returns(::Tapioca::GemInfo) }
     def from_spec(spec); end
 
+<<<<<<<< HEAD:sorbet/rbi/gems/tapioca@0.16.8.rbi
     # source://sorbet-runtime/0.5.11761lib/types/struct.rb#13
+|||||||| parent of 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.5.rbi
+    # source://sorbet-runtime/0.5.11635lib/types/struct.rb#13
+========
+    # source://sorbet-runtime/0.5.11725lib/types/struct.rb#13
+>>>>>>>> 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.6.rbi
     def inherited(s); end
   end
 end
@@ -2428,7 +2452,13 @@ class Tapioca::Loaders::Dsl < ::Tapioca::Loaders::Loader
 
   protected
 
+<<<<<<<< HEAD:sorbet/rbi/gems/tapioca@0.16.8.rbi
   # source://tapioca/lib/tapioca/loaders/dsl.rb#103
+|||||||| parent of 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.5.rbi
+  # source://tapioca/lib/tapioca/loaders/dsl.rb#105
+========
+  # source://tapioca/lib/tapioca/loaders/dsl.rb#110
+>>>>>>>> 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.6.rbi
   sig { void }
   def load_application; end
 

From 510a3eaab449087e147134fc37466fd26d8d9d87 Mon Sep 17 00:00:00 2001
From: Andy Waite <13400+andyw8@users.noreply.github.com>
Date: Tue, 7 Jan 2025 13:41:49 -0500
Subject: [PATCH 6/8] Update sqlite3 gem RBI

---
 .../{sqlite3@2.1.0.rbi => sqlite3@2.5.0.rbi}  | 424 ++++++++++++------
 1 file changed, 284 insertions(+), 140 deletions(-)
 rename sorbet/rbi/gems/{sqlite3@2.1.0.rbi => sqlite3@2.5.0.rbi} (80%)

diff --git a/sorbet/rbi/gems/sqlite3@2.1.0.rbi b/sorbet/rbi/gems/sqlite3@2.5.0.rbi
similarity index 80%
rename from sorbet/rbi/gems/sqlite3@2.1.0.rbi
rename to sorbet/rbi/gems/sqlite3@2.5.0.rbi
index 18a2e67b..4eb2d0ed 100644
--- a/sorbet/rbi/gems/sqlite3@2.1.0.rbi
+++ b/sorbet/rbi/gems/sqlite3@2.5.0.rbi
@@ -10,8 +10,6 @@ module Process
   extend ::ActiveSupport::ForkTracker::CoreExt
 end
 
-# based on Rails's active_support/fork_tracker.rb
-#
 # source://sqlite3/lib/sqlite3/constants.rb#1
 module SQLite3
   class << self
@@ -29,10 +27,10 @@ module SQLite3
   end
 end
 
-# source://sqlite3/lib/sqlite3/errors.rb#15
+# source://sqlite3/lib/sqlite3/errors.rb#43
 class SQLite3::AbortException < ::SQLite3::Exception; end
 
-# source://sqlite3/lib/sqlite3/errors.rb#53
+# source://sqlite3/lib/sqlite3/errors.rb#81
 class SQLite3::AuthorizationException < ::SQLite3::Exception; end
 
 class SQLite3::Backup
@@ -46,10 +44,10 @@ end
 
 class SQLite3::Blob < ::String; end
 
-# source://sqlite3/lib/sqlite3/errors.rb#17
+# source://sqlite3/lib/sqlite3/errors.rb#45
 class SQLite3::BusyException < ::SQLite3::Exception; end
 
-# source://sqlite3/lib/sqlite3/errors.rb#35
+# source://sqlite3/lib/sqlite3/errors.rb#63
 class SQLite3::CantOpenException < ::SQLite3::Exception; end
 
 # source://sqlite3/lib/sqlite3/constants.rb#2
@@ -275,6 +273,40 @@ SQLite3::Constants::Open::TRANSIENT_DB = T.let(T.unsafe(nil), Integer)
 SQLite3::Constants::Open::URI = T.let(T.unsafe(nil), Integer)
 SQLite3::Constants::Open::WAL = T.let(T.unsafe(nil), Integer)
 
+# source://sqlite3/lib/sqlite3/constants.rb#174
+module SQLite3::Constants::Optimize; end
+
+# Run ANALYZE on tables that might benefit. On by default.
+#
+# source://sqlite3/lib/sqlite3/constants.rb#180
+SQLite3::Constants::Optimize::ANALYZE_TABLES = T.let(T.unsafe(nil), Integer)
+
+# Check the size of all tables, not just tables that have not been recently used, to see if
+# any have grown and shrunk significantly and hence might benefit from being re-analyzed. Off
+# by default.
+#
+# source://sqlite3/lib/sqlite3/constants.rb#189
+SQLite3::Constants::Optimize::CHECK_ALL_TABLES = T.let(T.unsafe(nil), Integer)
+
+# Debugging mode. Do not actually perform any optimizations but instead return one line of
+# text for each optimization that would have been done. Off by default.
+#
+# source://sqlite3/lib/sqlite3/constants.rb#177
+SQLite3::Constants::Optimize::DEBUG = T.let(T.unsafe(nil), Integer)
+
+# Useful for adding a bit to the default behavior, for example
+#
+#     db.optimize(Optimize::DEFAULT | Optimize::CHECK_ALL_TABLES)
+#
+# source://sqlite3/lib/sqlite3/constants.rb#195
+SQLite3::Constants::Optimize::DEFAULT = T.let(T.unsafe(nil), Integer)
+
+# When running ANALYZE, set a temporary PRAGMA analysis_limit to prevent excess run-time. On
+# by default.
+#
+# source://sqlite3/lib/sqlite3/constants.rb#184
+SQLite3::Constants::Optimize::LIMIT_ANALYZE = T.let(T.unsafe(nil), Integer)
+
 # CAPI3REF: Status Parameters
 #
 # These integer constants designate various run-time status parameters
@@ -387,14 +419,16 @@ SQLite3::Constants::TextRep::UTF16LE = T.let(T.unsafe(nil), Integer)
 # source://sqlite3/lib/sqlite3/constants.rb#11
 SQLite3::Constants::TextRep::UTF8 = T.let(T.unsafe(nil), Integer)
 
-# source://sqlite3/lib/sqlite3/errors.rb#45
+# source://sqlite3/lib/sqlite3/errors.rb#73
 class SQLite3::ConstraintException < ::SQLite3::Exception; end
 
-# source://sqlite3/lib/sqlite3/errors.rb#29
+# source://sqlite3/lib/sqlite3/errors.rb#57
 class SQLite3::CorruptException < ::SQLite3::Exception; end
 
-# The Database class encapsulates a single connection to a SQLite3 database.
-# Its usage is very straightforward:
+# == Overview
+#
+# The Database class encapsulates a single connection to a SQLite3 database.  Here's a
+# straightforward example of usage:
 #
 #   require 'sqlite3'
 #
@@ -404,54 +438,95 @@ class SQLite3::CorruptException < ::SQLite3::Exception; end
 #     end
 #   end
 #
-# It wraps the lower-level methods provided by the selected driver, and
-# includes the Pragmas module for access to various pragma convenience
-# methods.
+# It wraps the lower-level methods provided by the selected driver, and includes the Pragmas
+# module for access to various pragma convenience methods.
 #
-# The Database class provides type translation services as well, by which
-# the SQLite3 data types (which are all represented as strings) may be
-# converted into their corresponding types (as defined in the schemas
-# for their tables). This translation only occurs when querying data from
+# The Database class provides type translation services as well, by which the SQLite3 data types
+# (which are all represented as strings) may be converted into their corresponding types (as
+# defined in the schemas for their tables). This translation only occurs when querying data from
 # the database--insertions and updates are all still typeless.
 #
-# Furthermore, the Database class has been designed to work well with the
-# ArrayFields module from Ara Howard. If you require the ArrayFields
-# module before performing a query, and if you have not enabled results as
-# hashes, then the results will all be indexible by field name.
+# Furthermore, the Database class has been designed to work well with the ArrayFields module from
+# Ara Howard. If you require the ArrayFields module before performing a query, and if you have not
+# enabled results as hashes, then the results will all be indexible by field name.
+#
+# == Thread safety
 #
-# Thread safety:
+# When SQLite3.threadsafe? returns true, it is safe to share instances of the database class
+# among threads without adding specific locking. Other object instances may require applications
+# to provide their own locks if they are to be shared among threads.  Please see the README.md for
+# more information.
 #
-# When `SQLite3.threadsafe?` returns true, it is safe to share instances of
-# the database class among threads without adding specific locking. Other
-# object instances may require applications to provide their own locks if
-# they are to be shared among threads.  Please see the README.md for more
-# information.
+# == SQLite Extensions
 #
-# source://sqlite3/lib/sqlite3/database.rb#44
+# SQLite3::Database supports the universe of {sqlite
+# extensions}[https://www.sqlite.org/loadext.html]. It's possible to load an extension into an
+# existing Database object using the #load_extension method and passing a filesystem path:
+#
+#   db = SQLite3::Database.new(":memory:")
+#   db.enable_load_extension(true)
+#   db.load_extension("/path/to/extension")
+#
+# As of v2.4.0, it's also possible to pass an object that responds to +#to_path+. This
+# documentation will refer to the supported interface as +_ExtensionSpecifier+, which can be
+# expressed in RBS syntax as:
+#
+#   interface _ExtensionSpecifier
+#     def to_path: () → String
+#   end
+#
+# So, for example, if you are using the {sqlean gem}[https://github.com/flavorjones/sqlean-ruby]
+# which provides modules that implement this interface, you can pass the module directly:
+#
+#   db = SQLite3::Database.new(":memory:")
+#   db.enable_load_extension(true)
+#   db.load_extension(SQLean::Crypto)
+#
+# It's also possible in v2.4.0+ to load extensions via the SQLite3::Database constructor by using
+# the +extensions:+ keyword argument to pass an array of String paths or extension specifiers:
+#
+#   db = SQLite3::Database.new(":memory:", extensions: ["/path/to/extension", SQLean::Crypto])
+#
+# Note that when loading extensions via the constructor, there is no need to call
+# #enable_load_extension; however it is still necessary to call #enable_load_extensions before any
+# subsequently invocations of #load_extension on the initialized Database object.
+#
+# You can load extensions in a Rails application by using the +extensions:+ configuration option:
+#
+#   # config/database.yml
+#   development:
+#     adapter: sqlite3
+#     extensions:
+#       - .sqlpkg/nalgeon/crypto/crypto.so # a filesystem path
+#       - <%= SQLean::UUID.to_path %>      # or ruby code returning a path
+#
+# source://sqlite3/lib/sqlite3/database.rb#86
 class SQLite3::Database
   include ::SQLite3::Pragmas
 
-  # call-seq: SQLite3::Database.new(file, options = {})
+  # call-seq:
+  #   SQLite3::Database.new(file, options = {})
   #
   # Create a new Database object that opens the given file.
   #
   # Supported permissions +options+:
   # - the default mode is <tt>READWRITE | CREATE</tt>
-  # - +:readonly+: boolean (default false), true to set the mode to +READONLY+
-  # - +:readwrite+: boolean (default false), true to set the mode to +READWRITE+
-  # - +:flags+: set the mode to a combination of SQLite3::Constants::Open flags.
+  # - +readonly:+ boolean (default false), true to set the mode to +READONLY+
+  # - +readwrite:+ boolean (default false), true to set the mode to +READWRITE+
+  # - +flags:+ set the mode to a combination of SQLite3::Constants::Open flags.
   #
   # Supported encoding +options+:
-  # - +:utf16+: boolean (default false), is the filename's encoding UTF-16 (only needed if the filename encoding is not UTF_16LE or BE)
+  # - +utf16:+ +boolish+ (default false), is the filename's encoding UTF-16 (only needed if the filename encoding is not UTF_16LE or BE)
   #
   # Other supported +options+:
-  # - +:strict+: boolean (default false), disallow the use of double-quoted string literals (see https://www.sqlite.org/quirks.html#double_quoted_string_literals_are_accepted)
-  # - +:results_as_hash+: boolean (default false), return rows as hashes instead of arrays
-  # - +:default_transaction_mode+: one of +:deferred+ (default), +:immediate+, or +:exclusive+. If a mode is not specified in a call to #transaction, this will be the default transaction mode.
+  # - +strict:+ +boolish+ (default false), disallow the use of double-quoted string literals (see https://www.sqlite.org/quirks.html#double_quoted_string_literals_are_accepted)
+  # - +results_as_hash:+ +boolish+ (default false), return rows as hashes instead of arrays
+  # - +default_transaction_mode:+ one of +:deferred+ (default), +:immediate+, or +:exclusive+. If a mode is not specified in a call to #transaction, this will be the default transaction mode.
+  # - +extensions:+ <tt>Array[String | _ExtensionSpecifier]</tt> SQLite extensions to load into the database. See Database@SQLite+Extensions for more information.
   #
   # @return [Database] a new instance of Database
   #
-  # source://sqlite3/lib/sqlite3/database.rb#97
+  # source://sqlite3/lib/sqlite3/database.rb#141
   def initialize(file, options = T.unsafe(nil), zvfs = T.unsafe(nil)); end
 
   # Installs (or removes) a block that will be invoked for every access
@@ -459,7 +534,7 @@ class SQLite3::Database
   # is allowed to proceed. Returning 1 causes an authorization error to
   # occur, and returning 2 causes the access to be silently denied.
   #
-  # source://sqlite3/lib/sqlite3/database.rb#160
+  # source://sqlite3/lib/sqlite3/database.rb#206
   def authorizer(&block); end
 
   def authorizer=(_arg0); end
@@ -467,7 +542,7 @@ class SQLite3::Database
   # Given a statement, return a result set.
   # This is not intended for general consumption
   #
-  # source://sqlite3/lib/sqlite3/database.rb#697
+  # source://sqlite3/lib/sqlite3/database.rb#789
   def build_result_set(stmt); end
 
   def busy_handler(*_arg0); end
@@ -477,7 +552,7 @@ class SQLite3::Database
   # This is an alternative to #busy_timeout, which holds the GVL
   # while SQLite sleeps and retries.
   #
-  # source://sqlite3/lib/sqlite3/database.rb#646
+  # source://sqlite3/lib/sqlite3/database.rb#692
   def busy_handler_timeout=(milliseconds); end
 
   def busy_timeout(_arg0); end
@@ -489,7 +564,7 @@ class SQLite3::Database
 
   # Returns the value of attribute collations.
   #
-  # source://sqlite3/lib/sqlite3/database.rb#45
+  # source://sqlite3/lib/sqlite3/database.rb#87
   def collations; end
 
   # Commits the current transaction. If there is no current transaction,
@@ -497,7 +572,7 @@ class SQLite3::Database
   # to allow it to be used in idioms like
   # <tt>abort? and rollback or commit</tt>.
   #
-  # source://sqlite3/lib/sqlite3/database.rb#622
+  # source://sqlite3/lib/sqlite3/database.rb#668
   def commit; end
 
   def complete?(_arg0); end
@@ -539,7 +614,7 @@ class SQLite3::Database
   # See also #create_aggregate_handler for a more object-oriented approach to
   # aggregate functions.
   #
-  # source://sqlite3/lib/sqlite3/database.rb#410
+  # source://sqlite3/lib/sqlite3/database.rb#456
   def create_aggregate(name, arity, step = T.unsafe(nil), finalize = T.unsafe(nil), text_rep = T.unsafe(nil), &block); end
 
   # This is another approach to creating an aggregate function (see
@@ -590,7 +665,7 @@ class SQLite3::Database
   #   db.create_aggregate_handler( LengthsAggregateHandler )
   #   puts db.get_first_value( "select lengths(name) from A" )
   #
-  # source://sqlite3/lib/sqlite3/database.rb#508
+  # source://sqlite3/lib/sqlite3/database.rb#554
   def create_aggregate_handler(handler); end
 
   # Creates a new function for use in SQL statements. It will be added as
@@ -617,7 +692,7 @@ class SQLite3::Database
   #
   #   puts db.get_first_value( "select maim(name) from table" )
   #
-  # source://sqlite3/lib/sqlite3/database.rb#365
+  # source://sqlite3/lib/sqlite3/database.rb#411
   def create_function(name, arity, text_rep = T.unsafe(nil), &block); end
 
   # Define an aggregate function named +name+ using a object template
@@ -631,7 +706,7 @@ class SQLite3::Database
   # already provide a suitable +clone+.
   # The functions arity is the arity of the +step+ method.
   #
-  # source://sqlite3/lib/sqlite3/database.rb#545
+  # source://sqlite3/lib/sqlite3/database.rb#591
   def define_aggregator(name, aggregator); end
 
   def define_function(_arg0); end
@@ -642,7 +717,7 @@ class SQLite3::Database
   #
   # Fetch the encoding set on this database
   #
-  # source://sqlite3/lib/sqlite3/database.rb#152
+  # source://sqlite3/lib/sqlite3/database.rb#198
   def encoding; end
 
   def errcode; end
@@ -663,7 +738,7 @@ class SQLite3::Database
   # See also #execute2, #query, and #execute_batch for additional ways of
   # executing statements.
   #
-  # source://sqlite3/lib/sqlite3/database.rb#201
+  # source://sqlite3/lib/sqlite3/database.rb#247
   def execute(sql, bind_vars = T.unsafe(nil), &block); end
 
   # Executes the given SQL statement, exactly as with #execute. However, the
@@ -677,7 +752,7 @@ class SQLite3::Database
   # See also #execute, #query, and #execute_batch for additional ways of
   # executing statements.
   #
-  # source://sqlite3/lib/sqlite3/database.rb#226
+  # source://sqlite3/lib/sqlite3/database.rb#272
   def execute2(sql, *bind_vars); end
 
   # Executes all SQL statements in the given string. By contrast, the other
@@ -691,7 +766,7 @@ class SQLite3::Database
   # See also #execute_batch2 for additional ways of
   # executing statements.
   #
-  # source://sqlite3/lib/sqlite3/database.rb#250
+  # source://sqlite3/lib/sqlite3/database.rb#296
   def execute_batch(sql, bind_vars = T.unsafe(nil)); end
 
   # Executes all SQL statements in the given string. By contrast, the other
@@ -708,7 +783,7 @@ class SQLite3::Database
   # See also #execute_batch for additional ways of
   # executing statements.
   #
-  # source://sqlite3/lib/sqlite3/database.rb#283
+  # source://sqlite3/lib/sqlite3/database.rb#329
   def execute_batch2(sql, &block); end
 
   def extended_result_codes=(_arg0); end
@@ -717,7 +792,7 @@ class SQLite3::Database
   # to "main".  Main return `nil` or an empty string if the database is
   # temporary or in-memory.
   #
-  # source://sqlite3/lib/sqlite3/database.rb#183
+  # source://sqlite3/lib/sqlite3/database.rb#229
   def filename(db_name = T.unsafe(nil)); end
 
   # A convenience method for obtaining the first row of a result set, and
@@ -725,7 +800,7 @@ class SQLite3::Database
   #
   # See also #get_first_value.
   #
-  # source://sqlite3/lib/sqlite3/database.rb#322
+  # source://sqlite3/lib/sqlite3/database.rb#368
   def get_first_row(sql, *bind_vars); end
 
   # A convenience method for obtaining the first value of the first row of a
@@ -734,19 +809,47 @@ class SQLite3::Database
   #
   # See also #get_first_row.
   #
-  # source://sqlite3/lib/sqlite3/database.rb#331
+  # source://sqlite3/lib/sqlite3/database.rb#377
   def get_first_value(sql, *bind_vars); end
 
+  # @raise [TypeError]
+  #
+  # source://sqlite3/lib/sqlite3/database.rb#737
+  def initialize_extensions(extensions); end
+
   def interrupt; end
   def last_insert_row_id; end
-  def load_extension(_arg0); end
+
+  # call-seq:
+  #   load_extension(extension_specifier) -> self
+  #
+  # Loads an SQLite extension library from the named file. Extension loading must be enabled using
+  # #enable_load_extension prior to using this method.
+  #
+  # See also: Database@SQLite+Extensions
+  #
+  # [Parameters]
+  # - +extension_specifier+: (String | +_ExtensionSpecifier+) If a String, it is the filesystem path
+  #   to the sqlite extension file. If an object that responds to #to_path, the
+  #   return value of that method is used as the filesystem path to the sqlite extension file.
+  #
+  # [Example] Using a filesystem path:
+  #
+  #   db.load_extension("/path/to/my_extension.so")
+  #
+  # [Example] Using the {sqlean gem}[https://github.com/flavorjones/sqlean-ruby]:
+  #
+  #   db.load_extension(SQLean::VSV)
+  #
+  # source://sqlite3/lib/sqlite3/database.rb#728
+  def load_extension(extension_specifier); end
 
   # Returns a Statement object representing the given SQL. This does not
   # execute the statement; it merely prepares the statement for execution.
   #
   # The Statement can then be executed using Statement#execute.
   #
-  # source://sqlite3/lib/sqlite3/database.rb#169
+  # source://sqlite3/lib/sqlite3/database.rb#215
   def prepare(sql); end
 
   # This is a convenience method for creating a statement, binding
@@ -761,7 +864,7 @@ class SQLite3::Database
   # with a block, +close+ will be invoked implicitly when the block
   # terminates.
   #
-  # source://sqlite3/lib/sqlite3/database.rb#305
+  # source://sqlite3/lib/sqlite3/database.rb#351
   def query(sql, bind_vars = T.unsafe(nil)); end
 
   # Returns +true+ if the database has been open in readonly mode
@@ -769,19 +872,19 @@ class SQLite3::Database
   #
   # @return [Boolean]
   #
-  # source://sqlite3/lib/sqlite3/database.rb#638
+  # source://sqlite3/lib/sqlite3/database.rb#684
   def readonly?; end
 
   # A boolean that indicates whether rows in result sets should be returned
   # as hashes or not. By default, rows are returned as arrays.
   #
-  # source://sqlite3/lib/sqlite3/database.rb#77
+  # source://sqlite3/lib/sqlite3/database.rb#119
   def results_as_hash; end
 
   # A boolean that indicates whether rows in result sets should be returned
   # as hashes or not. By default, rows are returned as arrays.
   #
-  # source://sqlite3/lib/sqlite3/database.rb#77
+  # source://sqlite3/lib/sqlite3/database.rb#119
   def results_as_hash=(_arg0); end
 
   # Rolls the current transaction back. If there is no current transaction,
@@ -789,7 +892,7 @@ class SQLite3::Database
   # to allow it to be used in idioms like
   # <tt>abort? and rollback or commit</tt>.
   #
-  # source://sqlite3/lib/sqlite3/database.rb#631
+  # source://sqlite3/lib/sqlite3/database.rb#677
   def rollback; end
 
   def statement_timeout=(_arg0); end
@@ -815,7 +918,7 @@ class SQLite3::Database
   # transaction explicitly, either by calling #commit, or by calling
   # #rollback.
   #
-  # source://sqlite3/lib/sqlite3/database.rb#599
+  # source://sqlite3/lib/sqlite3/database.rb#645
   def transaction(mode = T.unsafe(nil)); end
 
   def transaction_active?; end
@@ -827,6 +930,7 @@ class SQLite3::Database
   def disable_quirk_mode; end
   def discard; end
   def exec_batch(_arg0, _arg1); end
+  def load_extension_internal(_arg0); end
   def open16(_arg0); end
   def open_v2(_arg0, _arg1, _arg2); end
 
@@ -835,14 +939,14 @@ class SQLite3::Database
     # With block, like new closes the database at the end, but unlike new
     # returns the result of the block instead of the database instance.
     #
-    # source://sqlite3/lib/sqlite3/database.rb#53
+    # source://sqlite3/lib/sqlite3/database.rb#95
     def open(*args); end
 
     # Quotes the given string, making it safe to use in an SQL statement.
     # It replaces all instances of the single-quote character with two
     # single-quote characters. The modified string is returned.
     #
-    # source://sqlite3/lib/sqlite3/database.rb#70
+    # source://sqlite3/lib/sqlite3/database.rb#112
     def quote(string); end
   end
 end
@@ -856,7 +960,7 @@ end
 # This class will almost _always_ be instantiated indirectly, by working
 # with the create methods mentioned above.
 #
-# source://sqlite3/lib/sqlite3/database.rb#669
+# source://sqlite3/lib/sqlite3/database.rb#761
 class SQLite3::Database::FunctionProxy
   # Create a new FunctionProxy that encapsulates the given +func+ object.
   # If context is non-nil, the functions context will be set to that. If
@@ -865,35 +969,35 @@ class SQLite3::Database::FunctionProxy
   #
   # @return [FunctionProxy] a new instance of FunctionProxy
   #
-  # source://sqlite3/lib/sqlite3/database.rb#676
+  # source://sqlite3/lib/sqlite3/database.rb#768
   def initialize; end
 
   # Returns the value with the given key from the context. This is only
   # available to aggregate functions.
   #
-  # source://sqlite3/lib/sqlite3/database.rb#683
+  # source://sqlite3/lib/sqlite3/database.rb#775
   def [](key); end
 
   # Sets the value with the given key in the context. This is only
   # available to aggregate functions.
   #
-  # source://sqlite3/lib/sqlite3/database.rb#689
+  # source://sqlite3/lib/sqlite3/database.rb#781
   def []=(key, value); end
 
   # Returns the value of attribute result.
   #
-  # source://sqlite3/lib/sqlite3/database.rb#670
+  # source://sqlite3/lib/sqlite3/database.rb#762
   def result; end
 
   # Sets the attribute result
   #
   # @param value the value to set the attribute result to.
   #
-  # source://sqlite3/lib/sqlite3/database.rb#670
+  # source://sqlite3/lib/sqlite3/database.rb#762
   def result=(_arg0); end
 end
 
-# source://sqlite3/lib/sqlite3/errors.rb#39
+# source://sqlite3/lib/sqlite3/errors.rb#67
 class SQLite3::EmptyException < ::SQLite3::Exception; end
 
 # source://sqlite3/lib/sqlite3/errors.rb#4
@@ -902,8 +1006,29 @@ class SQLite3::Exception < ::StandardError
   #
   # source://sqlite3/lib/sqlite3/errors.rb#6
   def code; end
+
+  # source://sqlite3/lib/sqlite3/errors.rb#15
+  def message; end
+
+  # If the error is associated with a SQL query, this is the query
+  #
+  # source://sqlite3/lib/sqlite3/errors.rb#9
+  def sql; end
+
+  # If the error is associated with a particular offset in a SQL query, this is the non-negative
+  # offset. If the offset is not available, this will be -1.
+  #
+  # source://sqlite3/lib/sqlite3/errors.rb#13
+  def sql_offset; end
+
+  private
+
+  # source://sqlite3/lib/sqlite3/errors.rb#19
+  def sql_error; end
 end
 
+# based on Rails's active_support/fork_tracker.rb
+#
 # source://sqlite3/lib/sqlite3/fork_safety.rb#7
 module SQLite3::ForkSafety
   class << self
@@ -915,7 +1040,7 @@ module SQLite3::ForkSafety
 
     # Call to suppress the fork-related warnings.
     #
-    # source://sqlite3/lib/sqlite3/fork_safety.rb#55
+    # source://sqlite3/lib/sqlite3/fork_safety.rb#59
     def suppress_warnings!; end
 
     # source://sqlite3/lib/sqlite3/fork_safety.rb#27
@@ -929,10 +1054,10 @@ module SQLite3::ForkSafety::CoreExt
   def _fork; end
 end
 
-# source://sqlite3/lib/sqlite3/errors.rb#55
+# source://sqlite3/lib/sqlite3/errors.rb#83
 class SQLite3::FormatException < ::SQLite3::Exception; end
 
-# source://sqlite3/lib/sqlite3/errors.rb#33
+# source://sqlite3/lib/sqlite3/errors.rb#61
 class SQLite3::FullException < ::SQLite3::Exception; end
 
 # source://sqlite3/lib/sqlite3/resultset.rb#93
@@ -941,34 +1066,34 @@ class SQLite3::HashResultSet < ::SQLite3::ResultSet
   def next; end
 end
 
-# source://sqlite3/lib/sqlite3/errors.rb#27
+# source://sqlite3/lib/sqlite3/errors.rb#55
 class SQLite3::IOException < ::SQLite3::Exception; end
 
-# source://sqlite3/lib/sqlite3/errors.rb#11
+# source://sqlite3/lib/sqlite3/errors.rb#39
 class SQLite3::InternalException < ::SQLite3::Exception; end
 
-# source://sqlite3/lib/sqlite3/errors.rb#25
+# source://sqlite3/lib/sqlite3/errors.rb#53
 class SQLite3::InterruptException < ::SQLite3::Exception; end
 
-# source://sqlite3/lib/sqlite3/errors.rb#19
+# source://sqlite3/lib/sqlite3/errors.rb#47
 class SQLite3::LockedException < ::SQLite3::Exception; end
 
-# source://sqlite3/lib/sqlite3/errors.rb#21
+# source://sqlite3/lib/sqlite3/errors.rb#49
 class SQLite3::MemoryException < ::SQLite3::Exception; end
 
-# source://sqlite3/lib/sqlite3/errors.rb#47
+# source://sqlite3/lib/sqlite3/errors.rb#75
 class SQLite3::MismatchException < ::SQLite3::Exception; end
 
-# source://sqlite3/lib/sqlite3/errors.rb#49
+# source://sqlite3/lib/sqlite3/errors.rb#77
 class SQLite3::MisuseException < ::SQLite3::Exception; end
 
-# source://sqlite3/lib/sqlite3/errors.rb#59
+# source://sqlite3/lib/sqlite3/errors.rb#87
 class SQLite3::NotADatabaseException < ::SQLite3::Exception; end
 
-# source://sqlite3/lib/sqlite3/errors.rb#31
+# source://sqlite3/lib/sqlite3/errors.rb#59
 class SQLite3::NotFoundException < ::SQLite3::Exception; end
 
-# source://sqlite3/lib/sqlite3/errors.rb#13
+# source://sqlite3/lib/sqlite3/errors.rb#41
 class SQLite3::PermissionException < ::SQLite3::Exception; end
 
 # This module is intended for inclusion solely by the Database class. It
@@ -1201,63 +1326,73 @@ module SQLite3::Pragmas
   # source://sqlite3/lib/sqlite3/pragmas.rb#337
   def mmap_size=(size); end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#341
+  # Attempt to optimize the database.
+  #
+  # To customize the optimization options, pass +bitmask+ with a combination
+  # of the Constants::Optimize masks.
+  #
+  # See https://www.sqlite.org/pragma.html#pragma_optimize for more information.
+  #
+  # source://sqlite3/lib/sqlite3/pragmas.rb#347
+  def optimize(bitmask = T.unsafe(nil)); end
+
+  # source://sqlite3/lib/sqlite3/pragmas.rb#355
   def page_count; end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#345
+  # source://sqlite3/lib/sqlite3/pragmas.rb#359
   def page_size; end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#349
+  # source://sqlite3/lib/sqlite3/pragmas.rb#363
   def page_size=(size); end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#353
+  # source://sqlite3/lib/sqlite3/pragmas.rb#367
   def parser_trace=(mode); end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#357
+  # source://sqlite3/lib/sqlite3/pragmas.rb#371
   def query_only; end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#361
+  # source://sqlite3/lib/sqlite3/pragmas.rb#375
   def query_only=(mode); end
 
   # :yields: row
   #
-  # source://sqlite3/lib/sqlite3/pragmas.rb#365
+  # source://sqlite3/lib/sqlite3/pragmas.rb#379
   def quick_check(*num_errors, &block); end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#369
+  # source://sqlite3/lib/sqlite3/pragmas.rb#383
   def read_uncommitted; end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#373
+  # source://sqlite3/lib/sqlite3/pragmas.rb#387
   def read_uncommitted=(mode); end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#377
+  # source://sqlite3/lib/sqlite3/pragmas.rb#391
   def recursive_triggers; end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#381
+  # source://sqlite3/lib/sqlite3/pragmas.rb#395
   def recursive_triggers=(mode); end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#385
+  # source://sqlite3/lib/sqlite3/pragmas.rb#399
   def reverse_unordered_selects; end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#389
+  # source://sqlite3/lib/sqlite3/pragmas.rb#403
   def reverse_unordered_selects=(mode); end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#393
+  # source://sqlite3/lib/sqlite3/pragmas.rb#407
   def schema_cookie; end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#397
+  # source://sqlite3/lib/sqlite3/pragmas.rb#411
   def schema_cookie=(cookie); end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#401
+  # source://sqlite3/lib/sqlite3/pragmas.rb#415
   def schema_version; end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#405
+  # source://sqlite3/lib/sqlite3/pragmas.rb#419
   def schema_version=(version); end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#409
+  # source://sqlite3/lib/sqlite3/pragmas.rb#423
   def secure_delete; end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#413
+  # source://sqlite3/lib/sqlite3/pragmas.rb#427
   def secure_delete=(mode); end
 
   # Sets the given pragma to the given boolean value. The value itself
@@ -1282,90 +1417,90 @@ module SQLite3::Pragmas
   # source://sqlite3/lib/sqlite3/pragmas.rb#75
   def set_int_pragma(name, value); end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#417
+  # source://sqlite3/lib/sqlite3/pragmas.rb#431
   def short_column_names; end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#421
+  # source://sqlite3/lib/sqlite3/pragmas.rb#435
   def short_column_names=(mode); end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#425
+  # source://sqlite3/lib/sqlite3/pragmas.rb#439
   def shrink_memory; end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#429
+  # source://sqlite3/lib/sqlite3/pragmas.rb#443
   def soft_heap_limit; end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#433
+  # source://sqlite3/lib/sqlite3/pragmas.rb#447
   def soft_heap_limit=(mode); end
 
   # :yields: row
   #
-  # source://sqlite3/lib/sqlite3/pragmas.rb#437
+  # source://sqlite3/lib/sqlite3/pragmas.rb#451
   def stats(&block); end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#441
+  # source://sqlite3/lib/sqlite3/pragmas.rb#455
   def synchronous; end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#445
+  # source://sqlite3/lib/sqlite3/pragmas.rb#459
   def synchronous=(mode); end
 
   # Returns information about +table+.  Yields each row of table information
   # if a block is provided.
   #
-  # source://sqlite3/lib/sqlite3/pragmas.rb#524
+  # source://sqlite3/lib/sqlite3/pragmas.rb#538
   def table_info(table); end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#449
+  # source://sqlite3/lib/sqlite3/pragmas.rb#463
   def temp_store; end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#453
+  # source://sqlite3/lib/sqlite3/pragmas.rb#467
   def temp_store=(mode); end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#457
+  # source://sqlite3/lib/sqlite3/pragmas.rb#471
   def threads; end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#461
+  # source://sqlite3/lib/sqlite3/pragmas.rb#475
   def threads=(count); end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#465
+  # source://sqlite3/lib/sqlite3/pragmas.rb#479
   def user_cookie; end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#469
+  # source://sqlite3/lib/sqlite3/pragmas.rb#483
   def user_cookie=(cookie); end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#473
+  # source://sqlite3/lib/sqlite3/pragmas.rb#487
   def user_version; end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#477
+  # source://sqlite3/lib/sqlite3/pragmas.rb#491
   def user_version=(version); end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#481
+  # source://sqlite3/lib/sqlite3/pragmas.rb#495
   def vdbe_addoptrace=(mode); end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#485
+  # source://sqlite3/lib/sqlite3/pragmas.rb#499
   def vdbe_debug=(mode); end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#489
+  # source://sqlite3/lib/sqlite3/pragmas.rb#503
   def vdbe_listing=(mode); end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#493
+  # source://sqlite3/lib/sqlite3/pragmas.rb#507
   def vdbe_trace; end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#497
+  # source://sqlite3/lib/sqlite3/pragmas.rb#511
   def vdbe_trace=(mode); end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#501
+  # source://sqlite3/lib/sqlite3/pragmas.rb#515
   def wal_autocheckpoint; end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#505
+  # source://sqlite3/lib/sqlite3/pragmas.rb#519
   def wal_autocheckpoint=(mode); end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#509
+  # source://sqlite3/lib/sqlite3/pragmas.rb#523
   def wal_checkpoint; end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#513
+  # source://sqlite3/lib/sqlite3/pragmas.rb#527
   def wal_checkpoint=(mode); end
 
-  # source://sqlite3/lib/sqlite3/pragmas.rb#517
+  # source://sqlite3/lib/sqlite3/pragmas.rb#531
   def writable_schema=(mode); end
 
   private
@@ -1374,12 +1509,12 @@ module SQLite3::Pragmas
   # value of the row as a quoted SQL value. This method essentially
   # unquotes those values.
   #
-  # source://sqlite3/lib/sqlite3/pragmas.rb#574
+  # source://sqlite3/lib/sqlite3/pragmas.rb#588
   def tweak_default(hash); end
 
   # Compares two version strings
   #
-  # source://sqlite3/lib/sqlite3/pragmas.rb#558
+  # source://sqlite3/lib/sqlite3/pragmas.rb#572
   def version_compare(v1, v2); end
 end
 
@@ -1418,13 +1553,13 @@ SQLite3::Pragmas::TEMP_STORE_MODES = T.let(T.unsafe(nil), Array)
 # source://sqlite3/lib/sqlite3/pragmas.rb#99
 SQLite3::Pragmas::WAL_CHECKPOINTS = T.let(T.unsafe(nil), Array)
 
-# source://sqlite3/lib/sqlite3/errors.rb#37
+# source://sqlite3/lib/sqlite3/errors.rb#65
 class SQLite3::ProtocolException < ::SQLite3::Exception; end
 
-# source://sqlite3/lib/sqlite3/errors.rb#57
+# source://sqlite3/lib/sqlite3/errors.rb#85
 class SQLite3::RangeException < ::SQLite3::Exception; end
 
-# source://sqlite3/lib/sqlite3/errors.rb#23
+# source://sqlite3/lib/sqlite3/errors.rb#51
 class SQLite3::ReadOnlyException < ::SQLite3::Exception; end
 
 # The ResultSet object encapsulates the enumerability of a query's output.
@@ -1514,14 +1649,16 @@ class SQLite3::ResultSet
   def types; end
 end
 
-# source://sqlite3/lib/sqlite3/errors.rb#9
+# source://sqlite3/lib/sqlite3/errors.rb#37
 class SQLite3::SQLException < ::SQLite3::Exception; end
 
 SQLite3::SQLITE_LOADED_VERSION = T.let(T.unsafe(nil), String)
+SQLite3::SQLITE_PACKAGED_LIBRARIES = T.let(T.unsafe(nil), TrueClass)
+SQLite3::SQLITE_PRECOMPILED_LIBRARIES = T.let(T.unsafe(nil), TrueClass)
 SQLite3::SQLITE_VERSION = T.let(T.unsafe(nil), String)
 SQLite3::SQLITE_VERSION_NUMBER = T.let(T.unsafe(nil), Integer)
 
-# source://sqlite3/lib/sqlite3/errors.rb#41
+# source://sqlite3/lib/sqlite3/errors.rb#69
 class SQLite3::SchemaChangedException < ::SQLite3::Exception; end
 
 # A statement represents a prepared-but-unexecuted SQL query. It will rarely
@@ -1695,15 +1832,22 @@ class SQLite3::Statement
   def stats_as_hash; end
 end
 
-# source://sqlite3/lib/sqlite3/errors.rb#43
+# source://sqlite3/lib/sqlite3/errors.rb#71
 class SQLite3::TooBigException < ::SQLite3::Exception; end
 
-# source://sqlite3/lib/sqlite3/errors.rb#51
+# source://sqlite3/lib/sqlite3/errors.rb#79
 class SQLite3::UnsupportedException < ::SQLite3::Exception; end
 
-# source://sqlite3/lib/sqlite3/version.rb#2
+# (String) the version of the sqlite3 gem, e.g. "2.1.1"
+#
+# source://sqlite3/lib/sqlite3/version.rb#3
 SQLite3::VERSION = T.let(T.unsafe(nil), String)
 
+# a hash of descriptive metadata about the current version of the sqlite3 gem
+#
+# source://sqlite3/lib/sqlite3/version_info.rb#3
+SQLite3::VERSION_INFO = T.let(T.unsafe(nil), Hash)
+
 # source://sqlite3/lib/sqlite3/value.rb#4
 class SQLite3::Value
   # @return [Value] a new instance of Value

From 12774a8679627e10b582840912880d6203ee77cc Mon Sep 17 00:00:00 2001
From: Andy Waite <13400+andyw8@users.noreply.github.com>
Date: Tue, 7 Jan 2025 13:57:40 -0500
Subject: [PATCH 7/8] bundle lock --add-platform x64-mingw-ucrt

---
 Gemfile.lock | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/Gemfile.lock b/Gemfile.lock
index 453f00a1..dedfa492 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -133,6 +133,8 @@ GEM
       racc (~> 1.4)
     nokogiri (1.18.1-arm64-darwin)
       racc (~> 1.4)
+    nokogiri (1.18.1-x64-mingw-ucrt)
+      racc (~> 1.4)
     nokogiri (1.18.1-x86_64-darwin)
       racc (~> 1.4)
     nokogiri (1.18.1-x86_64-linux-gnu)
@@ -242,6 +244,7 @@ GEM
     sqlite3 (2.5.0-aarch64-linux-gnu)
     sqlite3 (2.5.0-aarch64-linux-musl)
     sqlite3 (2.5.0-arm64-darwin)
+    sqlite3 (2.5.0-x64-mingw-ucrt)
     sqlite3 (2.5.0-x86_64-darwin)
     sqlite3 (2.5.0-x86_64-linux-gnu)
     sqlite3 (2.5.0-x86_64-linux-musl)
@@ -260,6 +263,8 @@ GEM
     timeout (0.4.2)
     tzinfo (2.0.6)
       concurrent-ruby (~> 1.0)
+    tzinfo-data (1.2024.2)
+      tzinfo (>= 1.0.0)
     unicode-display_width (2.6.0)
     uri (1.0.1)
     useragent (0.16.10)
@@ -278,6 +283,7 @@ PLATFORMS
   aarch64-linux-musl
   arm64-darwin
   universal-darwin
+  x64-mingw-ucrt
   x86_64-darwin
   x86_64-linux
   x86_64-linux-gnu

From 5ba97d61e9712a788eae12c3d41dd9bbaadc987c Mon Sep 17 00:00:00 2001
From: Andy Waite <13400+andyw8@users.noreply.github.com>
Date: Wed, 22 Jan 2025 17:37:28 -0500
Subject: [PATCH 8/8] Fix bad rebase

---
 sorbet/rbi/gems/tapioca@0.16.6.rbi | 3628 ----------------------------
 sorbet/rbi/gems/tapioca@0.16.8.rbi |   30 -
 2 files changed, 3658 deletions(-)
 delete mode 100644 sorbet/rbi/gems/tapioca@0.16.6.rbi

diff --git a/sorbet/rbi/gems/tapioca@0.16.6.rbi b/sorbet/rbi/gems/tapioca@0.16.6.rbi
deleted file mode 100644
index fb3b20f4..00000000
--- a/sorbet/rbi/gems/tapioca@0.16.6.rbi
+++ /dev/null
@@ -1,3628 +0,0 @@
-# typed: true
-
-# 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 gem tapioca`.
-
-
-class Bundler::Dependency < ::Gem::Dependency
-  include ::Tapioca::BundlerExt::AutoRequireHook
-end
-
-# source://tapioca/lib/tapioca/helpers/git_attributes.rb#4
-class GitAttributes
-  class << self
-    # source://tapioca/lib/tapioca/helpers/git_attributes.rb#9
-    sig { params(path: ::Pathname).void }
-    def create_generated_attribute_file(path); end
-
-    # source://tapioca/lib/tapioca/helpers/git_attributes.rb#16
-    sig { params(path: ::Pathname).void }
-    def create_vendored_attribute_file(path); end
-
-    private
-
-    # source://tapioca/lib/tapioca/helpers/git_attributes.rb#25
-    sig { params(path: ::Pathname, content: ::String).void }
-    def create_gitattributes_file(path, content); end
-  end
-end
-
-# We need to do the alias-method-chain dance since Bootsnap does the same,
-# and prepended modules and alias-method-chain don't play well together.
-#
-# So, why does Bootsnap do alias-method-chain and not prepend? Glad you asked!
-# That's because RubyGems does alias-method-chain for Kernel#require and such,
-# so, if Bootsnap were to do prepend, it might end up breaking RubyGems.
-#
-# source://tapioca/lib/tapioca/runtime/trackers/autoload.rb#68
-class Module
-  # source://tapioca/lib/tapioca/runtime/trackers/mixin.rb#101
-  def append_features(constant); end
-
-  # source://tapioca/lib/tapioca/runtime/trackers/autoload.rb#71
-  def autoload(const_name, path); end
-
-  # source://tapioca/lib/tapioca/runtime/trackers/mixin.rb#111
-  def extend_object(obj); end
-
-  # source://tapioca/lib/tapioca/runtime/trackers/mixin.rb#91
-  def prepend_features(constant); end
-end
-
-# source://tapioca/lib/tapioca/rbi_ext/model.rb#4
-module RBI; end
-
-# source://tapioca/lib/tapioca/rbi_ext/model.rb#5
-class RBI::Tree < ::RBI::NodeWithComments
-  # source://rbi/0.2.3lib/rbi/model.rb#121
-  sig do
-    params(
-      loc: T.nilable(::RBI::Loc),
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::Tree).void)
-    ).void
-  end
-  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  # source://rbi/0.2.3lib/rbi/model.rb#128
-  sig { params(node: ::RBI::Node).void }
-  def <<(node); end
-
-  # source://rbi/0.2.3lib/rbi/rewriters/add_sig_templates.rb#66
-  sig { params(with_todo_comment: T::Boolean).void }
-  def add_sig_templates!(with_todo_comment: T.unsafe(nil)); end
-
-  # source://rbi/0.2.3lib/rbi/rewriters/annotate.rb#49
-  sig { params(annotation: ::String, annotate_scopes: T::Boolean, annotate_properties: T::Boolean).void }
-  def annotate!(annotation, annotate_scopes: T.unsafe(nil), annotate_properties: T.unsafe(nil)); end
-
-  # source://tapioca/lib/tapioca/rbi_ext/model.rb#38
-  sig do
-    params(
-      name: ::String,
-      superclass_name: T.nilable(::String),
-      block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)
-    ).returns(::RBI::Scope)
-  end
-  def create_class(name, superclass_name: T.unsafe(nil), &block); end
-
-  # source://tapioca/lib/tapioca/rbi_ext/model.rb#45
-  sig { params(name: ::String, value: ::String).void }
-  def create_constant(name, value:); end
-
-  # source://tapioca/lib/tapioca/rbi_ext/model.rb#55
-  sig { params(name: ::String).void }
-  def create_extend(name); end
-
-  # source://tapioca/lib/tapioca/rbi_ext/model.rb#50
-  sig { params(name: ::String).void }
-  def create_include(name); end
-
-  # source://tapioca/lib/tapioca/rbi_ext/model.rb#90
-  sig do
-    params(
-      name: ::String,
-      parameters: T::Array[::RBI::TypedParam],
-      return_type: T.nilable(::String),
-      class_method: T::Boolean,
-      visibility: ::RBI::Visibility,
-      comments: T::Array[::RBI::Comment],
-      block: T.nilable(T.proc.params(node: ::RBI::Method).void)
-    ).void
-  end
-  def create_method(name, parameters: T.unsafe(nil), return_type: T.unsafe(nil), class_method: T.unsafe(nil), visibility: T.unsafe(nil), comments: T.unsafe(nil), &block); end
-
-  # source://tapioca/lib/tapioca/rbi_ext/model.rb#60
-  sig { params(name: ::String).void }
-  def create_mixes_in_class_methods(name); end
-
-  # source://tapioca/lib/tapioca/rbi_ext/model.rb#25
-  sig { params(name: ::String, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).returns(::RBI::Scope) }
-  def create_module(name, &block); end
-
-  # source://tapioca/lib/tapioca/rbi_ext/model.rb#9
-  sig { params(constant: ::Module, block: T.nilable(T.proc.params(scope: ::RBI::Scope).void)).returns(::RBI::Scope) }
-  def create_path(constant, &block); end
-
-  # source://tapioca/lib/tapioca/rbi_ext/model.rb#74
-  sig do
-    params(
-      name: ::String,
-      type: ::String,
-      variance: ::Symbol,
-      fixed: T.nilable(::String),
-      upper: T.nilable(::String),
-      lower: T.nilable(::String)
-    ).void
-  end
-  def create_type_variable(name, type:, variance: T.unsafe(nil), fixed: T.unsafe(nil), upper: T.unsafe(nil), lower: T.unsafe(nil)); end
-
-  # source://rbi/0.2.3lib/rbi/rewriters/deannotate.rb#41
-  sig { params(annotation: ::String).void }
-  def deannotate!(annotation); end
-
-  # source://rbi/0.2.3lib/rbi/model.rb#134
-  sig { returns(T::Boolean) }
-  def empty?; end
-
-  # source://rbi/0.2.3lib/rbi/rewriters/filter_versions.rb#118
-  sig { params(version: ::Gem::Version).void }
-  def filter_versions!(version); end
-
-  # source://rbi/0.2.3lib/rbi/rewriters/flatten_singleton_methods.rb#60
-  sig { void }
-  def flatten_singleton_methods!; end
-
-  # source://rbi/0.2.3lib/rbi/rewriters/flatten_visibilities.rb#60
-  sig { void }
-  def flatten_visibilities!; end
-
-  # source://rbi/0.2.3lib/rbi/rewriters/group_nodes.rb#81
-  sig { void }
-  def group_nodes!; end
-
-  # source://rbi/0.2.3lib/rbi/index.rb#68
-  sig { returns(::RBI::Index) }
-  def index; end
-
-  # source://rbi/0.2.3lib/rbi/rewriters/merge_trees.rb#324
-  sig do
-    params(
-      other: ::RBI::Tree,
-      left_name: ::String,
-      right_name: ::String,
-      keep: ::RBI::Rewriters::Merge::Keep
-    ).returns(::RBI::MergeTree)
-  end
-  def merge(other, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
-
-  # source://rbi/0.2.3lib/rbi/rewriters/nest_non_public_members.rb#46
-  sig { void }
-  def nest_non_public_members!; end
-
-  # source://rbi/0.2.3lib/rbi/rewriters/nest_singleton_methods.rb#36
-  sig { void }
-  def nest_singleton_methods!; end
-
-  # source://rbi/0.2.3lib/rbi/rewriters/nest_top_level_members.rb#63
-  sig { void }
-  def nest_top_level_members!; end
-
-  # source://rbi/0.2.3lib/rbi/model.rb#112
-  sig { returns(T::Array[::RBI::Node]) }
-  def nodes; end
-
-  # source://rbi/0.2.3lib/rbi/rewriters/attr_to_methods.rb#53
-  sig { void }
-  def replace_attributes_with_methods!; end
-
-  # source://rbi/0.2.3lib/rbi/rewriters/sort_nodes.rb#119
-  sig { void }
-  def sort_nodes!; end
-
-  private
-
-  # source://tapioca/lib/tapioca/rbi_ext/model.rb#123
-  sig { params(node: ::RBI::Node).returns(::RBI::Node) }
-  def create_node(node); end
-
-  # source://tapioca/lib/tapioca/rbi_ext/model.rb#118
-  sig { returns(T::Hash[::String, ::RBI::Node]) }
-  def nodes_cache; end
-end
-
-# source://tapioca/lib/tapioca/rbi_ext/model.rb#133
-class RBI::TypedParam < ::T::Struct
-  const :param, ::RBI::Param
-  const :type, ::String
-
-  class << self
-<<<<<<<< HEAD:sorbet/rbi/gems/tapioca@0.16.8.rbi
-    # source://sorbet-runtime/0.5.11761lib/types/struct.rb#13
-|||||||| parent of 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.5.rbi
-    # source://sorbet-runtime/0.5.11635lib/types/struct.rb#13
-========
-    # source://sorbet-runtime/0.5.11725lib/types/struct.rb#13
->>>>>>>> 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.6.rbi
-    def inherited(s); end
-  end
-end
-
-# source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#5
-module T::Generic
-  include ::Kernel
-
-  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#13
-  def [](*types); end
-
-  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#47
-  def has_attached_class!(variance = T.unsafe(nil), &bounds_proc); end
-
-  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#21
-  def type_member(variance = T.unsafe(nil), &bounds_proc); end
-
-  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#34
-  def type_template(variance = T.unsafe(nil), &bounds_proc); end
-end
-
-# This module intercepts calls to generic type instantiations and type variable definitions.
-# Tapioca stores the data from those calls in a `GenericTypeRegistry` which can then be used
-# to look up the original call details when we are trying to do code generation.
-#
-# We are interested in the data of the `[]`, `type_member` and `type_template` calls which
-# are all needed to generate good generic information at runtime.
-#
-# source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#12
-module T::Generic::TypeStoragePatch
-  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#13
-  def [](*types); end
-
-  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#47
-  def has_attached_class!(variance = T.unsafe(nil), &bounds_proc); end
-
-  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#21
-  def type_member(variance = T.unsafe(nil), &bounds_proc); end
-
-  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#34
-  def type_template(variance = T.unsafe(nil), &bounds_proc); end
-end
-
-# source://tapioca/lib/tapioca/sorbet_ext/proc_bind_patch.rb#28
-module T::Private::Methods
-  class << self
-    # source://tapioca/lib/tapioca/sorbet_ext/proc_bind_patch.rb#30
-    def finalize_proc(decl); end
-  end
-end
-
-class T::Private::Methods::Declaration < ::Struct
-  def bind; end
-  def bind=(_); end
-  def checked; end
-  def checked=(_); end
-  def finalized; end
-  def finalized=(_); end
-  def mod; end
-  def mod=(_); end
-  def mode; end
-  def mode=(_); end
-  def on_failure; end
-  def on_failure=(_); end
-  def override_allow_incompatible; end
-  def override_allow_incompatible=(_); end
-  def params; end
-  def params=(_); end
-  def raw; end
-  def raw=(_); end
-  def returns; end
-  def returns=(_); end
-  def type_parameters; end
-  def type_parameters=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def keyword_init?; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-class T::Private::Methods::DeclarationBlock < ::Struct
-  def blk; end
-  def blk=(_); end
-  def final; end
-  def final=(_); end
-  def loc; end
-  def loc=(_); end
-  def mod; end
-  def mod=(_); end
-  def raw; end
-  def raw=(_); end
-
-  class << self
-    def [](*_arg0); end
-    def inspect; end
-    def keyword_init?; end
-    def members; end
-    def new(*_arg0); end
-  end
-end
-
-# source://tapioca/lib/tapioca/sorbet_ext/proc_bind_patch.rb#29
-module T::Private::Methods::ProcBindPatch
-  # source://tapioca/lib/tapioca/sorbet_ext/proc_bind_patch.rb#30
-  def finalize_proc(decl); end
-end
-
-class T::Types::Proc < ::T::Types::Base; end
-
-# source://tapioca/lib/tapioca/sorbet_ext/proc_bind_patch.rb#6
-module T::Types::ProcBindPatch
-  # source://tapioca/lib/tapioca/sorbet_ext/proc_bind_patch.rb#7
-  def initialize(arg_types, returns, bind = T.unsafe(nil)); end
-
-  # source://tapioca/lib/tapioca/sorbet_ext/proc_bind_patch.rb#15
-  def name; end
-end
-
-# source://tapioca/lib/tapioca/sorbet_ext/name_patch.rb#6
-class T::Types::Simple < ::T::Types::Base
-  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#70
-  def name; end
-end
-
-# source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#65
-module T::Types::Simple::GenericPatch
-  # This method intercepts calls to the `name` method for simple types, so that
-  # it can ask the name to the type if the type is generic, since, by this point,
-  # we've created a clone of that type with the `name` method returning the
-  # appropriate name for that specific concrete type.
-  #
-  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#70
-  def name; end
-end
-
-# source://tapioca/lib/tapioca/sorbet_ext/name_patch.rb#7
-module T::Types::Simple::NamePatch
-  # source://tapioca/lib/tapioca/sorbet_ext/name_patch.rb#10
-  def name; end
-
-  # source://tapioca/lib/tapioca/sorbet_ext/name_patch.rb#16
-  def qualified_name_of(constant); end
-end
-
-# source://tapioca/lib/tapioca/sorbet_ext/name_patch.rb#8
-T::Types::Simple::NamePatch::NAME_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#87
-module T::Utils::Private
-  class << self
-    # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#89
-    def coerce_and_check_module_types(val, check_val, check_module_type); end
-  end
-end
-
-# source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#88
-module T::Utils::Private::PrivateCoercePatch
-  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#89
-  def coerce_and_check_module_types(val, check_val, check_module_type); end
-end
-
-# source://tapioca/lib/tapioca/runtime/trackers/autoload.rb#4
-module Tapioca
-  class << self
-    # source://tapioca/lib/tapioca.rb#20
-    sig do
-      type_parameters(:Result)
-        .params(
-          blk: T.proc.returns(T.type_parameter(:Result))
-        ).returns(T.type_parameter(:Result))
-    end
-    def silence_warnings(&blk); end
-  end
-end
-
-# source://tapioca/lib/tapioca.rb#39
-Tapioca::BINARY_FILE = T.let(T.unsafe(nil), String)
-
-# source://tapioca/lib/tapioca/bundler_ext/auto_require_hook.rb#5
-module Tapioca::BundlerExt; end
-
-# This is a module that gets prepended to `Bundler::Dependency` and
-# makes sure even gems marked as `require: false` are required during
-# `Bundler.require`.
-#
-# source://tapioca/lib/tapioca/bundler_ext/auto_require_hook.rb#9
-module Tapioca::BundlerExt::AutoRequireHook
-  requires_ancestor { Bundler::Dependency }
-
-  # source://tapioca/lib/tapioca/bundler_ext/auto_require_hook.rb#46
-  sig { returns(T.untyped) }
-  def autorequire; end
-
-  class << self
-    # @return [Boolean]
-    #
-    # source://tapioca/lib/tapioca/bundler_ext/auto_require_hook.rb#26
-    def enabled?; end
-
-    # source://tapioca/lib/tapioca/bundler_ext/auto_require_hook.rb#22
-    sig { params(name: T.untyped).returns(T::Boolean) }
-    def excluded?(name); end
-
-    # source://tapioca/lib/tapioca/bundler_ext/auto_require_hook.rb#36
-    sig do
-      type_parameters(:Result)
-        .params(
-          exclude: T::Array[::String],
-          blk: T.proc.returns(T.type_parameter(:Result))
-        ).returns(T.type_parameter(:Result))
-    end
-    def override_require_false(exclude:, &blk); end
-  end
-end
-
-# source://tapioca/lib/tapioca.rb#62
-Tapioca::CENTRAL_REPO_ANNOTATIONS_DIR = T.let(T.unsafe(nil), String)
-
-# source://tapioca/lib/tapioca.rb#61
-Tapioca::CENTRAL_REPO_INDEX_PATH = T.let(T.unsafe(nil), String)
-
-# source://tapioca/lib/tapioca.rb#60
-Tapioca::CENTRAL_REPO_ROOT_URI = T.let(T.unsafe(nil), String)
-
-# source://tapioca/lib/tapioca/cli.rb#5
-class Tapioca::Cli < ::Thor
-  include ::Tapioca::CliHelper
-  include ::Tapioca::ConfigHelper
-  include ::Tapioca::EnvHelper
-
-  # source://tapioca/lib/tapioca/cli.rb#377
-  def __print_version; end
-
-  # source://tapioca/lib/tapioca/cli.rb#359
-  def annotations; end
-
-  # source://tapioca/lib/tapioca/cli.rb#331
-  def check_shims; end
-
-  # source://tapioca/lib/tapioca/cli.rb#46
-  def configure; end
-
-  # source://tapioca/lib/tapioca/cli.rb#151
-  def dsl(*constant_or_paths); end
-
-  # @raise [MalformattedArgumentError]
-  #
-  # source://tapioca/lib/tapioca/cli.rb#274
-  def gem(*gems); end
-
-  # source://tapioca/lib/tapioca/cli.rb#27
-  def init; end
-
-  # source://tapioca/lib/tapioca/cli.rb#57
-  def require; end
-
-  # source://tapioca/lib/tapioca/cli.rb#74
-  def todo; end
-
-  private
-
-  # source://tapioca/lib/tapioca/cli.rb#391
-  def print_init_next_steps; end
-
-  class << self
-    # source://tapioca/lib/tapioca/cli.rb#383
-    def exit_on_failure?; end
-  end
-end
-
-# source://tapioca/lib/tapioca/cli.rb#10
-Tapioca::Cli::FILE_HEADER_OPTION_DESC = T.let(T.unsafe(nil), String)
-
-# source://tapioca/lib/tapioca/helpers/cli_helper.rb#5
-module Tapioca::CliHelper
-  requires_ancestor { Thor::Shell }
-
-  # source://tapioca/lib/tapioca/helpers/cli_helper.rb#33
-  sig { params(options: T::Hash[::Symbol, T.untyped]).returns(T.nilable(::String)) }
-  def netrc_file(options); end
-
-  # source://tapioca/lib/tapioca/helpers/cli_helper.rb#26
-  sig { params(options: T::Hash[::Symbol, T.untyped]).returns(::Tapioca::RBIFormatter) }
-  def rbi_formatter(options); end
-
-  # source://tapioca/lib/tapioca/helpers/cli_helper.rb#12
-  sig { params(message: ::String, color: T.any(::Symbol, T::Array[::Symbol])).void }
-  def say_error(message = T.unsafe(nil), *color); end
-end
-
-# source://tapioca/lib/tapioca/commands.rb#5
-module Tapioca::Commands; end
-
-# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://tapioca/lib/tapioca/commands/abstract_dsl.rb#6
-class Tapioca::Commands::AbstractDsl < ::Tapioca::Commands::CommandWithoutTracker
-  include ::Tapioca::SorbetHelper
-  include ::Tapioca::RBIFilesHelper
-
-  abstract!
-
-  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#34
-  sig do
-    params(
-      requested_constants: T::Array[::String],
-      requested_paths: T::Array[::Pathname],
-      outpath: ::Pathname,
-      only: T::Array[::String],
-      exclude: T::Array[::String],
-      file_header: T::Boolean,
-      tapioca_path: ::String,
-      skip_constant: T::Array[::String],
-      quiet: T::Boolean,
-      verbose: T::Boolean,
-      number_of_workers: T.nilable(::Integer),
-      auto_strictness: T::Boolean,
-      gem_dir: ::String,
-      rbi_formatter: ::Tapioca::RBIFormatter,
-      app_root: ::String,
-      halt_upon_load_error: T::Boolean,
-      compiler_options: T::Hash[::String, T.untyped],
-      lsp_addon: T::Boolean
-    ).void
-  end
-  def initialize(requested_constants:, requested_paths:, outpath:, only:, exclude:, file_header:, tapioca_path:, skip_constant: T.unsafe(nil), quiet: T.unsafe(nil), verbose: T.unsafe(nil), number_of_workers: T.unsafe(nil), auto_strictness: T.unsafe(nil), gem_dir: T.unsafe(nil), rbi_formatter: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil), compiler_options: T.unsafe(nil), lsp_addon: T.unsafe(nil)); end
-
-  private
-
-  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#107
-  sig { returns(T::Array[::String]) }
-  def all_requested_constants; end
-
-  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#306
-  sig { params(cause: ::Symbol, files: T::Array[::String]).returns(::String) }
-  def build_error_for_files(cause, files); end
-
-  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#230
-  sig do
-    params(
-      constant_name: ::String,
-      rbi: ::RBI::File,
-      outpath: ::Pathname,
-      quiet: T::Boolean
-    ).returns(T.nilable(::Pathname))
-  end
-  def compile_dsl_rbi(constant_name, rbi, outpath: T.unsafe(nil), quiet: T.unsafe(nil)); end
-
-  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#165
-  sig { params(constant_names: T::Array[::String], ignore_missing: T::Boolean).returns(T::Array[::Module]) }
-  def constantize(constant_names, ignore_missing: T.unsafe(nil)); end
-
-  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#190
-  sig { params(compiler_names: T::Array[::String]).returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) }
-  def constantize_compilers(compiler_names); end
-
-  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#366
-  sig { returns(T::Array[::String]) }
-  def constants_from_requested_paths; end
-
-  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#133
-  sig { returns(::Tapioca::Dsl::Pipeline) }
-  def create_pipeline; end
-
-  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#269
-  sig { params(constant_name: ::String).returns(::Pathname) }
-  def dsl_rbi_filename(constant_name); end
-
-  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#151
-  sig { params(requested_constants: T::Array[::String], path: ::Pathname).returns(T::Set[::Pathname]) }
-  def existing_rbi_filenames(requested_constants, path: T.unsafe(nil)); end
-
-  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#361
-  sig { params(constant: ::String).returns(::String) }
-  def generate_command_for(constant); end
-
-  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#79
-  sig { params(outpath: ::Pathname, quiet: T::Boolean).returns(T::Set[::Pathname]) }
-  def generate_dsl_rbi_files(outpath, quiet:); end
-
-  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#120
-  sig { void }
-  def load_application; end
-
-  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#248
-  sig { params(dir: ::Pathname).void }
-  def perform_dsl_verification(dir); end
-
-  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#115
-  sig { returns(::Tapioca::Dsl::Pipeline) }
-  def pipeline; end
-
-  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#257
-  sig { params(files: T::Set[::Pathname]).void }
-  def purge_stale_dsl_rbi_files(files); end
-
-  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#356
-  sig { params(constant: ::String).returns(::String) }
-  def rbi_filename_for(constant); end
-
-  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#337
-  sig { params(path: ::Pathname).returns(T::Array[::Pathname]) }
-  def rbi_files_in(path); end
-
-  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#315
-  sig { params(diff: T::Hash[::String, ::Symbol], command: ::Symbol).void }
-  def report_diff_and_exit_if_out_of_date(diff, command); end
-
-  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#210
-  sig { params(name: ::String).returns(T.nilable(T.class_of(Tapioca::Dsl::Compiler))) }
-  def resolve(name); end
-
-  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#344
-  sig { params(class_name: ::String).returns(::String) }
-  def underscore(class_name); end
-
-  # source://tapioca/lib/tapioca/commands/abstract_dsl.rb#274
-  sig { params(tmp_dir: ::Pathname).returns(T::Hash[::String, ::Symbol]) }
-  def verify_dsl_rbi(tmp_dir:); end
-end
-
-# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://tapioca/lib/tapioca/commands/abstract_gem.rb#6
-class Tapioca::Commands::AbstractGem < ::Tapioca::Commands::Command
-  include ::Tapioca::SorbetHelper
-  include ::Tapioca::RBIFilesHelper
-
-  abstract!
-
-  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#33
-  sig do
-    params(
-      gem_names: T::Array[::String],
-      exclude: T::Array[::String],
-      include_dependencies: T::Boolean,
-      prerequire: T.nilable(::String),
-      postrequire: ::String,
-      typed_overrides: T::Hash[::String, ::String],
-      outpath: ::Pathname,
-      file_header: T::Boolean,
-      include_doc: T::Boolean,
-      include_loc: T::Boolean,
-      include_exported_rbis: T::Boolean,
-      number_of_workers: T.nilable(::Integer),
-      auto_strictness: T::Boolean,
-      dsl_dir: ::String,
-      rbi_formatter: ::Tapioca::RBIFormatter,
-      halt_upon_load_error: T::Boolean,
-      lsp_addon: T.nilable(T::Boolean)
-    ).void
-  end
-  def initialize(gem_names:, exclude:, include_dependencies:, prerequire:, postrequire:, typed_overrides:, outpath:, file_header:, include_doc:, include_loc:, include_exported_rbis:, number_of_workers: T.unsafe(nil), auto_strictness: T.unsafe(nil), dsl_dir: T.unsafe(nil), rbi_formatter: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil), lsp_addon: T.unsafe(nil)); end
-
-  private
-
-  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#200
-  sig { returns(T::Array[::String]) }
-  def added_rbis; end
-
-  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#261
-  sig { params(cause: ::Symbol, files: T::Array[::String]).returns(::String) }
-  def build_error_for_files(cause, files); end
-
-  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#80
-  sig { params(gem: ::Tapioca::Gemfile::GemSpec).void }
-  def compile_gem_rbi(gem); end
-
-  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#195
-  sig { params(gem_name: ::String).returns(::Pathname) }
-  def existing_rbi(gem_name); end
-
-  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#243
-  sig { returns(T::Hash[::String, ::String]) }
-  def existing_rbis; end
-
-  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#207
-  sig { params(gem_name: ::String).returns(::Pathname) }
-  def expected_rbi(gem_name); end
-
-  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#249
-  sig { returns(T::Hash[::String, ::String]) }
-  def expected_rbis; end
-
-  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#212
-  sig { params(gem_name: ::String).returns(T::Boolean) }
-  def gem_rbi_exists?(gem_name); end
-
-  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#256
-  sig { params(gem_name: ::String, version: ::String).returns(::Pathname) }
-  def gem_rbi_filename(gem_name, version); end
-
-  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#266
-  sig { params(gem: ::Tapioca::Gemfile::GemSpec, file: ::RBI::File).void }
-  def merge_with_exported_rbi(gem, file); end
-
-  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#237
-  sig { params(old_filename: ::Pathname, new_filename: ::Pathname).void }
-  def move(old_filename, new_filename); end
-
-  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#147
-  sig { void }
-  def perform_additions; end
-
-  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#120
-  sig { void }
-  def perform_removals; end
-
-  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#190
-  sig { returns(T::Array[::String]) }
-  def removed_rbis; end
-
-  # source://tapioca/lib/tapioca/commands/abstract_gem.rb#217
-  sig { params(diff: T::Hash[::String, ::Symbol], command: ::Symbol).void }
-  def report_diff_and_exit_if_out_of_date(diff, command); end
-end
-
-# source://tapioca/lib/tapioca/commands/annotations.rb#6
-class Tapioca::Commands::Annotations < ::Tapioca::Commands::CommandWithoutTracker
-  # source://tapioca/lib/tapioca/commands/annotations.rb#18
-  sig do
-    params(
-      central_repo_root_uris: T::Array[::String],
-      auth: T.nilable(::String),
-      netrc_file: T.nilable(::String),
-      central_repo_index_path: ::String,
-      typed_overrides: T::Hash[::String, ::String]
-    ).void
-  end
-  def initialize(central_repo_root_uris:, auth: T.unsafe(nil), netrc_file: T.unsafe(nil), central_repo_index_path: T.unsafe(nil), typed_overrides: T.unsafe(nil)); end
-
-  private
-
-  # source://tapioca/lib/tapioca/commands/annotations.rb#197
-  sig { params(name: ::String, content: ::String).returns(::String) }
-  def add_header(name, content); end
-
-  # source://tapioca/lib/tapioca/commands/annotations.rb#217
-  sig { params(name: ::String, content: ::String).returns(::String) }
-  def apply_typed_override(name, content); end
-
-  # source://tapioca/lib/tapioca/commands/annotations.rb#39
-  sig { override.void }
-  def execute; end
-
-  # source://tapioca/lib/tapioca/commands/annotations.rb#136
-  sig { params(repo_uris: T::Array[::String], gem_info: ::Tapioca::GemInfo).void }
-  def fetch_annotation(repo_uris, gem_info); end
-
-  # source://tapioca/lib/tapioca/commands/annotations.rb#113
-  sig { params(project_gems: T::Array[::Tapioca::GemInfo]).returns(T::Array[::String]) }
-  def fetch_annotations(project_gems); end
-
-  # source://tapioca/lib/tapioca/commands/annotations.rb#156
-  sig { params(repo_uri: ::String, path: ::String).returns(T.nilable(::String)) }
-  def fetch_file(repo_uri, path); end
-
-  # source://tapioca/lib/tapioca/commands/annotations.rb#173
-  sig { params(repo_uri: ::String, path: ::String).returns(T.nilable(::String)) }
-  def fetch_http_file(repo_uri, path); end
-
-  # source://tapioca/lib/tapioca/commands/annotations.rb#102
-  sig { params(repo_uri: ::String, repo_number: T.nilable(::Integer)).returns(T.nilable(Tapioca::RepoIndex)) }
-  def fetch_index(repo_uri, repo_number:); end
-
-  # source://tapioca/lib/tapioca/commands/annotations.rb#81
-  sig { returns(T::Hash[::String, Tapioca::RepoIndex]) }
-  def fetch_indexes; end
-
-  # source://tapioca/lib/tapioca/commands/annotations.rb#165
-  sig { params(repo_uri: ::String, path: ::String).returns(T.nilable(::String)) }
-  def fetch_local_file(repo_uri, path); end
-
-  # source://tapioca/lib/tapioca/commands/annotations.rb#229
-  sig { params(gem_version: ::Gem::Version, content: ::String).returns(::String) }
-  def filter_versions(gem_version, content); end
-
-  # source://tapioca/lib/tapioca/commands/annotations.rb#50
-  sig { returns(T::Array[::Tapioca::GemInfo]) }
-  def list_gemfile_gems; end
-
-  # source://tapioca/lib/tapioca/commands/annotations.rb#237
-  sig { params(gem_name: ::String, contents: T::Array[::String]).returns(T.nilable(::String)) }
-  def merge_files(gem_name, contents); end
-
-  # source://tapioca/lib/tapioca/commands/annotations.rb#60
-  sig { params(project_gems: T::Array[::Tapioca::GemInfo]).void }
-  def remove_expired_annotations(project_gems); end
-
-  # source://tapioca/lib/tapioca/commands/annotations.rb#264
-  sig { returns(T::Hash[::String, T.nilable(::String)]) }
-  def repo_tokens; end
-
-  # source://tapioca/lib/tapioca/commands/annotations.rb#292
-  sig { params(path: ::String, repo_uri: ::String, message: ::String).void }
-  def say_http_error(path, repo_uri, message:); end
-
-  # source://tapioca/lib/tapioca/commands/annotations.rb#276
-  sig { params(repo_uri: ::String).returns(T.nilable(::String)) }
-  def token_for(repo_uri); end
-end
-
-# source://tapioca/lib/tapioca/commands/check_shims.rb#6
-class Tapioca::Commands::CheckShims < ::Tapioca::Commands::CommandWithoutTracker
-  include ::Tapioca::SorbetHelper
-  include ::Tapioca::RBIFilesHelper
-
-  # source://tapioca/lib/tapioca/commands/check_shims.rb#22
-  sig do
-    params(
-      gem_rbi_dir: ::String,
-      dsl_rbi_dir: ::String,
-      annotations_rbi_dir: ::String,
-      shim_rbi_dir: ::String,
-      todo_rbi_file: ::String,
-      payload: T::Boolean,
-      number_of_workers: T.nilable(::Integer)
-    ).void
-  end
-  def initialize(gem_rbi_dir:, dsl_rbi_dir:, annotations_rbi_dir:, shim_rbi_dir:, todo_rbi_file:, payload:, number_of_workers:); end
-
-  private
-
-  # source://tapioca/lib/tapioca/commands/check_shims.rb#44
-  sig { override.void }
-  def execute; end
-end
-
-# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://tapioca/lib/tapioca/commands/command.rb#6
-class Tapioca::Commands::Command
-  include ::Thor::Base
-  include ::Thor::Invocation
-  include ::Thor::Shell
-  include ::Tapioca::CliHelper
-  extend ::Thor::Base::ClassMethods
-  extend ::Thor::Invocation::ClassMethods
-
-  abstract!
-
-  # source://tapioca/lib/tapioca/commands/command.rb#20
-  sig { void }
-  def initialize; end
-
-  # source://thor/1.3.2lib/thor/base.rb#155
-  sig { returns(::Thor::Actions) }
-  def file_writer; end
-
-  # source://tapioca/lib/tapioca/commands/command.rb#25
-  sig(:final) { void }
-  def run; end
-
-  private
-
-  # source://tapioca/lib/tapioca/commands/command.rb#53
-  sig do
-    params(
-      path: T.any(::Pathname, ::String),
-      content: ::String,
-      force: T::Boolean,
-      skip: T::Boolean,
-      verbose: T::Boolean
-    ).void
-  end
-  def create_file(path, content, force: T.unsafe(nil), skip: T.unsafe(nil), verbose: T.unsafe(nil)); end
-
-  # source://tapioca/lib/tapioca/commands/command.rb#37
-  sig { params(command: ::Symbol, args: ::String).returns(::String) }
-  def default_command(command, *args); end
-
-  # @abstract
-  #
-  # source://tapioca/lib/tapioca/commands/command.rb#34
-  sig { abstract.void }
-  def execute; end
-
-  # source://tapioca/lib/tapioca/commands/command.rb#63
-  sig { params(path: T.any(::Pathname, ::String), verbose: T::Boolean).void }
-  def remove_file(path, verbose: T.unsafe(nil)); end
-end
-
-# source://tapioca/lib/tapioca/commands/command.rb#10
-class Tapioca::Commands::Command::FileWriter < ::Thor
-  include ::Thor::Actions
-  extend ::Thor::Actions::ClassMethods
-end
-
-# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://tapioca/lib/tapioca/commands/command_without_tracker.rb#6
-class Tapioca::Commands::CommandWithoutTracker < ::Tapioca::Commands::Command
-  abstract!
-
-  # source://tapioca/lib/tapioca/commands/command_without_tracker.rb#12
-  sig { void }
-  def initialize; end
-end
-
-# source://tapioca/lib/tapioca/commands/configure.rb#6
-class Tapioca::Commands::Configure < ::Tapioca::Commands::CommandWithoutTracker
-  # source://tapioca/lib/tapioca/commands/configure.rb#14
-  sig { params(sorbet_config: ::String, tapioca_config: ::String, default_postrequire: ::String).void }
-  def initialize(sorbet_config:, tapioca_config:, default_postrequire:); end
-
-  private
-
-  # source://tapioca/lib/tapioca/commands/configure.rb#79
-  sig { void }
-  def create_binstub; end
-
-  # source://tapioca/lib/tapioca/commands/configure.rb#69
-  sig { void }
-  def create_post_require; end
-
-  # source://tapioca/lib/tapioca/commands/configure.rb#40
-  sig { void }
-  def create_sorbet_config; end
-
-  # source://tapioca/lib/tapioca/commands/configure.rb#50
-  sig { void }
-  def create_tapioca_config; end
-
-  # source://tapioca/lib/tapioca/commands/configure.rb#32
-  sig { override.void }
-  def execute; end
-
-  # source://tapioca/lib/tapioca/commands/configure.rb#92
-  sig { returns(::Bundler::Installer) }
-  def installer; end
-
-  # source://tapioca/lib/tapioca/commands/configure.rb#97
-  sig { returns(T.any(::Bundler::StubSpecification, ::Gem::Specification)) }
-  def spec; end
-end
-
-# source://tapioca/lib/tapioca/commands/dsl_compiler_list.rb#6
-class Tapioca::Commands::DslCompilerList < ::Tapioca::Commands::AbstractDsl
-  private
-
-  # source://tapioca/lib/tapioca/commands/dsl_compiler_list.rb#10
-  sig { override.void }
-  def execute; end
-end
-
-# source://tapioca/lib/tapioca/commands/dsl_generate.rb#6
-class Tapioca::Commands::DslGenerate < ::Tapioca::Commands::AbstractDsl
-  private
-
-  # source://tapioca/lib/tapioca/commands/dsl_generate.rb#10
-  sig { override.void }
-  def execute; end
-end
-
-# source://tapioca/lib/tapioca/commands/dsl_verify.rb#6
-class Tapioca::Commands::DslVerify < ::Tapioca::Commands::AbstractDsl
-  private
-
-  # source://tapioca/lib/tapioca/commands/dsl_verify.rb#10
-  sig { override.void }
-  def execute; end
-end
-
-# source://tapioca/lib/tapioca/commands/gem_generate.rb#6
-class Tapioca::Commands::GemGenerate < ::Tapioca::Commands::AbstractGem
-  private
-
-  # source://tapioca/lib/tapioca/commands/gem_generate.rb#10
-  sig { override.void }
-  def execute; end
-
-  # source://tapioca/lib/tapioca/commands/gem_generate.rb#74
-  sig do
-    params(
-      gem: ::Tapioca::Gemfile::GemSpec,
-      dependencies: T::Array[::Tapioca::Gemfile::GemSpec]
-    ).returns(T::Array[::Tapioca::Gemfile::GemSpec])
-  end
-  def gem_dependencies(gem, dependencies = T.unsafe(nil)); end
-
-  # source://tapioca/lib/tapioca/commands/gem_generate.rb#51
-  sig { params(gem_names: T::Array[::String]).returns(T::Array[::Tapioca::Gemfile::GemSpec]) }
-  def gems_to_generate(gem_names); end
-end
-
-# source://tapioca/lib/tapioca/commands/gem_sync.rb#6
-class Tapioca::Commands::GemSync < ::Tapioca::Commands::AbstractGem
-  private
-
-  # source://tapioca/lib/tapioca/commands/gem_sync.rb#10
-  sig { override.void }
-  def execute; end
-end
-
-# source://tapioca/lib/tapioca/commands/gem_verify.rb#6
-class Tapioca::Commands::GemVerify < ::Tapioca::Commands::AbstractGem
-  private
-
-  # source://tapioca/lib/tapioca/commands/gem_verify.rb#10
-  sig { override.void }
-  def execute; end
-
-  # source://tapioca/lib/tapioca/commands/gem_verify.rb#17
-  sig { void }
-  def perform_sync_verification; end
-end
-
-# source://tapioca/lib/tapioca/commands/require.rb#6
-class Tapioca::Commands::Require < ::Tapioca::Commands::CommandWithoutTracker
-  # source://tapioca/lib/tapioca/commands/require.rb#13
-  sig { params(requires_path: ::String, sorbet_config_path: ::String).void }
-  def initialize(requires_path:, sorbet_config_path:); end
-
-  private
-
-  # source://tapioca/lib/tapioca/commands/require.rb#23
-  sig { override.void }
-  def execute; end
-end
-
-# source://tapioca/lib/tapioca/commands/todo.rb#6
-class Tapioca::Commands::Todo < ::Tapioca::Commands::CommandWithoutTracker
-  include ::Tapioca::SorbetHelper
-
-  # source://tapioca/lib/tapioca/commands/todo.rb#26
-  sig { params(todo_file: ::String, file_header: T::Boolean).void }
-  def initialize(todo_file:, file_header:); end
-
-  # source://tapioca/lib/tapioca/commands/todo.rb#34
-  sig { void }
-  def run_with_deprecation; end
-
-  private
-
-  # source://tapioca/lib/tapioca/commands/todo.rb#44
-  sig { override.void }
-  def execute; end
-
-  # source://tapioca/lib/tapioca/commands/todo.rb#68
-  sig { params(constants: T::Array[::String], command: ::String).returns(::RBI::File) }
-  def rbi(constants, command:); end
-
-  # source://tapioca/lib/tapioca/commands/todo.rb#88
-  sig { returns(T::Array[::String]) }
-  def unresolved_constants; end
-end
-
-# source://tapioca/lib/tapioca/commands/todo.rb#9
-Tapioca::Commands::Todo::DEPRECATION_MESSAGE = T.let(T.unsafe(nil), String)
-
-# source://tapioca/lib/tapioca/helpers/config_helper.rb#5
-module Tapioca::ConfigHelper
-  requires_ancestor { Thor }
-
-  # source://tapioca/lib/tapioca/helpers/config_helper.rb#18
-  sig { params(args: T.untyped, local_options: T.untyped, config: T.untyped).void }
-  def initialize(args = T.unsafe(nil), local_options = T.unsafe(nil), config = T.unsafe(nil)); end
-
-  # source://tapioca/lib/tapioca/helpers/config_helper.rb#12
-  sig { returns(::String) }
-  def command_name; end
-
-  # source://tapioca/lib/tapioca/helpers/config_helper.rb#15
-  sig { returns(::Thor::CoreExt::HashWithIndifferentAccess) }
-  def defaults; end
-
-  # source://tapioca/lib/tapioca/helpers/config_helper.rb#34
-  sig { returns(::Thor::CoreExt::HashWithIndifferentAccess) }
-  def options; end
-
-  private
-
-  # source://tapioca/lib/tapioca/helpers/config_helper.rb#153
-  sig { params(msg: ::String).returns(::Tapioca::ConfigHelper::ConfigError) }
-  def build_error(msg); end
-
-  # source://tapioca/lib/tapioca/helpers/config_helper.rb#178
-  sig { params(config_file: ::String, errors: T::Array[::Tapioca::ConfigHelper::ConfigError]).returns(::String) }
-  def build_error_message(config_file, errors); end
-
-  # source://tapioca/lib/tapioca/helpers/config_helper.rb#56
-  sig do
-    params(
-      options: ::Thor::CoreExt::HashWithIndifferentAccess
-    ).returns(::Thor::CoreExt::HashWithIndifferentAccess)
-  end
-  def config_options(options); end
-
-  # source://tapioca/lib/tapioca/helpers/config_helper.rb#46
-  sig { params(options: T::Hash[::Symbol, ::Thor::Option]).void }
-  def filter_defaults(options); end
-
-  # source://tapioca/lib/tapioca/helpers/config_helper.rb#196
-  sig do
-    params(
-      options: T.nilable(::Thor::CoreExt::HashWithIndifferentAccess)
-    ).returns(::Thor::CoreExt::HashWithIndifferentAccess)
-  end
-  def merge_options(*options); end
-
-  # source://tapioca/lib/tapioca/helpers/config_helper.rb#70
-  sig { params(config_file: ::String, config: T::Hash[T.untyped, T.untyped]).void }
-  def validate_config!(config_file, config); end
-
-  # source://tapioca/lib/tapioca/helpers/config_helper.rb#102
-  sig do
-    params(
-      command_options: T::Hash[::Symbol, ::Thor::Option],
-      config_key: ::String,
-      config_options: T::Hash[T.untyped, T.untyped]
-    ).returns(T::Array[::Tapioca::ConfigHelper::ConfigError])
-  end
-  def validate_config_options(command_options, config_key, config_options); end
-end
-
-# source://tapioca/lib/tapioca/helpers/config_helper.rb#148
-class Tapioca::ConfigHelper::ConfigError < ::T::Struct
-  const :message_parts, T::Array[::Tapioca::ConfigHelper::ConfigErrorMessagePart]
-
-  class << self
-<<<<<<<< HEAD:sorbet/rbi/gems/tapioca@0.16.8.rbi
-    # source://sorbet-runtime/0.5.11761lib/types/struct.rb#13
-|||||||| parent of 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.5.rbi
-    # source://sorbet-runtime/0.5.11635lib/types/struct.rb#13
-========
-    # source://sorbet-runtime/0.5.11725lib/types/struct.rb#13
->>>>>>>> 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.6.rbi
-    def inherited(s); end
-  end
-end
-
-# source://tapioca/lib/tapioca/helpers/config_helper.rb#143
-class Tapioca::ConfigHelper::ConfigErrorMessagePart < ::T::Struct
-  const :message, ::String
-  const :colors, T::Array[::Symbol]
-
-  class << self
-<<<<<<<< HEAD:sorbet/rbi/gems/tapioca@0.16.8.rbi
-    # source://sorbet-runtime/0.5.11761lib/types/struct.rb#13
-|||||||| parent of 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.5.rbi
-    # source://sorbet-runtime/0.5.11635lib/types/struct.rb#13
-========
-    # source://sorbet-runtime/0.5.11725lib/types/struct.rb#13
->>>>>>>> 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.6.rbi
-    def inherited(s); end
-  end
-end
-
-# source://tapioca/lib/tapioca.rb#46
-Tapioca::DEFAULT_ANNOTATIONS_DIR = T.let(T.unsafe(nil), String)
-
-# source://tapioca/lib/tapioca.rb#42
-Tapioca::DEFAULT_DSL_DIR = T.let(T.unsafe(nil), String)
-
-# source://tapioca/lib/tapioca.rb#58
-Tapioca::DEFAULT_ENVIRONMENT = T.let(T.unsafe(nil), String)
-
-# source://tapioca/lib/tapioca.rb#43
-Tapioca::DEFAULT_GEM_DIR = T.let(T.unsafe(nil), String)
-
-# source://tapioca/lib/tapioca.rb#48
-Tapioca::DEFAULT_OVERRIDES = T.let(T.unsafe(nil), Hash)
-
-# source://tapioca/lib/tapioca.rb#40
-Tapioca::DEFAULT_POSTREQUIRE_FILE = T.let(T.unsafe(nil), String)
-
-# source://tapioca/lib/tapioca.rb#41
-Tapioca::DEFAULT_RBI_DIR = T.let(T.unsafe(nil), String)
-
-# source://tapioca/lib/tapioca/rbi_formatter.rb#31
-Tapioca::DEFAULT_RBI_FORMATTER = T.let(T.unsafe(nil), Tapioca::RBIFormatter)
-
-# source://tapioca/lib/tapioca.rb#57
-Tapioca::DEFAULT_RBI_MAX_LINE_LENGTH = T.let(T.unsafe(nil), Integer)
-
-# source://tapioca/lib/tapioca.rb#44
-Tapioca::DEFAULT_SHIM_DIR = T.let(T.unsafe(nil), String)
-
-# source://tapioca/lib/tapioca.rb#45
-Tapioca::DEFAULT_TODO_FILE = T.let(T.unsafe(nil), String)
-
-# source://tapioca/lib/tapioca/dsl/compilers.rb#5
-module Tapioca::Dsl; end
-
-# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://tapioca/lib/tapioca/dsl/compiler.rb#6
-class Tapioca::Dsl::Compiler
-  extend T::Generic
-  include ::Tapioca::SorbetHelper
-  include ::Tapioca::RBIHelper
-  include ::Tapioca::Runtime::AttachedClassOf
-  include ::Tapioca::Runtime::Reflection
-  extend ::Tapioca::Runtime::AttachedClassOf
-  extend ::Tapioca::Runtime::Reflection
-
-  abstract!
-
-  ConstantType = type_member { { upper: Module } }
-
-  # source://tapioca/lib/tapioca/dsl/compiler.rb#110
-  sig do
-    params(
-      pipeline: ::Tapioca::Dsl::Pipeline,
-      root: ::RBI::Tree,
-      constant: ConstantType,
-      options: T::Hash[::String, T.untyped]
-    ).void
-  end
-  def initialize(pipeline, root, constant, options = T.unsafe(nil)); end
-
-  # NOTE: This should eventually accept an `Error` object or `Exception` rather than simply a `String`.
-  #
-  # source://tapioca/lib/tapioca/dsl/compiler.rb#128
-  sig { params(error: ::String).void }
-  def add_error(error); end
-
-  # source://tapioca/lib/tapioca/dsl/compiler.rb#119
-  sig { params(compiler_name: ::String).returns(T::Boolean) }
-  def compiler_enabled?(compiler_name); end
-
-  # source://tapioca/lib/tapioca/dsl/compiler.rb#20
-  sig { returns(ConstantType) }
-  def constant; end
-
-  # @abstract
-  #
-  # source://tapioca/lib/tapioca/dsl/compiler.rb#124
-  sig { abstract.void }
-  def decorate; end
-
-  # source://tapioca/lib/tapioca/dsl/compiler.rb#26
-  sig { returns(T::Hash[::String, T.untyped]) }
-  def options; end
-
-  # source://tapioca/lib/tapioca/dsl/compiler.rb#23
-  sig { returns(::RBI::Tree) }
-  def root; end
-
-  private
-
-  # source://tapioca/lib/tapioca/dsl/compiler.rb#177
-  sig { params(method_def: T.any(::Method, ::UnboundMethod)).returns(T::Array[::RBI::TypedParam]) }
-  def compile_method_parameters_to_rbi(method_def); end
-
-  # source://tapioca/lib/tapioca/dsl/compiler.rb#213
-  sig { params(method_def: T.any(::Method, ::UnboundMethod)).returns(::String) }
-  def compile_method_return_type_to_rbi(method_def); end
-
-  # source://tapioca/lib/tapioca/dsl/compiler.rb#167
-  sig { params(scope: ::RBI::Scope, method_def: T.any(::Method, ::UnboundMethod), class_method: T::Boolean).void }
-  def create_method_from_def(scope, method_def, class_method: T.unsafe(nil)); end
-
-  # Get the types of each parameter from a method signature
-  #
-  # source://tapioca/lib/tapioca/dsl/compiler.rb#141
-  sig { params(method_def: T.any(::Method, ::UnboundMethod), signature: T.untyped).returns(T::Array[::String]) }
-  def parameters_types_from_signature(method_def, signature); end
-
-  class << self
-    # @abstract
-    #
-    # source://tapioca/lib/tapioca/dsl/compiler.rb#39
-    sig { abstract.returns(T::Enumerable[::Module]) }
-    def gather_constants; end
-
-    # source://tapioca/lib/tapioca/dsl/compiler.rb#34
-    sig { params(constant: ::Module).returns(T::Boolean) }
-    def handles?(constant); end
-
-    # source://tapioca/lib/tapioca/dsl/compiler.rb#42
-    sig { returns(T::Set[::Module]) }
-    def processable_constants; end
-
-    # source://tapioca/lib/tapioca/dsl/compiler.rb#50
-    sig { params(constants: T::Array[::Module]).void }
-    def requested_constants=(constants); end
-
-    # source://tapioca/lib/tapioca/dsl/compiler.rb#55
-    sig { void }
-    def reset_state; end
-
-    private
-
-    # source://tapioca/lib/tapioca/dsl/compiler.rb#82
-    sig { returns(T::Enumerable[T::Class[T.anything]]) }
-    def all_classes; end
-
-    # source://tapioca/lib/tapioca/dsl/compiler.rb#90
-    sig { returns(T::Enumerable[::Module]) }
-    def all_modules; end
-
-    # source://tapioca/lib/tapioca/dsl/compiler.rb#68
-    sig do
-      type_parameters(:U)
-        .params(
-          klass: T.all(T.type_parameter(:U), T::Class[T.anything])
-        ).returns(T::Array[T.type_parameter(:U)])
-    end
-    def descendants_of(klass); end
-  end
-end
-
-# source://tapioca/lib/tapioca/dsl/compilers.rb#6
-module Tapioca::Dsl::Compilers; end
-
-# DSL compilers are either built-in to Tapioca and live under the
-# `Tapioca::Dsl::Compilers` namespace (i.e. this namespace), and
-# can be referred to by just using the class name, or they live in
-# a different namespace and can only be referred to using their fully
-# qualified name. This constant encapsulates that dual lookup when
-# a compiler needs to be resolved by name.
-#
-# source://tapioca/lib/tapioca/dsl/compilers.rb#13
-Tapioca::Dsl::Compilers::NAMESPACES = T.let(T.unsafe(nil), Array)
-
-# source://tapioca/lib/tapioca/dsl/pipeline.rb#6
-class Tapioca::Dsl::Pipeline
-  # source://tapioca/lib/tapioca/dsl/pipeline.rb#40
-  sig do
-    params(
-      requested_constants: T::Array[::Module],
-      requested_paths: T::Array[::Pathname],
-      requested_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)],
-      excluded_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)],
-      error_handler: T.proc.params(error: ::String).void,
-      skipped_constants: T::Array[::Module],
-      number_of_workers: T.nilable(::Integer),
-      compiler_options: T::Hash[::String, T.untyped],
-      lsp_addon: T::Boolean
-    ).void
-  end
-  def initialize(requested_constants:, requested_paths: T.unsafe(nil), requested_compilers: T.unsafe(nil), excluded_compilers: T.unsafe(nil), error_handler: T.unsafe(nil), skipped_constants: T.unsafe(nil), number_of_workers: T.unsafe(nil), compiler_options: T.unsafe(nil), lsp_addon: T.unsafe(nil)); end
-
-  # source://tapioca/lib/tapioca/dsl/pipeline.rb#10
-  sig { returns(T::Enumerable[T.class_of(Tapioca::Dsl::Compiler)]) }
-  def active_compilers; end
-
-  # source://tapioca/lib/tapioca/dsl/pipeline.rb#105
-  sig { params(error: ::String).void }
-  def add_error(error); end
-
-  # source://tapioca/lib/tapioca/dsl/pipeline.rb#110
-  sig { params(compiler_name: ::String).returns(T::Boolean) }
-  def compiler_enabled?(compiler_name); end
-
-  # source://tapioca/lib/tapioca/dsl/pipeline.rb#119
-  sig { returns(T::Array[T.class_of(Tapioca::Dsl::Compiler)]) }
-  def compilers; end
-
-  # source://tapioca/lib/tapioca/dsl/pipeline.rb#22
-  sig { returns(T.proc.params(error: ::String).void) }
-  def error_handler; end
-
-  # source://tapioca/lib/tapioca/dsl/pipeline.rb#25
-  sig { returns(T::Array[::String]) }
-  def errors; end
-
-  # source://tapioca/lib/tapioca/dsl/pipeline.rb#13
-  sig { returns(T::Array[::Module]) }
-  def requested_constants; end
-
-  # source://tapioca/lib/tapioca/dsl/pipeline.rb#16
-  sig { returns(T::Array[::Pathname]) }
-  def requested_paths; end
-
-  # source://tapioca/lib/tapioca/dsl/pipeline.rb#70
-  sig do
-    type_parameters(:T)
-      .params(
-        blk: T.proc.params(constant: ::Module, rbi: ::RBI::File).returns(T.type_parameter(:T))
-      ).returns(T::Array[T.type_parameter(:T)])
-  end
-  def run(&blk); end
-
-  # source://tapioca/lib/tapioca/dsl/pipeline.rb#19
-  sig { returns(T::Array[::Module]) }
-  def skipped_constants; end
-
-  private
-
-  # source://tapioca/lib/tapioca/dsl/pipeline.rb#227
-  sig { void }
-  def abort_if_pending_migrations!; end
-
-  # source://tapioca/lib/tapioca/dsl/pipeline.rb#172
-  sig { params(constants: T::Set[::Module]).returns(T::Set[::Module]) }
-  def filter_anonymous_and_reloaded_constants(constants); end
-
-  # source://tapioca/lib/tapioca/dsl/pipeline.rb#136
-  sig do
-    params(
-      requested_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)],
-      excluded_compilers: T::Array[T.class_of(Tapioca::Dsl::Compiler)]
-    ).returns(T::Enumerable[T.class_of(Tapioca::Dsl::Compiler)])
-  end
-  def gather_active_compilers(requested_compilers, excluded_compilers); end
-
-  # source://tapioca/lib/tapioca/dsl/pipeline.rb#150
-  sig do
-    params(
-      requested_constants: T::Array[::Module],
-      requested_paths: T::Array[::Pathname],
-      skipped_constants: T::Array[::Module]
-    ).returns(T::Set[::Module])
-  end
-  def gather_constants(requested_constants, requested_paths, skipped_constants); end
-
-  # source://tapioca/lib/tapioca/dsl/pipeline.rb#201
-  sig { params(constant: ::Module).returns(T.nilable(::RBI::File)) }
-  def rbi_for_constant(constant); end
-
-  # source://tapioca/lib/tapioca/dsl/pipeline.rb#220
-  sig { params(error: ::String).returns(T.noreturn) }
-  def report_error(error); end
-end
-
-# source://tapioca/lib/tapioca/helpers/env_helper.rb#5
-module Tapioca::EnvHelper
-  requires_ancestor { Thor }
-
-  # source://tapioca/lib/tapioca/helpers/env_helper.rb#12
-  sig { params(options: T::Hash[::Symbol, T.untyped]).void }
-  def set_environment(options); end
-end
-
-class Tapioca::Error < ::StandardError; end
-
-# source://tapioca/lib/tapioca/executor.rb#5
-class Tapioca::Executor
-  # source://tapioca/lib/tapioca/executor.rb#11
-  sig { params(queue: T::Array[T.untyped], number_of_workers: T.nilable(::Integer)).void }
-  def initialize(queue, number_of_workers: T.unsafe(nil)); end
-
-  # source://tapioca/lib/tapioca/executor.rb#28
-  sig do
-    type_parameters(:T)
-      .params(
-        block: T.proc.params(item: T.untyped).returns(T.type_parameter(:T))
-      ).returns(T::Array[T.type_parameter(:T)])
-  end
-  def run_in_parallel(&block); end
-
-  private
-
-  # source://tapioca/lib/tapioca/executor.rb#37
-  sig { returns(::Integer) }
-  def max_processors; end
-end
-
-# source://tapioca/lib/tapioca/executor.rb#8
-Tapioca::Executor::MINIMUM_ITEMS_PER_WORKER = T.let(T.unsafe(nil), Integer)
-
-# source://tapioca/lib/tapioca/gem/events.rb#5
-module Tapioca::Gem; end
-
-# source://tapioca/lib/tapioca/gem/events.rb#77
-class Tapioca::Gem::ConstNodeAdded < ::Tapioca::Gem::NodeAdded
-  # source://tapioca/lib/tapioca/gem/events.rb#84
-  sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Const).void }
-  def initialize(symbol, constant, node); end
-
-  # source://tapioca/lib/tapioca/gem/events.rb#81
-  sig { returns(::RBI::Const) }
-  def node; end
-end
-
-# source://tapioca/lib/tapioca/gem/events.rb#26
-class Tapioca::Gem::ConstantFound < ::Tapioca::Gem::Event
-  # source://tapioca/lib/tapioca/gem/events.rb#36
-  sig { params(symbol: ::String, constant: ::BasicObject).void }
-  def initialize(symbol, constant); end
-
-  # source://tapioca/lib/tapioca/gem/events.rb#33
-  sig { returns(::BasicObject) }
-  def constant; end
-
-  # source://tapioca/lib/tapioca/gem/events.rb#30
-  sig { returns(::String) }
-  def symbol; end
-end
-
-# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://tapioca/lib/tapioca/gem/events.rb#6
-class Tapioca::Gem::Event
-  abstract!
-end
-
-# source://tapioca/lib/tapioca/gem/events.rb#43
-class Tapioca::Gem::ForeignConstantFound < ::Tapioca::Gem::ConstantFound
-  # source://tapioca/lib/tapioca/gem/events.rb#52
-  sig { params(symbol: ::String, constant: ::Module).void }
-  def initialize(symbol, constant); end
-
-  # source://tapioca/lib/tapioca/gem/events.rb#47
-  sig { override.returns(::Module) }
-  def constant; end
-end
-
-# source://tapioca/lib/tapioca/gem/events.rb#103
-class Tapioca::Gem::ForeignScopeNodeAdded < ::Tapioca::Gem::ScopeNodeAdded; end
-
-# source://tapioca/lib/tapioca/gem/listeners/base.rb#6
-module Tapioca::Gem::Listeners; end
-
-# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://tapioca/lib/tapioca/gem/listeners/base.rb#7
-class Tapioca::Gem::Listeners::Base
-  abstract!
-
-  # source://tapioca/lib/tapioca/gem/listeners/base.rb#14
-  sig { params(pipeline: ::Tapioca::Gem::Pipeline).void }
-  def initialize(pipeline); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/base.rb#19
-  sig { params(event: ::Tapioca::Gem::NodeAdded).void }
-  def dispatch(event); end
-
-  private
-
-  # source://tapioca/lib/tapioca/gem/listeners/base.rb#49
-  sig { params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
-  def ignore?(event); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/base.rb#37
-  sig { params(event: ::Tapioca::Gem::ConstNodeAdded).void }
-  def on_const(event); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/base.rb#45
-  sig { params(event: ::Tapioca::Gem::MethodNodeAdded).void }
-  def on_method(event); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/base.rb#41
-  sig { params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-# source://tapioca/lib/tapioca/gem/listeners/dynamic_mixins.rb#7
-class Tapioca::Gem::Listeners::DynamicMixins < ::Tapioca::Gem::Listeners::Base
-  include ::Tapioca::Runtime::AttachedClassOf
-  include ::Tapioca::Runtime::Reflection
-
-  private
-
-  # source://tapioca/lib/tapioca/gem/listeners/dynamic_mixins.rb#31
-  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
-  def ignore?(event); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/dynamic_mixins.rb#15
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-# source://tapioca/lib/tapioca/gem/listeners/foreign_constants.rb#7
-class Tapioca::Gem::Listeners::ForeignConstants < ::Tapioca::Gem::Listeners::Base
-  include ::Tapioca::Runtime::AttachedClassOf
-  include ::Tapioca::Runtime::Reflection
-
-  private
-
-  # source://tapioca/lib/tapioca/gem/listeners/foreign_constants.rb#60
-  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
-  def ignore?(event); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/foreign_constants.rb#55
-  sig { params(location: ::String).returns(T::Boolean) }
-  def mixed_in_by_gem?(location); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/foreign_constants.rb#15
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-# source://tapioca/lib/tapioca/gem/listeners/methods.rb#7
-class Tapioca::Gem::Listeners::Methods < ::Tapioca::Gem::Listeners::Base
-  include ::Tapioca::SorbetHelper
-  include ::Tapioca::RBIHelper
-  include ::Tapioca::Runtime::AttachedClassOf
-  include ::Tapioca::Runtime::Reflection
-
-  private
-
-  # source://tapioca/lib/tapioca/gem/listeners/methods.rb#35
-  sig do
-    params(
-      tree: ::RBI::Tree,
-      module_name: ::String,
-      mod: ::Module,
-      for_visibility: T::Array[::Symbol],
-      attached_class: T.nilable(::Module)
-    ).void
-  end
-  def compile_directly_owned_methods(tree, module_name, mod, for_visibility = T.unsafe(nil), attached_class: T.unsafe(nil)); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/methods.rb#71
-  sig do
-    params(
-      tree: ::RBI::Tree,
-      symbol_name: ::String,
-      constant: ::Module,
-      method: T.nilable(::UnboundMethod),
-      visibility: ::RBI::Visibility
-    ).void
-  end
-  def compile_method(tree, symbol_name, constant, method, visibility = T.unsafe(nil)); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/methods.rb#211
-  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
-  def ignore?(event); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/methods.rb#204
-  sig { params(constant: ::Module).returns(T.nilable(::UnboundMethod)) }
-  def initialize_method_for(constant); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/methods.rb#216
-  sig { params(method: ::UnboundMethod).returns(T.untyped) }
-  def lookup_signature_of(method); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/methods.rb#172
-  sig { params(mod: ::Module).returns(T::Hash[::Symbol, T::Array[::Symbol]]) }
-  def method_names_by_visibility(mod); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/methods.rb#196
-  sig { params(attached_class: T.nilable(::Module), method_name: ::Symbol).returns(T.nilable(T::Boolean)) }
-  def method_new_in_abstract_class?(attached_class, method_name); end
-
-  # Check whether the method is defined by the constant.
-  #
-  # In most cases, it works to check that the constant is the method owner. However,
-  # in the case that a method is also defined in a module prepended to the constant, it
-  # will be owned by the prepended module, not the constant.
-  #
-  # This method implements a better way of checking whether a constant defines a method.
-  # It walks up the ancestor tree via the `super_method` method; if any of the super
-  # methods are owned by the constant, it means that the constant declares the method.
-  #
-  # source://tapioca/lib/tapioca/gem/listeners/methods.rb#158
-  sig { params(method: ::UnboundMethod, constant: ::Module).returns(T::Boolean) }
-  def method_owned_by_constant?(method, constant); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/methods.rb#16
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/methods.rb#181
-  sig { params(constant: ::Module, method_name: ::String).returns(T::Boolean) }
-  def struct_method?(constant, method_name); end
-end
-
-# source://tapioca/lib/tapioca/gem/listeners/mixins.rb#7
-class Tapioca::Gem::Listeners::Mixins < ::Tapioca::Gem::Listeners::Base
-  include ::Tapioca::Runtime::AttachedClassOf
-  include ::Tapioca::Runtime::Reflection
-
-  private
-
-  # source://tapioca/lib/tapioca/gem/listeners/mixins.rb#42
-  sig do
-    params(
-      tree: ::RBI::Tree,
-      constant: ::Module,
-      mods: T::Array[::Module],
-      mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type
-    ).void
-  end
-  def add_mixins(tree, constant, mods, mixin_type); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/mixins.rb#84
-  sig { params(mixin_name: ::String).returns(T::Boolean) }
-  def filtered_mixin?(mixin_name); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/mixins.rb#91
-  sig { params(constant: ::Module).returns(T::Array[::Module]) }
-  def interesting_ancestors_of(constant); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/mixins.rb#75
-  sig do
-    params(
-      constant: ::Module,
-      mixin: ::Module,
-      mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type
-    ).returns(T::Boolean)
-  end
-  def mixed_in_by_gem?(constant, mixin, mixin_type); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/mixins.rb#15
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-# source://tapioca/lib/tapioca/gem/listeners/remove_empty_payload_scopes.rb#7
-class Tapioca::Gem::Listeners::RemoveEmptyPayloadScopes < ::Tapioca::Gem::Listeners::Base
-  include ::Tapioca::Runtime::AttachedClassOf
-  include ::Tapioca::Runtime::Reflection
-
-  private
-
-  # source://tapioca/lib/tapioca/gem/listeners/remove_empty_payload_scopes.rb#20
-  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
-  def ignore?(event); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/remove_empty_payload_scopes.rb#15
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-# source://tapioca/lib/tapioca/gem/listeners/sorbet_enums.rb#7
-class Tapioca::Gem::Listeners::SorbetEnums < ::Tapioca::Gem::Listeners::Base
-  private
-
-  # source://tapioca/lib/tapioca/gem/listeners/sorbet_enums.rb#28
-  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
-  def ignore?(event); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/sorbet_enums.rb#13
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-# source://tapioca/lib/tapioca/gem/listeners/sorbet_helpers.rb#7
-class Tapioca::Gem::Listeners::SorbetHelpers < ::Tapioca::Gem::Listeners::Base
-  include ::Tapioca::Runtime::AttachedClassOf
-  include ::Tapioca::Runtime::Reflection
-
-  private
-
-  # source://tapioca/lib/tapioca/gem/listeners/sorbet_helpers.rb#27
-  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
-  def ignore?(event); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/sorbet_helpers.rb#15
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-# source://tapioca/lib/tapioca/gem/listeners/sorbet_props.rb#7
-class Tapioca::Gem::Listeners::SorbetProps < ::Tapioca::Gem::Listeners::Base
-  include ::Tapioca::SorbetHelper
-  include ::Tapioca::RBIHelper
-
-  private
-
-  # source://tapioca/lib/tapioca/gem/listeners/sorbet_props.rb#33
-  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
-  def ignore?(event); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/sorbet_props.rb#14
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-# source://tapioca/lib/tapioca/gem/listeners/sorbet_required_ancestors.rb#7
-class Tapioca::Gem::Listeners::SorbetRequiredAncestors < ::Tapioca::Gem::Listeners::Base
-  private
-
-  # source://tapioca/lib/tapioca/gem/listeners/sorbet_required_ancestors.rb#23
-  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
-  def ignore?(event); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/sorbet_required_ancestors.rb#13
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-# source://tapioca/lib/tapioca/gem/listeners/sorbet_signatures.rb#7
-class Tapioca::Gem::Listeners::SorbetSignatures < ::Tapioca::Gem::Listeners::Base
-  include ::Tapioca::Runtime::AttachedClassOf
-  include ::Tapioca::Runtime::Reflection
-  include ::Tapioca::SorbetHelper
-  include ::Tapioca::RBIHelper
-
-  private
-
-  # source://tapioca/lib/tapioca/gem/listeners/sorbet_signatures.rb#26
-  sig { params(signature: T.untyped, parameters: T::Array[[::Symbol, ::String]]).returns(::RBI::Sig) }
-  def compile_signature(signature, parameters); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/sorbet_signatures.rb#79
-  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
-  def ignore?(event); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/sorbet_signatures.rb#18
-  sig { override.params(event: ::Tapioca::Gem::MethodNodeAdded).void }
-  def on_method(event); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/sorbet_signatures.rb#68
-  sig { params(signature: T.untyped).returns(T::Boolean) }
-  def signature_final?(signature); end
-end
-
-# source://tapioca/lib/tapioca/gem/listeners/sorbet_signatures.rb#13
-Tapioca::Gem::Listeners::SorbetSignatures::TYPE_PARAMETER_MATCHER = T.let(T.unsafe(nil), Regexp)
-
-# source://tapioca/lib/tapioca/gem/listeners/sorbet_type_variables.rb#7
-class Tapioca::Gem::Listeners::SorbetTypeVariables < ::Tapioca::Gem::Listeners::Base
-  include ::Tapioca::Runtime::AttachedClassOf
-  include ::Tapioca::Runtime::Reflection
-
-  private
-
-  # source://tapioca/lib/tapioca/gem/listeners/sorbet_type_variables.rb#27
-  sig { params(tree: ::RBI::Tree, constant: ::Module).void }
-  def compile_type_variable_declarations(tree, constant); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/sorbet_type_variables.rb#63
-  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
-  def ignore?(event); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/sorbet_type_variables.rb#50
-  sig { params(type_variable: ::Tapioca::TypeVariableModule).returns(T.nilable(::RBI::Node)) }
-  def node_from_type_variable(type_variable); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/sorbet_type_variables.rb#15
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-# source://tapioca/lib/tapioca/gem/listeners/source_location.rb#7
-class Tapioca::Gem::Listeners::SourceLocation < ::Tapioca::Gem::Listeners::Base
-  private
-
-  # source://tapioca/lib/tapioca/gem/listeners/source_location.rb#41
-  sig { params(node: ::RBI::NodeWithComments, file: T.nilable(::String), line: T.nilable(::Integer)).void }
-  def add_source_location_comment(node, file, line); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/source_location.rb#13
-  sig { override.params(event: ::Tapioca::Gem::ConstNodeAdded).void }
-  def on_const(event); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/source_location.rb#35
-  sig { override.params(event: ::Tapioca::Gem::MethodNodeAdded).void }
-  def on_method(event); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/source_location.rb#19
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-# source://tapioca/lib/tapioca/gem/listeners/subconstants.rb#7
-class Tapioca::Gem::Listeners::Subconstants < ::Tapioca::Gem::Listeners::Base
-  include ::Tapioca::Runtime::AttachedClassOf
-  include ::Tapioca::Runtime::Reflection
-
-  private
-
-  # source://tapioca/lib/tapioca/gem/listeners/subconstants.rb#36
-  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
-  def ignore?(event); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/subconstants.rb#15
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-# source://tapioca/lib/tapioca/gem/listeners/yard_doc.rb#7
-class Tapioca::Gem::Listeners::YardDoc < ::Tapioca::Gem::Listeners::Base
-  # source://tapioca/lib/tapioca/gem/listeners/yard_doc.rb#27
-  sig { params(pipeline: ::Tapioca::Gem::Pipeline).void }
-  def initialize(pipeline); end
-
-  private
-
-  # source://tapioca/lib/tapioca/gem/listeners/yard_doc.rb#55
-  sig { params(name: ::String, sigs: T::Array[::RBI::Sig]).returns(T::Array[::RBI::Comment]) }
-  def documentation_comments(name, sigs: T.unsafe(nil)); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/yard_doc.rb#99
-  sig { override.params(event: ::Tapioca::Gem::NodeAdded).returns(T::Boolean) }
-  def ignore?(event); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/yard_doc.rb#36
-  sig { override.params(event: ::Tapioca::Gem::ConstNodeAdded).void }
-  def on_const(event); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/yard_doc.rb#46
-  sig { override.params(event: ::Tapioca::Gem::MethodNodeAdded).void }
-  def on_method(event); end
-
-  # source://tapioca/lib/tapioca/gem/listeners/yard_doc.rb#41
-  sig { override.params(event: ::Tapioca::Gem::ScopeNodeAdded).void }
-  def on_scope(event); end
-end
-
-# source://tapioca/lib/tapioca/gem/listeners/yard_doc.rb#10
-Tapioca::Gem::Listeners::YardDoc::IGNORED_COMMENTS = T.let(T.unsafe(nil), Array)
-
-# source://tapioca/lib/tapioca/gem/listeners/yard_doc.rb#24
-Tapioca::Gem::Listeners::YardDoc::IGNORED_SIG_TAGS = T.let(T.unsafe(nil), Array)
-
-# source://tapioca/lib/tapioca/gem/events.rb#105
-class Tapioca::Gem::MethodNodeAdded < ::Tapioca::Gem::NodeAdded
-  # source://tapioca/lib/tapioca/gem/events.rb#130
-  sig do
-    params(
-      symbol: ::String,
-      constant: ::Module,
-      method: ::UnboundMethod,
-      node: ::RBI::Method,
-      signature: T.untyped,
-      parameters: T::Array[[::Symbol, ::String]]
-    ).void
-  end
-  def initialize(symbol, constant, method, node, signature, parameters); end
-
-  # source://tapioca/lib/tapioca/gem/events.rb#109
-  sig { returns(::UnboundMethod) }
-  def method; end
-
-  # source://tapioca/lib/tapioca/gem/events.rb#112
-  sig { returns(::RBI::Method) }
-  def node; end
-
-  # source://tapioca/lib/tapioca/gem/events.rb#118
-  sig { returns(T::Array[[::Symbol, ::String]]) }
-  def parameters; end
-
-  # source://tapioca/lib/tapioca/gem/events.rb#115
-  sig { returns(T.untyped) }
-  def signature; end
-end
-
-# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://tapioca/lib/tapioca/gem/events.rb#57
-class Tapioca::Gem::NodeAdded < ::Tapioca::Gem::Event
-  abstract!
-
-  # source://tapioca/lib/tapioca/gem/events.rb#70
-  sig { params(symbol: ::String, constant: ::Module).void }
-  def initialize(symbol, constant); end
-
-  # source://tapioca/lib/tapioca/gem/events.rb#67
-  sig { returns(::Module) }
-  def constant; end
-
-  # source://tapioca/lib/tapioca/gem/events.rb#64
-  sig { returns(::String) }
-  def symbol; end
-end
-
-# source://tapioca/lib/tapioca/gem/pipeline.rb#6
-class Tapioca::Gem::Pipeline
-  include ::Tapioca::Runtime::AttachedClassOf
-  include ::Tapioca::Runtime::Reflection
-  include ::Tapioca::SorbetHelper
-  include ::Tapioca::RBIHelper
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#27
-  sig do
-    params(
-      gem: ::Tapioca::Gemfile::GemSpec,
-      error_handler: T.proc.params(error: ::String).void,
-      include_doc: T::Boolean,
-      include_loc: T::Boolean
-    ).void
-  end
-  def initialize(gem, error_handler:, include_doc: T.unsafe(nil), include_loc: T.unsafe(nil)); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#64
-  sig { returns(::RBI::Tree) }
-  def compile; end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#135
-  sig { params(name: T.any(::String, ::Symbol)).returns(T::Boolean) }
-  def constant_in_gem?(name); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#17
-  sig { returns(T.proc.params(error: ::String).void) }
-  def error_handler; end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#14
-  sig { returns(::Tapioca::Gemfile::GemSpec) }
-  def gem; end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#153
-  sig { params(method: ::UnboundMethod).returns(T::Boolean) }
-  def method_in_gem?(method); end
-
-  # Helpers
-  #
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#163
-  sig { params(constant: ::Module).returns(T.nilable(::String)) }
-  def name_of(constant); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#87
-  sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Const).void }
-  def push_const(symbol, constant, node); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#77
-  sig { params(symbol: ::String, constant: ::BasicObject).void }
-  def push_constant(symbol, constant); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#82
-  sig { params(symbol: ::String, constant: ::Module).void }
-  def push_foreign_constant(symbol, constant); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#101
-  sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Scope).void }
-  def push_foreign_scope(symbol, constant, node); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#115
-  sig do
-    params(
-      symbol: ::String,
-      constant: ::Module,
-      method: ::UnboundMethod,
-      node: ::RBI::Method,
-      signature: T.untyped,
-      parameters: T::Array[[::Symbol, ::String]]
-    ).void
-  end
-  def push_method(symbol, constant, method, node, signature, parameters); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#94
-  sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Scope).void }
-  def push_scope(symbol, constant, node); end
-
-  # Events handling
-  #
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#72
-  sig { params(symbol: ::String).void }
-  def push_symbol(symbol); end
-
-  # Constants and properties filtering
-  #
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#122
-  sig { params(symbol_name: ::String).returns(T::Boolean) }
-  def symbol_in_payload?(symbol_name); end
-
-  private
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#456
-  sig { params(name: ::String).void }
-  def add_to_alias_namespace(name); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#461
-  sig { params(name: ::String).returns(T::Boolean) }
-  def alias_namespaced?(name); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#260
-  sig { params(name: ::String, constant: ::Module).void }
-  def compile_alias(name, constant); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#246
-  sig { params(symbol: ::String, constant: ::BasicObject).void }
-  def compile_constant(symbol, constant); end
-
-  # Compiling
-  #
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#235
-  sig { params(symbol: ::String, constant: ::Module).void }
-  def compile_foreign_constant(symbol, constant); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#314
-  sig { params(name: ::String, constant: ::Module).void }
-  def compile_module(name, constant); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#281
-  sig { params(name: ::String, value: ::BasicObject).void }
-  def compile_object(name, value); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#325
-  sig { params(name: ::String, constant: ::Module).returns(::RBI::Scope) }
-  def compile_scope(name, constant); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#339
-  sig { params(constant: T::Class[T.anything]).returns(T.nilable(::String)) }
-  def compile_superclass(constant); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#437
-  sig { params(constant: ::Module, strict: T::Boolean).returns(T::Boolean) }
-  def defined_in_gem?(constant, strict: T.unsafe(nil)); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#193
-  sig { params(event: ::Tapioca::Gem::Event).void }
-  def dispatch(event); end
-
-  # Helpers
-  #
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#480
-  sig { params(constant: T.all(::Module, ::T::Generic)).returns(::String) }
-  def generic_name_of(constant); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#449
-  sig { params(constant: ::Module).returns(T::Set[::String]) }
-  def get_file_candidates(constant); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#178
-  sig { params(gem: ::Tapioca::Gemfile::GemSpec).returns(T::Set[::String]) }
-  def load_bootstrap_symbols(gem); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#496
-  sig { params(constant: ::Module, class_name: T.nilable(::String)).returns(T.nilable(::String)) }
-  def name_of_proxy_target(constant, class_name); end
-
-  # Events handling
-  #
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#188
-  sig { returns(::Tapioca::Gem::Event) }
-  def next_event; end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#216
-  sig { params(event: ::Tapioca::Gem::ConstantFound).void }
-  def on_constant(event); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#228
-  sig { params(event: ::Tapioca::Gem::NodeAdded).void }
-  def on_node(event); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#207
-  sig { params(event: ::Tapioca::Gem::SymbolFound).void }
-  def on_symbol(event); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#468
-  sig { params(name: ::String).void }
-  def seen!(name); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#473
-  sig { params(name: ::String).returns(T::Boolean) }
-  def seen?(name); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#407
-  sig { params(name: ::String, constant: ::Module).returns(T::Boolean) }
-  def skip_alias?(name, constant); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#395
-  sig { params(name: ::String, constant: T.anything).returns(T::Boolean) }
-  def skip_constant?(name, constant); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#424
-  sig { params(name: ::String, constant: ::Module).returns(T::Boolean) }
-  def skip_foreign_constant?(name, constant); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#429
-  sig { params(name: ::String, constant: ::Module).returns(T::Boolean) }
-  def skip_module?(name, constant); end
-
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#416
-  sig { params(name: ::String, constant: ::BasicObject).returns(T::Boolean) }
-  def skip_object?(name, constant); end
-
-  # Constants and properties filtering
-  #
-  # source://tapioca/lib/tapioca/gem/pipeline.rb#390
-  sig { params(name: ::String).returns(T::Boolean) }
-  def skip_symbol?(name); end
-end
-
-# this looks something like:
-# "(eval at /path/to/file.rb:123)"
-# and we are just interested in the "/path/to/file.rb" part
-#
-# source://tapioca/lib/tapioca/gem/pipeline.rb#132
-Tapioca::Gem::Pipeline::EVAL_SOURCE_FILE_PATTERN = T.let(T.unsafe(nil), Regexp)
-
-# source://tapioca/lib/tapioca/gem/pipeline.rb#11
-Tapioca::Gem::Pipeline::IGNORED_SYMBOLS = T.let(T.unsafe(nil), Array)
-
-# source://tapioca/lib/tapioca/gem/events.rb#90
-class Tapioca::Gem::ScopeNodeAdded < ::Tapioca::Gem::NodeAdded
-  # source://tapioca/lib/tapioca/gem/events.rb#97
-  sig { params(symbol: ::String, constant: ::Module, node: ::RBI::Scope).void }
-  def initialize(symbol, constant, node); end
-
-  # source://tapioca/lib/tapioca/gem/events.rb#94
-  sig { returns(::RBI::Scope) }
-  def node; end
-end
-
-# source://tapioca/lib/tapioca/gem/events.rb#13
-class Tapioca::Gem::SymbolFound < ::Tapioca::Gem::Event
-  # source://tapioca/lib/tapioca/gem/events.rb#20
-  sig { params(symbol: ::String).void }
-  def initialize(symbol); end
-
-  # source://tapioca/lib/tapioca/gem/events.rb#17
-  sig { returns(::String) }
-  def symbol; end
-end
-
-# source://tapioca/lib/tapioca/helpers/gem_helper.rb#5
-module Tapioca::GemHelper
-  # source://tapioca/lib/tapioca/helpers/gem_helper.rb#9
-  sig { params(app_dir: T.any(::Pathname, ::String), full_gem_path: ::String).returns(T::Boolean) }
-  def gem_in_app_dir?(app_dir, full_gem_path); end
-
-  # source://tapioca/lib/tapioca/helpers/gem_helper.rb#17
-  sig { params(full_gem_path: ::String).returns(T::Boolean) }
-  def gem_in_bundle_path?(full_gem_path); end
-
-  # source://tapioca/lib/tapioca/helpers/gem_helper.rb#22
-  sig { params(full_gem_path: ::String).returns(T::Boolean) }
-  def gem_in_ruby_path?(full_gem_path); end
-
-  # source://tapioca/lib/tapioca/helpers/gem_helper.rb#27
-  sig { params(path: T.any(::Pathname, ::String)).returns(::String) }
-  def to_realpath(path); end
-
-  private
-
-  # source://tapioca/lib/tapioca/helpers/gem_helper.rb#36
-  sig { params(path: T.any(::Pathname, ::String), dir: T.any(::Pathname, ::String)).returns(T::Boolean) }
-  def path_in_dir?(path, dir); end
-end
-
-# source://tapioca/lib/tapioca/gem_info.rb#5
-class Tapioca::GemInfo < ::T::Struct
-  const :name, ::String
-  const :version, ::Gem::Version
-
-  class << self
-    # source://tapioca/lib/tapioca/gem_info.rb#13
-    sig { params(spec: ::Bundler::LazySpecification).returns(::Tapioca::GemInfo) }
-    def from_spec(spec); end
-
-<<<<<<<< HEAD:sorbet/rbi/gems/tapioca@0.16.8.rbi
-    # source://sorbet-runtime/0.5.11761lib/types/struct.rb#13
-|||||||| parent of 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.5.rbi
-    # source://sorbet-runtime/0.5.11635lib/types/struct.rb#13
-========
-    # source://sorbet-runtime/0.5.11725lib/types/struct.rb#13
->>>>>>>> 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.6.rbi
-    def inherited(s); end
-  end
-end
-
-# source://tapioca/lib/tapioca/gemfile.rb#7
-class Tapioca::Gemfile
-  # source://tapioca/lib/tapioca/gemfile.rb#27
-  sig { params(excluded_gems: T::Array[::String]).void }
-  def initialize(excluded_gems); end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#18
-  sig { returns(::Bundler::Definition) }
-  def definition; end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#21
-  sig { returns(T::Array[::Tapioca::Gemfile::GemSpec]) }
-  def dependencies; end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#40
-  sig { params(gem_name: ::String).returns(T.nilable(::Tapioca::Gemfile::GemSpec)) }
-  def gem(gem_name); end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#24
-  sig { returns(T::Array[::String]) }
-  def missing_specs; end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#45
-  sig { void }
-  def require_bundle; end
-
-  private
-
-  # source://tapioca/lib/tapioca/gemfile.rb#101
-  sig { returns(::String) }
-  def dir; end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#54
-  sig { returns(::File) }
-  def gemfile; end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#96
-  sig { returns(T::Array[::Symbol]) }
-  def groups; end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#57
-  sig { returns([T::Array[::Tapioca::Gemfile::GemSpec], T::Array[::String]]) }
-  def load_dependencies; end
-
-  # @return [File]
-  #
-  # source://tapioca/lib/tapioca/gemfile.rb#54
-  def lockfile; end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#68
-  sig { returns([T::Enumerable[T.any(::Bundler::StubSpecification, ::Gem::Specification)], T::Array[::String]]) }
-  def materialize_deps; end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#91
-  sig { returns(::Bundler::Runtime) }
-  def runtime; end
-end
-
-# source://tapioca/lib/tapioca/gemfile.rb#105
-class Tapioca::Gemfile::GemSpec
-  include ::Tapioca::GemHelper
-
-  # source://tapioca/lib/tapioca/gemfile.rb#145
-  sig { params(spec: T.any(::Bundler::StubSpecification, ::Gem::Specification)).void }
-  def initialize(spec); end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#155
-  sig { params(other: ::BasicObject).returns(T::Boolean) }
-  def ==(other); end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#180
-  sig { params(path: ::String).returns(T::Boolean) }
-  def contains_path?(path); end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#170
-  sig { returns(T::Array[::Gem::Dependency]) }
-  def dependencies; end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#210
-  sig { returns(T::Boolean) }
-  def export_rbi_files?; end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#205
-  sig { returns(T::Array[::String]) }
-  def exported_rbi_files; end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#215
-  sig { returns(::RBI::MergeTree) }
-  def exported_rbi_tree; end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#142
-  sig { returns(T::Array[::Pathname]) }
-  def files; end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#139
-  sig { returns(::String) }
-  def full_gem_path; end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#160
-  sig { params(gemfile_dir: ::String).returns(T::Boolean) }
-  def ignore?(gemfile_dir); end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#165
-  sig { returns(::String) }
-  def name; end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#189
-  sig { void }
-  def parse_yard_docs; end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#175
-  sig { returns(::String) }
-  def rbi_file_name; end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#227
-  sig { params(file: ::Pathname).returns(::Pathname) }
-  def relative_path_for(file); end
-
-  # @return [String]
-  #
-  # source://tapioca/lib/tapioca/gemfile.rb#139
-  def version; end
-
-  private
-
-  # source://tapioca/lib/tapioca/gemfile.rb#238
-  sig { returns(T::Array[::Pathname]) }
-  def collect_files; end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#253
-  sig { returns(T.nilable(T::Boolean)) }
-  def default_gem?; end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#312
-  sig { returns(T::Boolean) }
-  def gem_ignored?; end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#291
-  sig { params(path: ::String).returns(T::Boolean) }
-  def has_parent_gemspec?(path); end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#258
-  sig { returns(::Regexp) }
-  def require_paths_prefix_matcher; end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#270
-  sig { params(file: ::String).returns(::Pathname) }
-  def resolve_to_ruby_lib_dir(file); end
-
-  # source://tapioca/lib/tapioca/gemfile.rb#284
-  sig { returns(::String) }
-  def version_string; end
-
-  class << self
-    # source://tapioca/lib/tapioca/gemfile.rb#113
-    sig { returns(T::Hash[::String, ::Tapioca::Gemfile::GemSpec]) }
-    def spec_lookup_by_file_path; end
-  end
-end
-
-# source://tapioca/lib/tapioca/gemfile.rb#125
-Tapioca::Gemfile::GemSpec::IGNORED_GEMS = T.let(T.unsafe(nil), Array)
-
-# source://tapioca/lib/tapioca/gemfile.rb#10
-Tapioca::Gemfile::Spec = T.type_alias { T.any(::Bundler::StubSpecification, ::Gem::Specification) }
-
-# source://tapioca/lib/tapioca.rb#33
-Tapioca::LIB_ROOT_DIR = T.let(T.unsafe(nil), String)
-
-# source://tapioca/lib/tapioca/loaders/loader.rb#5
-module Tapioca::Loaders; end
-
-# source://tapioca/lib/tapioca/loaders/dsl.rb#6
-class Tapioca::Loaders::Dsl < ::Tapioca::Loaders::Loader
-  # source://tapioca/lib/tapioca/loaders/dsl.rb#53
-  sig do
-    params(
-      tapioca_path: ::String,
-      eager_load: T::Boolean,
-      app_root: ::String,
-      halt_upon_load_error: T::Boolean
-    ).void
-  end
-  def initialize(tapioca_path:, eager_load: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil)); end
-
-  # source://tapioca/lib/tapioca/loaders/dsl.rb#36
-  sig { override.void }
-  def load; end
-
-  # source://tapioca/lib/tapioca/loaders/dsl.rb#43
-  sig { void }
-  def load_dsl_extensions_and_compilers; end
-
-  protected
-
-<<<<<<<< HEAD:sorbet/rbi/gems/tapioca@0.16.8.rbi
-  # source://tapioca/lib/tapioca/loaders/dsl.rb#103
-|||||||| parent of 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.5.rbi
-  # source://tapioca/lib/tapioca/loaders/dsl.rb#105
-========
-  # source://tapioca/lib/tapioca/loaders/dsl.rb#110
->>>>>>>> 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.6.rbi
-  sig { void }
-  def load_application; end
-
-  # source://tapioca/lib/tapioca/loaders/dsl.rb#78
-  sig { void }
-  def load_dsl_compilers; end
-
-  # source://tapioca/lib/tapioca/loaders/dsl.rb#63
-  sig { void }
-  def load_dsl_extensions; end
-
-  class << self
-    # source://tapioca/lib/tapioca/loaders/dsl.rb#20
-    sig do
-      params(
-        tapioca_path: ::String,
-        eager_load: T::Boolean,
-        app_root: ::String,
-        halt_upon_load_error: T::Boolean
-      ).void
-    end
-    def load_application(tapioca_path:, eager_load: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil)); end
-  end
-end
-
-# source://tapioca/lib/tapioca/loaders/gem.rb#6
-class Tapioca::Loaders::Gem < ::Tapioca::Loaders::Loader
-  # source://tapioca/lib/tapioca/loaders/gem.rb#49
-  sig do
-    params(
-      bundle: ::Tapioca::Gemfile,
-      prerequire: T.nilable(::String),
-      postrequire: ::String,
-      default_command: ::String,
-      halt_upon_load_error: T::Boolean
-    ).void
-  end
-  def initialize(bundle:, prerequire:, postrequire:, default_command:, halt_upon_load_error:); end
-
-  # source://tapioca/lib/tapioca/loaders/gem.rb#34
-  sig { override.void }
-  def load; end
-
-  protected
-
-  # source://tapioca/lib/tapioca/loaders/gem.rb#80
-  sig { params(file: ::String, error: ::LoadError).void }
-  def explain_failed_require(file, error); end
-
-  # source://tapioca/lib/tapioca/loaders/gem.rb#60
-  sig { void }
-  def require_gem_file; end
-
-  class << self
-    # source://tapioca/lib/tapioca/loaders/gem.rb#21
-    sig do
-      params(
-        bundle: ::Tapioca::Gemfile,
-        prerequire: T.nilable(::String),
-        postrequire: ::String,
-        default_command: ::String,
-        halt_upon_load_error: T::Boolean
-      ).void
-    end
-    def load_application(bundle:, prerequire:, postrequire:, default_command:, halt_upon_load_error:); end
-  end
-end
-
-# @abstract It cannot be directly instantiated. Subclasses must implement the `abstract` methods below.
-#
-# source://tapioca/lib/tapioca/loaders/loader.rb#6
-class Tapioca::Loaders::Loader
-  include ::Thor::Base
-  include ::Thor::Invocation
-  include ::Thor::Shell
-  include ::Tapioca::CliHelper
-  include ::Tapioca::GemHelper
-  extend ::Thor::Base::ClassMethods
-  extend ::Thor::Invocation::ClassMethods
-
-  abstract!
-
-  # @abstract
-  #
-  # source://tapioca/lib/tapioca/loaders/loader.rb#17
-  sig { abstract.void }
-  def load; end
-
-  private
-
-  # Rails 7.2 renamed `eager_load_paths` to `all_eager_load_paths`, which maintains the same original functionality.
-  # The `eager_load_paths` method still exists, but doesn't return all paths anymore and causes Tapioca to miss some
-  # engine paths. The following commit is the change:
-  # https://github.com/rails/rails/commit/ebfca905db14020589c22e6937382e6f8f687664
-  #
-  # @param engine [T.class_of(Rails::Engine)]
-  # @return [Array<String>]
-  #
-  # source://tapioca/lib/tapioca/loaders/loader.rb#234
-  def eager_load_paths(engine); end
-
-  # source://tapioca/lib/tapioca/loaders/loader.rb#199
-  sig { void }
-  def eager_load_rails_app; end
-
-  # @return [Array<T.class_of(Rails::Engine)>]
-  #
-  # source://tapioca/lib/tapioca/loaders/loader.rb#178
-  def engines; end
-
-  # source://tapioca/lib/tapioca/loaders/loader.rb#29
-  sig do
-    params(
-      gemfile: ::Tapioca::Gemfile,
-      initialize_file: T.nilable(::String),
-      require_file: T.nilable(::String),
-      halt_upon_load_error: T::Boolean
-    ).void
-  end
-  def load_bundle(gemfile, initialize_file, require_file, halt_upon_load_error); end
-
-  # source://tapioca/lib/tapioca/loaders/loader.rb#136
-  sig { void }
-  def load_engines_in_classic_mode; end
-
-  # source://tapioca/lib/tapioca/loaders/loader.rb#114
-  sig { void }
-  def load_engines_in_zeitwerk_mode; end
-
-  # source://tapioca/lib/tapioca/loaders/loader.rb#49
-  sig do
-    params(
-      environment_load: T::Boolean,
-      eager_load: T::Boolean,
-      app_root: ::String,
-      halt_upon_load_error: T::Boolean
-    ).void
-  end
-  def load_rails_application(environment_load: T.unsafe(nil), eager_load: T.unsafe(nil), app_root: T.unsafe(nil), halt_upon_load_error: T.unsafe(nil)); end
-
-  # source://tapioca/lib/tapioca/loaders/loader.rb#89
-  sig { void }
-  def load_rails_engines; end
-
-  # source://tapioca/lib/tapioca/loaders/loader.rb#220
-  sig { params(file: T.nilable(::String)).void }
-  def require_helper(file); end
-
-  # source://tapioca/lib/tapioca/loaders/loader.rb#103
-  def run_initializers; end
-
-  # source://tapioca/lib/tapioca/loaders/loader.rb#192
-  sig { params(path: ::String).void }
-  def safe_require(path); end
-
-  # source://tapioca/lib/tapioca/loaders/loader.rb#161
-  sig { params(blk: T.proc.void).void }
-  def with_rails_application(&blk); end
-
-  # source://tapioca/lib/tapioca/loaders/loader.rb#154
-  sig { returns(T::Boolean) }
-  def zeitwerk_mode?; end
-end
-
-# source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#5
-module Tapioca::RBIFilesHelper
-  requires_ancestor { Tapioca::SorbetHelper }
-  requires_ancestor { Thor::Shell }
-
-  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#48
-  sig do
-    params(
-      index: ::RBI::Index,
-      shim_rbi_dir: ::String,
-      todo_rbi_file: ::String
-    ).returns(T::Hash[::String, T::Array[::RBI::Node]])
-  end
-  def duplicated_nodes_from_index(index, shim_rbi_dir:, todo_rbi_file:); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#13
-  sig { params(index: ::RBI::Index, kind: ::String, file: ::String).void }
-  def index_rbi(index, kind, file); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#25
-  sig { params(index: ::RBI::Index, kind: ::String, dir: ::String, number_of_workers: T.nilable(::Integer)).void }
-  def index_rbis(index, kind, dir, number_of_workers:); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#65
-  sig { params(loc: ::RBI::Loc, path_prefix: T.nilable(::String)).returns(::String) }
-  def location_to_payload_url(loc, path_prefix:); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#86
-  sig do
-    params(
-      command: ::String,
-      gem_dir: ::String,
-      dsl_dir: ::String,
-      auto_strictness: T::Boolean,
-      gems: T::Array[::Tapioca::Gemfile::GemSpec],
-      compilers: T::Enumerable[T.class_of(Tapioca::Dsl::Compiler)]
-    ).void
-  end
-  def validate_rbi_files(command:, gem_dir:, dsl_dir:, auto_strictness:, gems: T.unsafe(nil), compilers: T.unsafe(nil)); end
-
-  private
-
-  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#223
-  sig { params(nodes: T::Array[::RBI::Node]).returns(T::Array[::RBI::Scope]) }
-  def extract_empty_scopes(nodes); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#228
-  sig { params(nodes: T::Array[::RBI::Node]).returns(T::Array[T.any(::RBI::Attr, ::RBI::Method)]) }
-  def extract_methods_and_attrs(nodes); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#238
-  sig { params(nodes: T::Array[::RBI::Node]).returns(T::Array[T.any(::RBI::Mixin, ::RBI::RequiresAncestor)]) }
-  def extract_mixins(nodes); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#248
-  sig do
-    params(
-      nodes: T::Array[T.any(::RBI::Attr, ::RBI::Method)]
-    ).returns(T::Array[T.any(::RBI::Attr, ::RBI::Method)])
-  end
-  def extract_nodes_with_sigs(nodes); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#216
-  sig do
-    params(
-      nodes: T::Array[::RBI::Node],
-      shim_rbi_dir: ::String,
-      todo_rbi_file: ::String
-    ).returns(T::Array[::RBI::Node])
-  end
-  def extract_shims_and_todos(nodes, shim_rbi_dir:, todo_rbi_file:); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#280
-  sig { params(path: ::String).returns(::String) }
-  def gem_name_from_rbi_path(path); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#155
-  sig { params(index: ::RBI::Index, files: T::Array[::String], number_of_workers: T.nilable(::Integer)).void }
-  def parse_and_index_files(index, files, number_of_workers:); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#171
-  sig { params(nodes: T::Array[::RBI::Node], shim_rbi_dir: ::String, todo_rbi_file: ::String).returns(T::Boolean) }
-  def shims_or_todos_have_duplicates?(nodes, shim_rbi_dir:, todo_rbi_file:); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_files_helper.rb#253
-  sig { params(errors: T::Array[::Spoom::Sorbet::Errors::Error], gem_dir: ::String).void }
-  def update_gem_rbis_strictnesses(errors, gem_dir); end
-end
-
-# source://tapioca/lib/tapioca/rbi_formatter.rb#5
-class Tapioca::RBIFormatter < ::RBI::Formatter
-  # source://tapioca/lib/tapioca/rbi_formatter.rb#24
-  sig { params(file: ::RBI::File).void }
-  def write_empty_body_comment!(file); end
-
-  # source://tapioca/lib/tapioca/rbi_formatter.rb#15
-  sig { params(file: ::RBI::File, command: ::String, reason: T.nilable(::String)).void }
-  def write_header!(file, command, reason: T.unsafe(nil)); end
-end
-
-# source://tapioca/lib/tapioca/helpers/rbi_helper.rb#5
-module Tapioca::RBIHelper
-  include ::Tapioca::SorbetHelper
-  extend ::Tapioca::SorbetHelper
-  extend ::Tapioca::RBIHelper
-
-  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#91
-  sig { params(type: ::String).returns(::String) }
-  def as_nilable_type(type); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#100
-  sig { params(type: ::String).returns(::String) }
-  def as_non_nilable_type(type); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#72
-  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
-  def create_block_param(name, type:); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#62
-  sig { params(name: ::String, type: ::String, default: ::String).returns(::RBI::TypedParam) }
-  def create_kw_opt_param(name, type:, default:); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#57
-  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
-  def create_kw_param(name, type:); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#67
-  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
-  def create_kw_rest_param(name, type:); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#47
-  sig { params(name: ::String, type: ::String, default: ::String).returns(::RBI::TypedParam) }
-  def create_opt_param(name, type:, default:); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#42
-  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
-  def create_param(name, type:); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#52
-  sig { params(name: ::String, type: ::String).returns(::RBI::TypedParam) }
-  def create_rest_param(name, type:); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#77
-  sig { params(param: ::RBI::Param, type: ::String).returns(::RBI::TypedParam) }
-  def create_typed_param(param, type); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#82
-  sig { params(sig_string: ::String).returns(::String) }
-  def sanitize_signature_types(sig_string); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#109
-  sig { params(name: ::String).returns(T::Boolean) }
-  def valid_method_name?(name); end
-
-  # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#114
-  sig { params(name: ::String).returns(T::Boolean) }
-  def valid_parameter_name?(name); end
-
-  class << self
-    # source://tapioca/lib/tapioca/helpers/rbi_helper.rb#23
-    sig do
-      params(
-        type: ::String,
-        variance: ::Symbol,
-        fixed: T.nilable(::String),
-        upper: T.nilable(::String),
-        lower: T.nilable(::String)
-      ).returns(::String)
-    end
-    def serialize_type_variable(type, variance, fixed, upper, lower); end
-  end
-end
-
-# source://tapioca/lib/tapioca/repo_index.rb#5
-class Tapioca::RepoIndex
-  # source://tapioca/lib/tapioca/repo_index.rb#26
-  sig { void }
-  def initialize; end
-
-  # source://tapioca/lib/tapioca/repo_index.rb#31
-  sig { params(gem_name: ::String).void }
-  def <<(gem_name); end
-
-  # source://tapioca/lib/tapioca/repo_index.rb#36
-  sig { returns(T::Enumerable[::String]) }
-  def gems; end
-
-  # source://tapioca/lib/tapioca/repo_index.rb#41
-  sig { params(gem_name: ::String).returns(T::Boolean) }
-  def has_gem?(gem_name); end
-
-  class << self
-    # source://tapioca/lib/tapioca/repo_index.rb#18
-    sig { params(hash: T::Hash[::String, T::Hash[T.untyped, T.untyped]]).returns(Tapioca::RepoIndex) }
-    def from_hash(hash); end
-
-    # source://tapioca/lib/tapioca/repo_index.rb#13
-    sig { params(json: ::String).returns(Tapioca::RepoIndex) }
-    def from_json(json); end
-  end
-end
-
-# source://tapioca/lib/tapioca/runtime/trackers/autoload.rb#5
-module Tapioca::Runtime; end
-
-# This module should only be included when running versions of Ruby
-# older than 3.2. Because the Class#attached_object method is not
-# available, it implements finding the attached class of a singleton
-# class by iterating through ObjectSpace.
-module Tapioca::Runtime::AttachedClassOf
-  # source://tapioca/lib/tapioca/runtime/attached_class_of_32.rb#14
-  sig { params(singleton_class: ::Class).returns(T.nilable(::Module)) }
-  def attached_class_of(singleton_class); end
-end
-
-# source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#6
-class Tapioca::Runtime::DynamicMixinCompiler
-  include ::Tapioca::Runtime::AttachedClassOf
-  include ::Tapioca::Runtime::Reflection
-
-  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#20
-  sig { params(constant: ::Module).void }
-  def initialize(constant); end
-
-  # @return [Array<Symbol>]
-  #
-  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#14
-  def class_attribute_predicates; end
-
-  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#14
-  sig { returns(T::Array[::Symbol]) }
-  def class_attribute_readers; end
-
-  # @return [Array<Symbol>]
-  #
-  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#14
-  def class_attribute_writers; end
-
-  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#137
-  sig { params(tree: ::RBI::Tree).void }
-  def compile_class_attributes(tree); end
-
-  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#180
-  sig { params(tree: ::RBI::Tree).returns([T::Array[::Module], T::Array[::Module]]) }
-  def compile_mixes_in_class_methods(tree); end
-
-  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#11
-  sig { returns(T::Array[::Module]) }
-  def dynamic_extends; end
-
-  # @return [Array<Module>]
-  #
-  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#11
-  def dynamic_includes; end
-
-  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#132
-  sig { returns(T::Boolean) }
-  def empty_attributes?; end
-
-  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#222
-  sig { params(qualified_mixin_name: ::String).returns(T::Boolean) }
-  def filtered_mixin?(qualified_mixin_name); end
-
-  # @return [Array<Symbol>]
-  #
-  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#17
-  def instance_attribute_predicates; end
-
-  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#17
-  sig { returns(T::Array[::Symbol]) }
-  def instance_attribute_readers; end
-
-  # @return [Array<Symbol>]
-  #
-  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#17
-  def instance_attribute_writers; end
-
-  # source://tapioca/lib/tapioca/runtime/dynamic_mixin_compiler.rb#215
-  sig { params(mod: ::Module, dynamic_extends: T::Array[::Module]).returns(T::Boolean) }
-  def module_included_by_another_dynamic_extend?(mod, dynamic_extends); end
-end
-
-# This class is responsible for storing and looking up information related to generic types.
-#
-# The class stores 2 different kinds of data, in two separate lookup tables:
-#   1. a lookup of generic type instances by name: `@generic_instances`
-#   2. a lookup of type variable serializer by constant and type variable
-#      instance: `@type_variables`
-#
-# By storing the above data, we can cheaply query each constant against this registry
-# to see if it declares any generic type variables. This becomes a simple lookup in the
-# `@type_variables` hash table with the given constant.
-#
-# If there is no entry, then we can cheaply know that we can skip generic type
-# information generation for this type.
-#
-# On the other hand, if we get a result, then the result will be a hash of type
-# variable to type variable serializers. This allows us to associate type variables
-# to the constant names that represent them, easily.
-#
-# source://tapioca/lib/tapioca/runtime/generic_type_registry.rb#23
-module Tapioca::Runtime::GenericTypeRegistry
-  class << self
-    # source://tapioca/lib/tapioca/runtime/generic_type_registry.rb#80
-    sig { params(instance: ::Object).returns(T::Boolean) }
-    def generic_type_instance?(instance); end
-
-    # source://tapioca/lib/tapioca/runtime/generic_type_registry.rb#85
-    sig { params(constant: ::Module).returns(T.nilable(T::Array[::Tapioca::TypeVariableModule])) }
-    def lookup_type_variables(constant); end
-
-    # This method is responsible for building the name of the instantiated concrete type
-    # and cloning the given constant so that we can return a type that is the same
-    # as the current type but is a different instance and has a different name method.
-    #
-    # We cache those cloned instances by their name in `@generic_instances`, so that
-    # we don't keep instantiating a new type every single time it is referenced.
-    # For example, `[Foo[Integer], Foo[Integer], Foo[Integer], Foo[String]]` will only
-    # result in 2 clones (1 for `Foo[Integer]` and another for `Foo[String]`) and
-    # 2 hash lookups (for the other two `Foo[Integer]`s).
-    #
-    # This method returns the created or cached clone of the constant.
-    #
-    # source://tapioca/lib/tapioca/runtime/generic_type_registry.rb#65
-    sig { params(constant: T.untyped, types: T.untyped).returns(::Module) }
-    def register_type(constant, types); end
-
-    # This method is called from intercepted calls to `type_member` and `type_template`.
-    # We get passed all the arguments to those methods, as well as the `T::Types::TypeVariable`
-    # instance generated by the Sorbet defined `type_member`/`type_template` call on `T::Generic`.
-    #
-    # This method creates a `String` with that data and stores it in the
-    # `@type_variables` lookup table, keyed by the `constant` and `type_variable`.
-    #
-    # Finally, the original `type_variable` is returned from this method, so that the caller
-    # can return it from the original methods as well.
-    #
-    # source://tapioca/lib/tapioca/runtime/generic_type_registry.rb#104
-    sig { params(constant: T.untyped, type_variable: ::Tapioca::TypeVariableModule).void }
-    def register_type_variable(constant, type_variable); end
-
-    private
-
-    # source://tapioca/lib/tapioca/runtime/generic_type_registry.rb#113
-    sig { params(constant: ::Module, name: ::String).returns(::Module) }
-    def create_generic_type(constant, name); end
-
-    # source://tapioca/lib/tapioca/runtime/generic_type_registry.rb#155
-    sig { params(constant: T::Class[T.anything]).returns(T::Class[T.anything]) }
-    def create_safe_subclass(constant); end
-
-    # source://tapioca/lib/tapioca/runtime/generic_type_registry.rb#182
-    sig { params(constant: ::Module).returns(T::Array[::Tapioca::TypeVariableModule]) }
-    def lookup_or_initialize_type_variables(constant); end
-  end
-end
-
-# source://tapioca/lib/tapioca/runtime/generic_type_registry.rb#34
-class Tapioca::Runtime::GenericTypeRegistry::GenericType < ::T::Types::Simple
-  # source://tapioca/lib/tapioca/runtime/generic_type_registry.rb#38
-  sig { params(raw_type: ::Module, underlying_type: ::Module).void }
-  def initialize(raw_type, underlying_type); end
-
-  # source://tapioca/lib/tapioca/runtime/generic_type_registry.rb#45
-  sig { override.params(obj: T.untyped).returns(T::Boolean) }
-  def valid?(obj); end
-end
-
-module Tapioca::Runtime::Reflection
-  include ::Tapioca::Runtime::AttachedClassOf
-  extend ::Tapioca::Runtime::AttachedClassOf
-  extend ::Tapioca::Runtime::Reflection
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#207
-  sig { params(constant: ::Module).returns(T.untyped) }
-  def abstract_type_of(constant); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#77
-  sig { params(constant: ::Module).returns(T::Array[::Module]) }
-  def ancestors_of(constant); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#92
-  sig { params(object: ::BasicObject, other: ::BasicObject).returns(T::Boolean) }
-  def are_equal?(object, other); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#56
-  sig { params(object: ::BasicObject).returns(T::Class[T.anything]) }
-  def class_of(object); end
-
-  # @param constant [BasicObject]
-  # @return [Boolean]
-  #
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#38
-  def constant_defined?(constant); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#49
-  sig { params(symbol: ::String, inherit: T::Boolean, namespace: ::Module).returns(::BasicObject) }
-  def constantize(symbol, inherit: T.unsafe(nil), namespace: T.unsafe(nil)); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#61
-  sig { params(constant: ::Module).returns(T::Array[::Symbol]) }
-  def constants_of(constant); end
-
-  # Returns an array with all classes that are < than the supplied class.
-  #
-  #   class C; end
-  #   descendants_of(C) # => []
-  #
-  #   class B < C; end
-  #   descendants_of(C) # => [B]
-  #
-  #   class A < B; end
-  #   descendants_of(C) # => [B, A]
-  #
-  #   class D < C; end
-  #   descendants_of(C) # => [B, A, D]
-  #
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#172
-  sig do
-    type_parameters(:U)
-      .params(
-        klass: T.all(T.type_parameter(:U), T::Class[T.anything])
-      ).returns(T::Array[T.type_parameter(:U)])
-  end
-  def descendants_of(klass); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#200
-  sig { params(constant: ::Module).returns(T::Set[::String]) }
-  def file_candidates_for(constant); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#213
-  sig { params(constant: ::Module).returns(T::Boolean) }
-  def final_module?(constant); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#112
-  sig { params(constant: ::Module).returns(T::Array[::Module]) }
-  def inherited_ancestors_of(constant); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#150
-  sig { params(constant: ::Module, method: ::Symbol).returns(::Method) }
-  def method_of(constant, method); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#66
-  sig { params(constant: ::Module).returns(T.nilable(::String)) }
-  def name_of(constant); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#145
-  sig { params(type: ::T::Types::Base).returns(::String) }
-  def name_of_type(type); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#87
-  sig { params(object: ::BasicObject).returns(::Integer) }
-  def object_id_of(object); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#107
-  sig { params(constant: ::Module).returns(T::Array[::Symbol]) }
-  def private_instance_methods_of(constant); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#102
-  sig { params(constant: ::Module).returns(T::Array[::Symbol]) }
-  def protected_instance_methods_of(constant); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#97
-  sig { params(constant: ::Module).returns(T::Array[::Symbol]) }
-  def public_instance_methods_of(constant); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#121
-  sig { params(constant: ::Module).returns(T.nilable(::String)) }
-  def qualified_name_of(constant); end
-
-  # Examines the call stack to identify the closest location where a "require" is performed
-  # by searching for the label "<top (required)>" or "block in <class:...>" in the
-  # case of an ActiveSupport.on_load hook. If none is found, it returns the location
-  # labeled "<main>", which is the original call site.
-  #
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#185
-  sig { params(locations: T.nilable(T::Array[::Thread::Backtrace::Location])).returns(::String) }
-  def resolve_loc(locations); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#218
-  sig { params(constant: ::Module).returns(T::Boolean) }
-  def sealed_module?(constant); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#138
-  sig { params(method: T.any(::Method, ::UnboundMethod)).returns(T.untyped) }
-  def signature_of(method); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#133
-  sig { params(method: T.any(::Method, ::UnboundMethod)).returns(T.untyped) }
-  def signature_of!(method); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#72
-  sig { params(constant: ::Module).returns(T::Class[T.anything]) }
-  def singleton_class_of(constant); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#82
-  sig { params(constant: T::Class[T.anything]).returns(T.nilable(T::Class[T.anything])) }
-  def superclass_of(constant); end
-
-  private
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#255
-  sig { params(parent: ::Module, name: ::String).returns(T.nilable(::Module)) }
-  def child_module_for_parent_with_name(parent, name); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#271
-  sig { params(name: ::String).returns(T::Boolean) }
-  def has_aliased_namespace?(name); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#266
-  sig { params(method: ::UnboundMethod).returns(T::Boolean) }
-  def method_defined_by_forwardable_module?(method); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#241
-  sig { params(constant: ::Module).returns(T::Array[::UnboundMethod]) }
-  def methods_for(constant); end
-
-  # source://tapioca/lib/tapioca/runtime/reflection.rb#225
-  sig { params(constant: ::Module).returns(T::Array[::UnboundMethod]) }
-  def relevant_methods_for(constant); end
-end
-
-# source://tapioca/lib/tapioca/runtime/reflection.rb#25
-Tapioca::Runtime::Reflection::ANCESTORS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca/lib/tapioca/runtime/reflection.rb#21
-Tapioca::Runtime::Reflection::CLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca/lib/tapioca/runtime/reflection.rb#22
-Tapioca::Runtime::Reflection::CONSTANTS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca/lib/tapioca/runtime/reflection.rb#28
-Tapioca::Runtime::Reflection::EQUAL_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca/lib/tapioca/runtime/reflection.rb#32
-Tapioca::Runtime::Reflection::METHOD_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca/lib/tapioca/runtime/reflection.rb#23
-Tapioca::Runtime::Reflection::NAME_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca/lib/tapioca/runtime/reflection.rb#27
-Tapioca::Runtime::Reflection::OBJECT_ID_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca/lib/tapioca/runtime/reflection.rb#31
-Tapioca::Runtime::Reflection::PRIVATE_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca/lib/tapioca/runtime/reflection.rb#30
-Tapioca::Runtime::Reflection::PROTECTED_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca/lib/tapioca/runtime/reflection.rb#29
-Tapioca::Runtime::Reflection::PUBLIC_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca/lib/tapioca/runtime/reflection.rb#35
-Tapioca::Runtime::Reflection::REQUIRED_FROM_LABELS = T.let(T.unsafe(nil), Array)
-
-# source://tapioca/lib/tapioca/runtime/reflection.rb#24
-Tapioca::Runtime::Reflection::SINGLETON_CLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca/lib/tapioca/runtime/reflection.rb#26
-Tapioca::Runtime::Reflection::SUPERCLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
-
-# source://tapioca/lib/tapioca/runtime/trackers/autoload.rb#6
-module Tapioca::Runtime::Trackers
-  class << self
-    # source://tapioca/lib/tapioca/runtime/trackers.rb#34
-    sig { void }
-    def disable_all!; end
-
-    # source://tapioca/lib/tapioca/runtime/trackers.rb#39
-    sig { params(tracker: ::Tapioca::Runtime::Trackers::Tracker).void }
-    def register_tracker(tracker); end
-
-    # source://tapioca/lib/tapioca/runtime/trackers.rb#21
-    sig do
-      type_parameters(:Return)
-        .params(
-          blk: T.proc.returns(T.type_parameter(:Return))
-        ).returns(T.type_parameter(:Return))
-    end
-    def with_trackers_enabled(&blk); end
-  end
-end
-
-# source://tapioca/lib/tapioca/runtime/trackers/autoload.rb#7
-module Tapioca::Runtime::Trackers::Autoload
-  extend ::Tapioca::Runtime::Trackers::Tracker
-
-  class << self
-    # source://tapioca/lib/tapioca/runtime/trackers/autoload.rb#19
-    sig { void }
-    def eager_load_all!; end
-
-    # source://tapioca/lib/tapioca/runtime/trackers/autoload.rb#31
-    sig { params(constant_name: ::String).void }
-    def register(constant_name); end
-
-    # source://tapioca/lib/tapioca/runtime/trackers/autoload.rb#42
-    sig do
-      type_parameters(:Result)
-        .params(
-          block: T.proc.returns(T.type_parameter(:Result))
-        ).returns(T.type_parameter(:Result))
-    end
-    def with_disabled_exits(&block); end
-  end
-end
-
-# source://tapioca/lib/tapioca/runtime/trackers/autoload.rb#11
-Tapioca::Runtime::Trackers::Autoload::NOOP_METHOD = T.let(T.unsafe(nil), Proc)
-
-# Registers a TracePoint immediately upon load to track points at which
-# classes and modules are opened for definition. This is used to track
-# correspondence between classes/modules and files, as this information isn't
-# available in the ruby runtime without extra accounting.
-module Tapioca::Runtime::Trackers::ConstantDefinition
-  extend ::Tapioca::Runtime::Trackers::Tracker
-  extend ::Tapioca::Runtime::AttachedClassOf
-  extend ::Tapioca::Runtime::Reflection
-
-  class << self
-    # source://tapioca/lib/tapioca/runtime/trackers/constant_definition.rb#61
-    def build_constant_location(tp, locations); end
-
-    # source://tapioca/lib/tapioca/runtime/trackers/constant_definition.rb#55
-    def disable!; end
-
-    # Returns the files in which this class or module was opened. Doesn't know
-    # about situations where the class was opened prior to +require+ing,
-    # or where metaprogramming was used via +eval+, etc.
-    #
-    # source://tapioca/lib/tapioca/runtime/trackers/constant_definition.rb#71
-    def files_for(klass); end
-
-    # source://tapioca/lib/tapioca/runtime/trackers/constant_definition.rb#75
-    def locations_for(klass); end
-  end
-end
-
-module Tapioca::Runtime::Trackers::Mixin
-  extend ::Tapioca::Runtime::Trackers::Tracker
-
-  class << self
-    # source://tapioca/lib/tapioca/runtime/trackers/mixin.rb#56
-    sig do
-      params(
-        mixin: ::Module
-      ).returns(T::Hash[::Tapioca::Runtime::Trackers::Mixin::Type, T::Hash[::Module, ::String]])
-    end
-    def constants_with_mixin(mixin); end
-
-    # source://tapioca/lib/tapioca/runtime/trackers/mixin.rb#61
-    sig do
-      params(
-        mixin: ::Module,
-        mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type,
-        constant: ::Module
-      ).returns(T.nilable(::String))
-    end
-    def mixin_location(mixin, mixin_type, constant); end
-
-    # source://tapioca/lib/tapioca/runtime/trackers/mixin.rb#35
-    sig { params(constant: ::Module, mixin: ::Module, mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type).void }
-    def register(constant, mixin, mixin_type); end
-
-    # source://tapioca/lib/tapioca/runtime/trackers/mixin.rb#43
-    def resolve_to_attached_class(constant, mixin, mixin_type); end
-
-    # source://tapioca/lib/tapioca/runtime/trackers/mixin.rb#30
-    sig do
-      type_parameters(:Result)
-        .params(
-          block: T.proc.returns(T.type_parameter(:Result))
-        ).returns(T.type_parameter(:Result))
-    end
-    def with_disabled_registration(&block); end
-
-    private
-
-    # source://tapioca/lib/tapioca/runtime/trackers/mixin.rb#76
-    sig do
-      params(
-        mixin: ::Module
-      ).returns(T::Hash[::Tapioca::Runtime::Trackers::Mixin::Type, T::Hash[::Module, ::String]])
-    end
-    def find_or_initialize_mixin_lookup(mixin); end
-
-    # source://tapioca/lib/tapioca/runtime/trackers/mixin.rb#68
-    sig do
-      params(
-        constant: ::Module,
-        mixin: ::Module,
-        mixin_type: ::Tapioca::Runtime::Trackers::Mixin::Type,
-        location: ::String
-      ).void
-    end
-    def register_with_location(constant, mixin, mixin_type, location); end
-  end
-end
-
-class Tapioca::Runtime::Trackers::Mixin::Type < ::T::Enum
-  enums do
-    Extend = new
-    Include = new
-    Prepend = new
-  end
-end
-
-# source://tapioca/lib/tapioca/runtime/trackers/required_ancestor.rb#7
-module Tapioca::Runtime::Trackers::RequiredAncestor
-  extend ::Tapioca::Runtime::Trackers::Tracker
-
-  class << self
-    # source://tapioca/lib/tapioca/runtime/trackers/required_ancestor.rb#15
-    sig { params(requiring: ::T::Helpers, block: T.proc.void).void }
-    def register(requiring, block); end
-
-    # source://tapioca/lib/tapioca/runtime/trackers/required_ancestor.rb#23
-    sig { params(mod: ::Module).returns(T::Array[T.proc.void]) }
-    def required_ancestors_blocks_by(mod); end
-
-    # source://tapioca/lib/tapioca/runtime/trackers/required_ancestor.rb#28
-    sig { params(mod: ::Module).returns(T::Array[T.untyped]) }
-    def required_ancestors_by(mod); end
-  end
-end
-
-# @abstract Subclasses must implement the `abstract` methods below.
-module Tapioca::Runtime::Trackers::Tracker
-  abstract!
-
-  # source://tapioca/lib/tapioca/runtime/trackers/tracker.rb#26
-  sig { void }
-  def disable!; end
-
-  # @return [Boolean]
-  #
-  # source://tapioca/lib/tapioca/runtime/trackers/tracker.rb#30
-  def enabled?; end
-
-  # source://tapioca/lib/tapioca/runtime/trackers/tracker.rb#34
-  def with_disabled_tracker(&block); end
-
-  class << self
-    # source://tapioca/lib/tapioca/runtime/trackers/tracker.rb#17
-    sig { params(base: T.all(::Module, ::Tapioca::Runtime::Trackers::Tracker)).void }
-    def extended(base); end
-  end
-end
-
-# source://tapioca/lib/tapioca.rb#35
-Tapioca::SORBET_CONFIG_FILE = T.let(T.unsafe(nil), String)
-
-# source://tapioca/lib/tapioca.rb#34
-Tapioca::SORBET_DIR = T.let(T.unsafe(nil), String)
-
-# source://tapioca/lib/tapioca/helpers/sorbet_helper.rb#5
-module Tapioca::SorbetHelper
-  # source://tapioca/lib/tapioca/helpers/sorbet_helper.rb#32
-  sig { params(sorbet_args: ::String).returns(::Spoom::ExecResult) }
-  def sorbet(*sorbet_args); end
-
-  # source://tapioca/lib/tapioca/helpers/sorbet_helper.rb#37
-  sig { returns(::String) }
-  def sorbet_path; end
-
-  # source://tapioca/lib/tapioca/helpers/sorbet_helper.rb#44
-  sig { params(feature: ::Symbol, version: T.nilable(::Gem::Version)).returns(T::Boolean) }
-  def sorbet_supports?(feature, version: T.unsafe(nil)); end
-end
-
-# source://tapioca/lib/tapioca/helpers/sorbet_helper.rb#24
-Tapioca::SorbetHelper::FEATURE_REQUIREMENTS = T.let(T.unsafe(nil), Hash)
-
-# source://tapioca/lib/tapioca/helpers/sorbet_helper.rb#13
-Tapioca::SorbetHelper::SORBET_BIN = T.let(T.unsafe(nil), Pathname)
-
-# source://tapioca/lib/tapioca/helpers/sorbet_helper.rb#18
-Tapioca::SorbetHelper::SORBET_EXE_PATH_ENV_VAR = T.let(T.unsafe(nil), String)
-
-# source://tapioca/lib/tapioca/helpers/sorbet_helper.rb#8
-Tapioca::SorbetHelper::SORBET_GEM_SPEC = T.let(T.unsafe(nil), Gem::Specification)
-
-# source://tapioca/lib/tapioca/helpers/sorbet_helper.rb#20
-Tapioca::SorbetHelper::SORBET_PAYLOAD_URL = T.let(T.unsafe(nil), String)
-
-# source://tapioca/lib/tapioca/helpers/sorbet_helper.rb#22
-Tapioca::SorbetHelper::SPOOM_CONTEXT = T.let(T.unsafe(nil), Spoom::Context)
-
-# source://tapioca/lib/tapioca/static/symbol_table_parser.rb#5
-module Tapioca::Static; end
-
-# source://tapioca/lib/tapioca/static/requires_compiler.rb#6
-class Tapioca::Static::RequiresCompiler
-  # source://tapioca/lib/tapioca/static/requires_compiler.rb#10
-  sig { params(sorbet_path: ::String).void }
-  def initialize(sorbet_path); end
-
-  # source://tapioca/lib/tapioca/static/requires_compiler.rb#15
-  sig { returns(::String) }
-  def compile; end
-
-  private
-
-  # source://tapioca/lib/tapioca/static/requires_compiler.rb#29
-  sig { params(config: ::Spoom::Sorbet::Config).returns(T::Array[::String]) }
-  def collect_files(config); end
-
-  # source://tapioca/lib/tapioca/static/requires_compiler.rb#44
-  sig { params(file_path: ::String).returns(T::Enumerable[::String]) }
-  def collect_requires(file_path); end
-
-  # source://tapioca/lib/tapioca/static/requires_compiler.rb#51
-  sig { params(config: ::Spoom::Sorbet::Config, file_path: ::Pathname).returns(T::Boolean) }
-  def file_ignored_by_sorbet?(config, file_path); end
-
-  # source://tapioca/lib/tapioca/static/requires_compiler.rb#80
-  sig { params(path: ::Pathname).returns(T::Array[::String]) }
-  def path_parts(path); end
-end
-
-# source://tapioca/lib/tapioca/static/symbol_loader.rb#6
-module Tapioca::Static::SymbolLoader
-  extend ::Tapioca::SorbetHelper
-  extend ::Tapioca::Runtime::AttachedClassOf
-  extend ::Tapioca::Runtime::Reflection
-
-  class << self
-    # source://tapioca/lib/tapioca/static/symbol_loader.rb#23
-    sig { params(gem: ::Tapioca::Gemfile::GemSpec).returns(T::Set[::String]) }
-    def engine_symbols(gem); end
-
-    # source://tapioca/lib/tapioca/static/symbol_loader.rb#48
-    sig { params(gem: ::Tapioca::Gemfile::GemSpec).returns(T::Set[::String]) }
-    def gem_symbols(gem); end
-
-    # source://tapioca/lib/tapioca/static/symbol_loader.rb#13
-    sig { returns(T::Set[::String]) }
-    def payload_symbols; end
-
-    # source://tapioca/lib/tapioca/static/symbol_loader.rb#53
-    sig { params(paths: T::Array[::Pathname]).returns(T::Set[::String]) }
-    def symbols_from_paths(paths); end
-
-    private
-
-    # @return [Array<T.class_of(Rails::Engine)>]
-    #
-    # source://tapioca/lib/tapioca/static/symbol_loader.rb#71
-    def engines; end
-
-    # source://tapioca/lib/tapioca/static/symbol_loader.rb#84
-    sig { params(input: ::String, table_type: ::String).returns(::String) }
-    def symbol_table_json_from(input, table_type: T.unsafe(nil)); end
-  end
-end
-
-# source://tapioca/lib/tapioca/static/symbol_table_parser.rb#6
-class Tapioca::Static::SymbolTableParser
-  # source://tapioca/lib/tapioca/static/symbol_table_parser.rb#30
-  sig { void }
-  def initialize; end
-
-  # source://tapioca/lib/tapioca/static/symbol_table_parser.rb#65
-  sig { params(name: ::String).returns(::String) }
-  def fully_qualified_name(name); end
-
-  # source://tapioca/lib/tapioca/static/symbol_table_parser.rb#36
-  sig { params(object: T::Hash[::String, T.untyped]).void }
-  def parse_object(object); end
-
-  # source://tapioca/lib/tapioca/static/symbol_table_parser.rb#27
-  sig { returns(T::Set[::String]) }
-  def symbols; end
-
-  class << self
-    # source://tapioca/lib/tapioca/static/symbol_table_parser.rb#15
-    sig { params(json_string: ::String).returns(T::Set[::String]) }
-    def parse_json(json_string); end
-  end
-end
-
-# source://tapioca/lib/tapioca/static/symbol_table_parser.rb#9
-Tapioca::Static::SymbolTableParser::SKIP_PARSE_KINDS = T.let(T.unsafe(nil), Array)
-
-# source://tapioca/lib/tapioca.rb#37
-Tapioca::TAPIOCA_CONFIG_FILE = T.let(T.unsafe(nil), String)
-
-# source://tapioca/lib/tapioca.rb#36
-Tapioca::TAPIOCA_DIR = T.let(T.unsafe(nil), String)
-
-# source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#108
-class Tapioca::TypeVariable < ::T::Types::TypeVariable
-  # @return [TypeVariable] a new instance of TypeVariable
-  #
-  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#109
-  def initialize(name, variance); end
-
-  # Returns the value of attribute name.
-  #
-  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#114
-  def name; end
-end
-
-# This is subclassing from `Module` so that instances of this type will be modules.
-# The reason why we want that is because that means those instances will automatically
-# get bound to the constant names they are assigned to by Ruby. As a result, we don't
-# need to do any matching of constants to type variables to bind their names, Ruby will
-# do that automatically for us and we get the `name` method for free from `Module`.
-#
-# source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#122
-class Tapioca::TypeVariableModule < ::Module
-  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#146
-  sig do
-    params(
-      context: ::Module,
-      type: ::Tapioca::TypeVariableModule::Type,
-      variance: ::Symbol,
-      bounds_proc: T.nilable(T.proc.returns(T::Hash[::Symbol, T.untyped]))
-    ).void
-  end
-  def initialize(context, type, variance, bounds_proc); end
-
-  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#181
-  sig { returns(::Tapioca::TypeVariable) }
-  def coerce_to_type_variable; end
-
-  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#161
-  sig { returns(T::Boolean) }
-  def fixed?; end
-
-  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#155
-  sig { returns(T.nilable(::String)) }
-  def name; end
-
-  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#166
-  sig { returns(::String) }
-  def serialize; end
-
-  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#136
-  sig { returns(::Tapioca::TypeVariableModule::Type) }
-  def type; end
-
-  private
-
-  # source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#188
-  sig { returns(T::Hash[::Symbol, T.untyped]) }
-  def bounds; end
-end
-
-# source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#133
-Tapioca::TypeVariableModule::DEFAULT_BOUNDS_PROC = T.let(T.unsafe(nil), Proc)
-
-# source://tapioca/lib/tapioca/sorbet_ext/generic_name_patch.rb#125
-class Tapioca::TypeVariableModule::Type < ::T::Enum
-  enums do
-    HasAttachedClass = new
-    Member = new
-    Template = new
-  end
-end
-
-# source://tapioca/lib/tapioca/version.rb#5
-Tapioca::VERSION = T.let(T.unsafe(nil), String)
-
-# source://tapioca/lib/tapioca/helpers/source_uri.rb#7
-class URI::Source < ::URI::File
-  # source://ruby-lsp/0.23.6lib/ruby_lsp/requests/support/source_uri.rb#69
-  sig { params(v: T.nilable(::String)).returns(T::Boolean) }
-  def check_host(v); end
-
-  # source://tapioca/lib/tapioca/helpers/source_uri.rb#55
-  sig { returns(T.nilable(::String)) }
-  def gem_name; end
-
-  # source://ruby-lsp/0.23.6lib/ruby_lsp/requests/support/source_uri.rb#33
-  sig { returns(T.nilable(::String)) }
-  def gem_version; end
-
-  # source://tapioca/lib/tapioca/helpers/source_uri.rb#60
-  sig { returns(T.nilable(::String)) }
-  def line_number; end
-
-  # source://ruby-lsp/0.23.6lib/ruby_lsp/requests/support/source_uri.rb#59
-  sig { params(v: T.nilable(::String)).void }
-  def set_path(v); end
-
-  # source://ruby-lsp/0.23.6lib/ruby_lsp/requests/support/source_uri.rb#81
-  sig { returns(::String) }
-  def to_s; end
-
-  class << self
-    # source://ruby-lsp/0.23.6lib/ruby_lsp/requests/support/source_uri.rb#46
-    sig do
-      params(
-        gem_name: ::String,
-        gem_version: T.nilable(::String),
-        path: ::String,
-        line_number: T.nilable(::String)
-      ).returns(::URI::Source)
-    end
-    def build(gem_name:, gem_version:, path:, line_number:); end
-  end
-end
diff --git a/sorbet/rbi/gems/tapioca@0.16.8.rbi b/sorbet/rbi/gems/tapioca@0.16.8.rbi
index fb3b20f4..5e1e4573 100644
--- a/sorbet/rbi/gems/tapioca@0.16.8.rbi
+++ b/sorbet/rbi/gems/tapioca@0.16.8.rbi
@@ -218,13 +218,7 @@ class RBI::TypedParam < ::T::Struct
   const :type, ::String
 
   class << self
-<<<<<<<< HEAD:sorbet/rbi/gems/tapioca@0.16.8.rbi
     # source://sorbet-runtime/0.5.11761lib/types/struct.rb#13
-|||||||| parent of 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.5.rbi
-    # source://sorbet-runtime/0.5.11635lib/types/struct.rb#13
-========
-    # source://sorbet-runtime/0.5.11725lib/types/struct.rb#13
->>>>>>>> 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.6.rbi
     def inherited(s); end
   end
 end
@@ -1149,13 +1143,7 @@ class Tapioca::ConfigHelper::ConfigError < ::T::Struct
   const :message_parts, T::Array[::Tapioca::ConfigHelper::ConfigErrorMessagePart]
 
   class << self
-<<<<<<<< HEAD:sorbet/rbi/gems/tapioca@0.16.8.rbi
     # source://sorbet-runtime/0.5.11761lib/types/struct.rb#13
-|||||||| parent of 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.5.rbi
-    # source://sorbet-runtime/0.5.11635lib/types/struct.rb#13
-========
-    # source://sorbet-runtime/0.5.11725lib/types/struct.rb#13
->>>>>>>> 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.6.rbi
     def inherited(s); end
   end
 end
@@ -1166,13 +1154,7 @@ class Tapioca::ConfigHelper::ConfigErrorMessagePart < ::T::Struct
   const :colors, T::Array[::Symbol]
 
   class << self
-<<<<<<<< HEAD:sorbet/rbi/gems/tapioca@0.16.8.rbi
     # source://sorbet-runtime/0.5.11761lib/types/struct.rb#13
-|||||||| parent of 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.5.rbi
-    # source://sorbet-runtime/0.5.11635lib/types/struct.rb#13
-========
-    # source://sorbet-runtime/0.5.11725lib/types/struct.rb#13
->>>>>>>> 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.6.rbi
     def inherited(s); end
   end
 end
@@ -2246,13 +2228,7 @@ class Tapioca::GemInfo < ::T::Struct
     sig { params(spec: ::Bundler::LazySpecification).returns(::Tapioca::GemInfo) }
     def from_spec(spec); end
 
-<<<<<<<< HEAD:sorbet/rbi/gems/tapioca@0.16.8.rbi
     # source://sorbet-runtime/0.5.11761lib/types/struct.rb#13
-|||||||| parent of 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.5.rbi
-    # source://sorbet-runtime/0.5.11635lib/types/struct.rb#13
-========
-    # source://sorbet-runtime/0.5.11725lib/types/struct.rb#13
->>>>>>>> 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.6.rbi
     def inherited(s); end
   end
 end
@@ -2452,13 +2428,7 @@ class Tapioca::Loaders::Dsl < ::Tapioca::Loaders::Loader
 
   protected
 
-<<<<<<<< HEAD:sorbet/rbi/gems/tapioca@0.16.8.rbi
   # source://tapioca/lib/tapioca/loaders/dsl.rb#103
-|||||||| parent of 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.5.rbi
-  # source://tapioca/lib/tapioca/loaders/dsl.rb#105
-========
-  # source://tapioca/lib/tapioca/loaders/dsl.rb#110
->>>>>>>> 0e32ef8 (Update Tapioca):sorbet/rbi/gems/tapioca@0.16.6.rbi
   sig { void }
   def load_application; end