diff --git a/Gemfile b/Gemfile
index 1c186ef7..d7fccc74 100644
--- a/Gemfile
+++ b/Gemfile
@@ -5,8 +5,9 @@ source "https://rubygems.org"
 
 gemspec
 
-group(:development) do
-  gem('rubocop-shopify', require: false)
-  gem('rubocop-sorbet', require: false)
-  gem('pry-byebug')
+group :development do
+  gem "pry-byebug"
+  gem "rubocop-shopify", require: false
+  gem "rubocop-sorbet", require: false
+  gem "tapioca", require: false
 end
diff --git a/Gemfile.lock b/Gemfile.lock
index 9987a309..3a95f43b 100644
--- a/Gemfile.lock
+++ b/Gemfile.lock
@@ -9,14 +9,38 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
+    abstract_type (0.0.7)
+    adamantium (0.2.0)
+      ice_nine (~> 0.11.0)
+      memoizable (~> 0.4.0)
+    anima (0.3.2)
+      abstract_type (~> 0.0.7)
+      adamantium (~> 0.2)
+      equalizer (~> 0.0.11)
     ast (2.4.1)
     byebug (11.1.3)
     coderay (1.1.3)
+    concord (0.1.6)
+      adamantium (~> 0.2.0)
+      equalizer (~> 0.0.9)
+    diff-lcs (1.4.4)
+    equalizer (0.0.11)
+    ice_nine (0.11.2)
+    memoizable (0.4.2)
+      thread_safe (~> 0.3, >= 0.3.1)
     method_source (1.0.0)
     minitest (5.14.3)
+    mprelude (0.1.0)
+      abstract_type (~> 0.0.7)
+      adamantium (~> 0.2.0)
+      concord (~> 0.1.5)
+      equalizer (~> 0.0.9)
+      ice_nine (~> 0.11.1)
+      procto (~> 0.0.2)
     parallel (1.19.2)
     parser (2.7.1.4)
       ast (~> 2.4.1)
+    procto (0.0.3)
     pry (0.13.1)
       coderay (~> 1.1)
       method_source (~> 1.0)
@@ -25,6 +49,11 @@ GEM
       pry (~> 0.13.0)
     rainbow (3.0.0)
     rake (13.0.1)
+    rbi (0.0.6)
+      ast
+      parser
+      sorbet-runtime (>= 0.5.9204)
+      unparser
     regexp_parser (1.7.1)
     rexml (3.2.5)
     rubocop (0.86.0)
@@ -55,8 +84,32 @@ GEM
     sorbet-static (0.5.9271-universal-darwin-20)
     sorbet-static (0.5.9271-universal-darwin-21)
     sorbet-static (0.5.9271-x86_64-linux)
+    tapioca (0.5.4)
+      bundler (>= 1.17.3)
+      pry (>= 0.12.2)
+      rbi
+      sorbet-runtime
+      sorbet-static (>= 0.5.6200)
+      spoom
+      thor (>= 0.19.2)
+      yard-sorbet
     thor (1.1.0)
+    thread_safe (0.3.6)
     unicode-display_width (1.7.0)
+    unparser (0.5.5)
+      abstract_type (~> 0.0.7)
+      adamantium (~> 0.2.0)
+      anima (~> 0.3.1)
+      concord (~> 0.1.5)
+      diff-lcs (~> 1.3)
+      equalizer (~> 0.0.9)
+      mprelude (~> 0.1.0)
+      parser (>= 2.6.5)
+      procto (~> 0.0.2)
+    yard (0.9.26)
+    yard-sorbet (0.6.1)
+      sorbet-runtime (>= 0.5)
+      yard (>= 0.9)
 
 PLATFORMS
   ruby
@@ -69,6 +122,7 @@ DEPENDENCIES
   rubocop-shopify
   rubocop-sorbet
   spoom!
+  tapioca
 
 BUNDLED WITH
    2.2.27
diff --git a/sorbet/rbi/gems/abstract_type@0.0.7.rbi b/sorbet/rbi/gems/abstract_type@0.0.7.rbi
new file mode 100644
index 00000000..4464cab0
--- /dev/null
+++ b/sorbet/rbi/gems/abstract_type@0.0.7.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `abstract_type` gem.
+# Please instead update this file by running `bin/tapioca gem abstract_type`.
+
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires
diff --git a/sorbet/rbi/gems/adamantium@0.2.0.rbi b/sorbet/rbi/gems/adamantium@0.2.0.rbi
new file mode 100644
index 00000000..c8d6ecf4
--- /dev/null
+++ b/sorbet/rbi/gems/adamantium@0.2.0.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `adamantium` gem.
+# Please instead update this file by running `bin/tapioca gem adamantium`.
+
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires
diff --git a/sorbet/rbi/gems/anima@0.3.2.rbi b/sorbet/rbi/gems/anima@0.3.2.rbi
new file mode 100644
index 00000000..4d71fd49
--- /dev/null
+++ b/sorbet/rbi/gems/anima@0.3.2.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `anima` gem.
+# Please instead update this file by running `bin/tapioca gem anima`.
+
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires
diff --git a/sorbet/rbi/gems/ast@2.4.1.rbi b/sorbet/rbi/gems/ast@2.4.1.rbi
index 5534cd94..7cf87a40 100644
--- a/sorbet/rbi/gems/ast@2.4.1.rbi
+++ b/sorbet/rbi/gems/ast@2.4.1.rbi
@@ -1,6 +1,53 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca generate
-
 # typed: true
 
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `ast` gem.
+# Please instead update this file by running `bin/tapioca gem ast`.
+
+module AST; end
+
+class AST::Node
+  def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end
+
+  def +(array); end
+  def <<(element); end
+  def ==(other); end
+  def append(element); end
+  def children; end
+  def clone; end
+  def concat(array); end
+  def dup; end
+  def eql?(other); end
+  def hash; end
+  def inspect(indent = T.unsafe(nil)); end
+  def to_a; end
+  def to_ast; end
+  def to_s(indent = T.unsafe(nil)); end
+  def to_sexp(indent = T.unsafe(nil)); end
+  def to_sexp_array; end
+  def type; end
+  def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end
+
+  protected
+
+  def assign_properties(properties); end
+  def fancy_type; end
+
+  private
+
+  def original_dup; end
+end
+
+class AST::Processor
+  include ::AST::Processor::Mixin
+end
+
+module AST::Processor::Mixin
+  def handler_missing(node); end
+  def process(node); end
+  def process_all(nodes); end
+end
 
+module AST::Sexp
+  def s(type, *children); end
+end
diff --git a/sorbet/rbi/gems/byebug@11.1.3.rbi b/sorbet/rbi/gems/byebug@11.1.3.rbi
new file mode 100644
index 00000000..d242dfa8
--- /dev/null
+++ b/sorbet/rbi/gems/byebug@11.1.3.rbi
@@ -0,0 +1,1568 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `byebug` gem.
+# Please instead update this file by running `bin/tapioca gem byebug`.
+
+module Byebug
+  include ::Byebug::Helpers::ReflectionHelper
+  extend ::Byebug::Helpers::ReflectionHelper
+  extend ::Byebug
+
+  def displays; end
+  def displays=(_arg0); end
+  def init_file; end
+  def init_file=(_arg0); end
+  def mode; end
+  def mode=(_arg0); end
+  def run_init_script; end
+
+  private
+
+  def add_catchpoint(_arg0); end
+  def breakpoints; end
+  def catchpoints; end
+  def contexts; end
+  def current_context; end
+  def debug_load(*_arg0); end
+  def lock; end
+  def post_mortem=(_arg0); end
+  def post_mortem?; end
+  def raised_exception; end
+  def rc_dirs; end
+  def run_rc_file(rc_file); end
+  def start; end
+  def started?; end
+  def stop; end
+  def stoppable?; end
+  def thread_context(_arg0); end
+  def tracing=(_arg0); end
+  def tracing?; end
+  def unlock; end
+  def verbose=(_arg0); end
+  def verbose?; end
+
+  class << self
+    def actual_control_port; end
+    def actual_port; end
+    def add_catchpoint(_arg0); end
+    def attach; end
+    def breakpoints; end
+    def catchpoints; end
+    def contexts; end
+    def current_context; end
+    def debug_load(*_arg0); end
+    def handle_post_mortem; end
+    def interrupt; end
+    def load_settings; end
+    def lock; end
+    def parse_host_and_port(host_port_spec); end
+    def post_mortem=(_arg0); end
+    def post_mortem?; end
+    def raised_exception; end
+    def spawn(host = T.unsafe(nil), port = T.unsafe(nil)); end
+    def start; end
+    def start_client(host = T.unsafe(nil), port = T.unsafe(nil)); end
+    def start_control(host = T.unsafe(nil), port = T.unsafe(nil)); end
+    def start_server(host = T.unsafe(nil), port = T.unsafe(nil)); end
+    def started?; end
+    def stop; end
+    def stoppable?; end
+    def thread_context(_arg0); end
+    def tracing=(_arg0); end
+    def tracing?; end
+    def unlock; end
+    def verbose=(_arg0); end
+    def verbose?; end
+    def wait_connection; end
+    def wait_connection=(_arg0); end
+
+    private
+
+    def client; end
+    def control; end
+    def server; end
+  end
+end
+
+class Byebug::AutoirbSetting < ::Byebug::Setting
+  def initialize; end
+
+  def banner; end
+  def value; end
+  def value=(val); end
+end
+
+Byebug::AutoirbSetting::DEFAULT = T.let(T.unsafe(nil), Integer)
+
+class Byebug::AutolistSetting < ::Byebug::Setting
+  def initialize; end
+
+  def banner; end
+  def value; end
+  def value=(val); end
+end
+
+Byebug::AutolistSetting::DEFAULT = T.let(T.unsafe(nil), Integer)
+
+class Byebug::AutoprySetting < ::Byebug::Setting
+  def initialize; end
+
+  def banner; end
+  def value; end
+  def value=(val); end
+end
+
+Byebug::AutoprySetting::DEFAULT = T.let(T.unsafe(nil), Integer)
+
+class Byebug::AutosaveSetting < ::Byebug::Setting
+  def banner; end
+end
+
+Byebug::AutosaveSetting::DEFAULT = T.let(T.unsafe(nil), TrueClass)
+
+class Byebug::BasenameSetting < ::Byebug::Setting
+  def banner; end
+end
+
+class Byebug::BreakCommand < ::Byebug::Command
+  include ::Byebug::Helpers::EvalHelper
+  include ::Byebug::Helpers::FileHelper
+  include ::Byebug::Helpers::ParseHelper
+
+  def execute; end
+
+  private
+
+  def add_line_breakpoint(file, line); end
+  def line_breakpoint(location); end
+  def method_breakpoint(location); end
+  def target_object(str); end
+  def valid_breakpoints_for(path, line); end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::Breakpoint
+  def initialize(_arg0, _arg1, _arg2); end
+
+  def enabled=(_arg0); end
+  def enabled?; end
+  def expr; end
+  def expr=(_arg0); end
+  def hit_condition; end
+  def hit_condition=(_arg0); end
+  def hit_count; end
+  def hit_value; end
+  def hit_value=(_arg0); end
+  def id; end
+  def inspect; end
+  def pos; end
+  def source; end
+
+  class << self
+    def add(file, line, expr = T.unsafe(nil)); end
+    def first; end
+    def last; end
+    def none?; end
+    def potential_line?(filename, lineno); end
+    def potential_lines(filename); end
+    def remove(id); end
+
+    private
+
+    def potential_lines_with_trace_points(iseq, lines); end
+    def potential_lines_without_trace_points(iseq, lines); end
+  end
+end
+
+class Byebug::CallstyleSetting < ::Byebug::Setting
+  def banner; end
+  def to_s; end
+end
+
+Byebug::CallstyleSetting::DEFAULT = T.let(T.unsafe(nil), String)
+
+class Byebug::CatchCommand < ::Byebug::Command
+  include ::Byebug::Helpers::EvalHelper
+
+  def execute; end
+
+  private
+
+  def add(exception); end
+  def clear; end
+  def info; end
+  def remove(exception); end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::Command
+  extend ::Forwardable
+  extend ::Byebug::Helpers::StringHelper
+
+  def initialize(processor, input = T.unsafe(nil)); end
+
+  def arguments; end
+  def confirm(*args, &block); end
+  def context; end
+  def errmsg(*args, &block); end
+  def frame; end
+  def help(*args, &block); end
+  def match(*args, &block); end
+  def pr(*args, &block); end
+  def prc(*args, &block); end
+  def print(*args, &block); end
+  def processor; end
+  def prv(*args, &block); end
+  def puts(*args, &block); end
+
+  class << self
+    def allow_in_control; end
+    def allow_in_control=(_arg0); end
+    def allow_in_post_mortem; end
+    def allow_in_post_mortem=(_arg0); end
+    def always_run; end
+    def always_run=(_arg0); end
+    def columnize(width); end
+    def help; end
+    def match(input); end
+    def to_s; end
+  end
+end
+
+class Byebug::CommandList
+  include ::Enumerable
+
+  def initialize(commands); end
+
+  def each; end
+  def match(input); end
+  def to_s; end
+
+  private
+
+  def width; end
+end
+
+class Byebug::CommandNotFound < ::NoMethodError
+  def initialize(input, parent = T.unsafe(nil)); end
+
+  private
+
+  def build_cmd(*args); end
+  def help; end
+  def name; end
+end
+
+class Byebug::CommandProcessor
+  include ::Byebug::Helpers::EvalHelper
+  extend ::Forwardable
+
+  def initialize(context, interface = T.unsafe(nil)); end
+
+  def at_breakpoint(brkpt); end
+  def at_catchpoint(exception); end
+  def at_end; end
+  def at_line; end
+  def at_return(return_value); end
+  def at_tracing; end
+  def command_list; end
+  def commands(*args, &block); end
+  def confirm(*args, &block); end
+  def context; end
+  def errmsg(*args, &block); end
+  def frame(*args, &block); end
+  def interface; end
+  def pr(*args, &block); end
+  def prc(*args, &block); end
+  def prev_line; end
+  def prev_line=(_arg0); end
+  def printer; end
+  def proceed!; end
+  def process_commands; end
+  def prv(*args, &block); end
+  def puts(*args, &block); end
+
+  protected
+
+  def after_repl; end
+  def before_repl; end
+  def prompt; end
+  def repl; end
+
+  private
+
+  def auto_cmds_for(run_level); end
+  def run_auto_cmds(run_level); end
+  def run_cmd(input); end
+  def safely; end
+end
+
+class Byebug::ConditionCommand < ::Byebug::Command
+  include ::Byebug::Helpers::ParseHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::Context
+  include ::Byebug::Helpers::FileHelper
+  extend ::Byebug::Helpers::PathHelper
+  extend ::Forwardable
+
+  def at_breakpoint(breakpoint); end
+  def at_catchpoint(exception); end
+  def at_end; end
+  def at_line; end
+  def at_return(return_value); end
+  def at_tracing; end
+  def backtrace; end
+  def dead?; end
+  def file(*args, &block); end
+  def frame; end
+  def frame=(pos); end
+  def frame_binding(*_arg0); end
+  def frame_class(*_arg0); end
+  def frame_file(*_arg0); end
+  def frame_line(*_arg0); end
+  def frame_method(*_arg0); end
+  def frame_self(*_arg0); end
+  def full_location; end
+  def ignored?; end
+  def interrupt; end
+  def line(*args, &block); end
+  def location; end
+  def resume; end
+  def stack_size; end
+  def step_into(*_arg0); end
+  def step_out(*_arg0); end
+  def step_over(*_arg0); end
+  def stop_reason; end
+  def suspend; end
+  def suspended?; end
+  def switch; end
+  def thnum; end
+  def thread; end
+  def tracing; end
+  def tracing=(_arg0); end
+
+  private
+
+  def ignored_file?(path); end
+  def processor; end
+
+  class << self
+    def ignored_files; end
+    def ignored_files=(_arg0); end
+    def interface; end
+    def interface=(_arg0); end
+    def processor; end
+    def processor=(_arg0); end
+  end
+end
+
+class Byebug::ContinueCommand < ::Byebug::Command
+  include ::Byebug::Helpers::ParseHelper
+
+  def execute; end
+
+  private
+
+  def modifier; end
+  def unconditionally?; end
+  def until_line?; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::ControlProcessor < ::Byebug::CommandProcessor
+  def commands; end
+  def prompt; end
+end
+
+class Byebug::DebugCommand < ::Byebug::Command
+  include ::Byebug::Helpers::EvalHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::DebugThread < ::Thread
+  class << self
+    def inherited; end
+  end
+end
+
+class Byebug::DeleteCommand < ::Byebug::Command
+  include ::Byebug::Helpers::ParseHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::DisableCommand < ::Byebug::Command
+  include ::Byebug::Subcommands
+  extend ::Byebug::Helpers::ReflectionHelper
+  extend ::Byebug::Subcommands::ClassMethods
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::DisableCommand::BreakpointsCommand < ::Byebug::Command
+  include ::Byebug::Helpers::ParseHelper
+  include ::Byebug::Helpers::ToggleHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::DisableCommand::DisplayCommand < ::Byebug::Command
+  include ::Byebug::Helpers::ParseHelper
+  include ::Byebug::Helpers::ToggleHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::DisplayCommand < ::Byebug::Command
+  include ::Byebug::Helpers::EvalHelper
+
+  def execute; end
+
+  private
+
+  def display_expression(exp); end
+  def eval_expr(expression); end
+  def print_display_expressions; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::DownCommand < ::Byebug::Command
+  include ::Byebug::Helpers::FrameHelper
+  include ::Byebug::Helpers::ParseHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::EditCommand < ::Byebug::Command
+  def execute; end
+
+  private
+
+  def edit_error(type, file); end
+  def editor; end
+  def location(matched); end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::EnableCommand < ::Byebug::Command
+  include ::Byebug::Subcommands
+  extend ::Byebug::Helpers::ReflectionHelper
+  extend ::Byebug::Subcommands::ClassMethods
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::EnableCommand::BreakpointsCommand < ::Byebug::Command
+  include ::Byebug::Helpers::ParseHelper
+  include ::Byebug::Helpers::ToggleHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::EnableCommand::DisplayCommand < ::Byebug::Command
+  include ::Byebug::Helpers::ParseHelper
+  include ::Byebug::Helpers::ToggleHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::FinishCommand < ::Byebug::Command
+  include ::Byebug::Helpers::ParseHelper
+
+  def execute; end
+
+  private
+
+  def max_frames; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::Frame
+  include ::Byebug::Helpers::FileHelper
+
+  def initialize(context, pos); end
+
+  def _binding; end
+  def _class; end
+  def _method; end
+  def _self; end
+  def args; end
+  def c_frame?; end
+  def current?; end
+  def deco_args; end
+  def deco_block; end
+  def deco_call; end
+  def deco_class; end
+  def deco_file; end
+  def deco_method; end
+  def deco_pos; end
+  def file; end
+  def line; end
+  def locals; end
+  def mark; end
+  def pos; end
+  def to_hash; end
+
+  private
+
+  def c_args; end
+  def prefix_and_default(arg_type); end
+  def ruby_args; end
+  def use_short_style?(arg); end
+end
+
+class Byebug::FrameCommand < ::Byebug::Command
+  include ::Byebug::Helpers::FrameHelper
+  include ::Byebug::Helpers::ParseHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::FullpathSetting < ::Byebug::Setting
+  def banner; end
+end
+
+Byebug::FullpathSetting::DEFAULT = T.let(T.unsafe(nil), TrueClass)
+
+class Byebug::HelpCommand < ::Byebug::Command
+  def execute; end
+
+  private
+
+  def command; end
+  def help_for(input, cmd); end
+  def help_for_all; end
+  def subcommand; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+module Byebug::Helpers; end
+
+module Byebug::Helpers::BinHelper
+  def executable_file_extensions; end
+  def find_executable(path, cmd); end
+  def real_executable?(file); end
+  def search_paths; end
+  def which(cmd); end
+end
+
+module Byebug::Helpers::EvalHelper
+  def error_eval(str, binding = T.unsafe(nil)); end
+  def multiple_thread_eval(expression); end
+  def separate_thread_eval(expression); end
+  def silent_eval(str, binding = T.unsafe(nil)); end
+  def warning_eval(str, binding = T.unsafe(nil)); end
+
+  private
+
+  def allowing_other_threads; end
+  def error_msg(exception); end
+  def in_new_thread; end
+  def msg(exception); end
+  def safe_eval(str, binding); end
+  def safe_inspect(var); end
+  def safe_to_s(var); end
+  def warning_msg(exception); end
+end
+
+module Byebug::Helpers::FileHelper
+  def get_line(filename, lineno); end
+  def get_lines(filename); end
+  def n_lines(filename); end
+  def normalize(filename); end
+  def shortpath(fullpath); end
+  def virtual_file?(name); end
+end
+
+module Byebug::Helpers::FrameHelper
+  def jump_frames(steps); end
+  def switch_to_frame(frame); end
+
+  private
+
+  def adjust_frame(new_frame); end
+  def direction(step); end
+  def frame_err(msg); end
+  def index_from_start(index); end
+  def navigate_to_frame(jump_no); end
+  def out_of_bounds?(pos); end
+end
+
+module Byebug::Helpers::ParseHelper
+  def get_int(str, cmd, min = T.unsafe(nil), max = T.unsafe(nil)); end
+  def parse_steps(str, cmd); end
+  def syntax_valid?(code); end
+
+  private
+
+  def without_stderr; end
+end
+
+module Byebug::Helpers::PathHelper
+  def all_files; end
+  def bin_file; end
+  def gem_files; end
+  def lib_files; end
+  def root_path; end
+  def test_files; end
+
+  private
+
+  def glob_for(dir); end
+end
+
+module Byebug::Helpers::ReflectionHelper
+  def commands; end
+end
+
+module Byebug::Helpers::StringHelper
+  def camelize(str); end
+  def deindent(str, leading_spaces: T.unsafe(nil)); end
+  def prettify(str); end
+end
+
+module Byebug::Helpers::ThreadHelper
+  def context_from_thread(thnum); end
+  def current_thread?(ctx); end
+  def display_context(ctx); end
+  def thread_arguments(ctx); end
+
+  private
+
+  def debug_flag(ctx); end
+  def location(ctx); end
+  def status_flag(ctx); end
+end
+
+module Byebug::Helpers::ToggleHelper
+  include ::Byebug::Helpers::ParseHelper
+
+  def enable_disable_breakpoints(is_enable, args); end
+  def enable_disable_display(is_enable, args); end
+
+  private
+
+  def n_displays; end
+  def select_breakpoints(is_enable, args); end
+end
+
+module Byebug::Helpers::VarHelper
+  include ::Byebug::Helpers::EvalHelper
+
+  def var_args; end
+  def var_global; end
+  def var_instance(str); end
+  def var_list(ary, binding = T.unsafe(nil)); end
+  def var_local; end
+end
+
+class Byebug::HistfileSetting < ::Byebug::Setting
+  def banner; end
+  def to_s; end
+end
+
+Byebug::HistfileSetting::DEFAULT = T.let(T.unsafe(nil), String)
+
+class Byebug::History
+  def initialize; end
+
+  def buffer; end
+  def clear; end
+  def default_max_size; end
+  def ignore?(buf); end
+  def last_ids(number); end
+  def pop; end
+  def push(cmd); end
+  def restore; end
+  def save; end
+  def size; end
+  def size=(_arg0); end
+  def specific_max_size(number); end
+  def to_s(n_cmds); end
+end
+
+class Byebug::HistoryCommand < ::Byebug::Command
+  include ::Byebug::Helpers::ParseHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::HistsizeSetting < ::Byebug::Setting
+  def banner; end
+  def to_s; end
+end
+
+Byebug::HistsizeSetting::DEFAULT = T.let(T.unsafe(nil), Integer)
+
+class Byebug::InfoCommand < ::Byebug::Command
+  include ::Byebug::Subcommands
+  extend ::Byebug::Helpers::ReflectionHelper
+  extend ::Byebug::Subcommands::ClassMethods
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::InfoCommand::BreakpointsCommand < ::Byebug::Command
+  def execute; end
+
+  private
+
+  def info_breakpoint(brkpt); end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::InfoCommand::DisplayCommand < ::Byebug::Command
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::InfoCommand::FileCommand < ::Byebug::Command
+  include ::Byebug::Helpers::FileHelper
+  include ::Byebug::Helpers::StringHelper
+
+  def execute; end
+
+  private
+
+  def info_file_basic(file); end
+  def info_file_breakpoints(file); end
+  def info_file_mtime(file); end
+  def info_file_sha1(file); end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::InfoCommand::LineCommand < ::Byebug::Command
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::InfoCommand::ProgramCommand < ::Byebug::Command
+  def execute; end
+
+  private
+
+  def format_stop_reason(stop_reason); end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::Interface
+  include ::Byebug::Helpers::FileHelper
+
+  def initialize; end
+
+  def autorestore; end
+  def autosave; end
+  def close; end
+  def command_queue; end
+  def command_queue=(_arg0); end
+  def confirm(prompt); end
+  def errmsg(message); end
+  def error; end
+  def history; end
+  def history=(_arg0); end
+  def input; end
+  def last_if_empty(input); end
+  def output; end
+  def prepare_input(prompt); end
+  def print(message); end
+  def puts(message); end
+  def read_command(prompt); end
+  def read_file(filename); end
+  def read_input(prompt, save_hist = T.unsafe(nil)); end
+
+  private
+
+  def split_commands(cmd_line); end
+end
+
+class Byebug::InterruptCommand < ::Byebug::Command
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::IrbCommand < ::Byebug::Command
+  def execute; end
+
+  private
+
+  def with_clean_argv; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::KillCommand < ::Byebug::Command
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::LinetraceSetting < ::Byebug::Setting
+  def banner; end
+  def value; end
+  def value=(val); end
+end
+
+class Byebug::ListCommand < ::Byebug::Command
+  include ::Byebug::Helpers::FileHelper
+  include ::Byebug::Helpers::ParseHelper
+
+  def amend_final(*args, &block); end
+  def execute; end
+  def max_line(*args, &block); end
+  def size(*args, &block); end
+
+  private
+
+  def auto_range(direction); end
+  def display_lines(min, max); end
+  def lower_bound(range); end
+  def move(line, size, direction = T.unsafe(nil)); end
+  def parse_range(input); end
+  def range(input); end
+  def source_file_formatter; end
+  def split_range(str); end
+  def upper_bound(range); end
+  def valid_range?(first, last); end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::ListsizeSetting < ::Byebug::Setting
+  def banner; end
+  def to_s; end
+end
+
+Byebug::ListsizeSetting::DEFAULT = T.let(T.unsafe(nil), Integer)
+
+class Byebug::LocalInterface < ::Byebug::Interface
+  def initialize; end
+
+  def readline(prompt); end
+  def with_repl_like_sigint; end
+  def without_readline_completion; end
+end
+
+Byebug::LocalInterface::EOF_ALIAS = T.let(T.unsafe(nil), String)
+
+class Byebug::MethodCommand < ::Byebug::Command
+  include ::Byebug::Helpers::EvalHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::NextCommand < ::Byebug::Command
+  include ::Byebug::Helpers::ParseHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+Byebug::PORT = T.let(T.unsafe(nil), Integer)
+
+class Byebug::PostMortemProcessor < ::Byebug::CommandProcessor
+  def commands; end
+  def prompt; end
+end
+
+class Byebug::PostMortemSetting < ::Byebug::Setting
+  def initialize; end
+
+  def banner; end
+  def value; end
+  def value=(val); end
+end
+
+module Byebug::Printers; end
+
+class Byebug::Printers::Base
+  def type; end
+
+  private
+
+  def array_of_args(collection, &_block); end
+  def contents; end
+  def contents_files; end
+  def locate(path); end
+  def parts(path); end
+  def translate(string, args = T.unsafe(nil)); end
+end
+
+class Byebug::Printers::Base::MissedArgument < ::StandardError; end
+class Byebug::Printers::Base::MissedPath < ::StandardError; end
+Byebug::Printers::Base::SEPARATOR = T.let(T.unsafe(nil), String)
+
+class Byebug::Printers::Plain < ::Byebug::Printers::Base
+  def print(path, args = T.unsafe(nil)); end
+  def print_collection(path, collection, &block); end
+  def print_variables(variables, *_unused); end
+
+  private
+
+  def contents_files; end
+end
+
+class Byebug::PryCommand < ::Byebug::Command
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::QuitCommand < ::Byebug::Command
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+module Byebug::Remote; end
+
+class Byebug::Remote::Client
+  def initialize(interface); end
+
+  def interface; end
+  def socket; end
+  def start(host = T.unsafe(nil), port = T.unsafe(nil)); end
+  def started?; end
+
+  private
+
+  def connect_at(host, port); end
+end
+
+class Byebug::Remote::Server
+  def initialize(wait_connection:, &block); end
+
+  def actual_port; end
+  def start(host, port); end
+  def wait_connection; end
+end
+
+class Byebug::RemoteInterface < ::Byebug::Interface
+  def initialize(socket); end
+
+  def close; end
+  def confirm(prompt); end
+  def print(message); end
+  def puts(message); end
+  def read_command(prompt); end
+  def readline(prompt); end
+end
+
+class Byebug::RestartCommand < ::Byebug::Command
+  include ::Byebug::Helpers::BinHelper
+  include ::Byebug::Helpers::PathHelper
+
+  def execute; end
+
+  private
+
+  def prepend_byebug_bin(cmd); end
+  def prepend_ruby_bin(cmd); end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::SaveCommand < ::Byebug::Command
+  def execute; end
+
+  private
+
+  def save_breakpoints(file); end
+  def save_catchpoints(file); end
+  def save_displays(file); end
+  def save_settings(file); end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::SavefileSetting < ::Byebug::Setting
+  def banner; end
+  def to_s; end
+end
+
+Byebug::SavefileSetting::DEFAULT = T.let(T.unsafe(nil), String)
+
+class Byebug::ScriptInterface < ::Byebug::Interface
+  def initialize(file, verbose = T.unsafe(nil)); end
+
+  def close; end
+  def read_command(prompt); end
+  def readline(*_arg0); end
+end
+
+class Byebug::ScriptProcessor < ::Byebug::CommandProcessor
+  def after_repl; end
+  def commands; end
+  def prompt; end
+  def repl; end
+
+  private
+
+  def without_exceptions; end
+end
+
+class Byebug::SetCommand < ::Byebug::Command
+  include ::Byebug::Helpers::ParseHelper
+
+  def execute; end
+
+  private
+
+  def get_onoff(arg, default); end
+
+  class << self
+    def description; end
+    def help; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::Setting
+  def initialize; end
+
+  def boolean?; end
+  def help; end
+  def integer?; end
+  def to_s; end
+  def to_sym; end
+  def value; end
+  def value=(_arg0); end
+
+  class << self
+    def [](name); end
+    def []=(name, value); end
+    def find(shortcut); end
+    def help_all; end
+    def settings; end
+  end
+end
+
+class Byebug::ShowCommand < ::Byebug::Command
+  def execute; end
+
+  class << self
+    def description; end
+    def help; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::SkipCommand < ::Byebug::Command
+  include ::Byebug::Helpers::ParseHelper
+
+  def auto_run; end
+  def execute; end
+  def initialize_attributes; end
+  def keep_execution; end
+  def reset_attributes; end
+
+  class << self
+    def description; end
+    def file_line; end
+    def file_line=(_arg0); end
+    def file_path; end
+    def file_path=(_arg0); end
+    def previous_autolist; end
+    def regexp; end
+    def restore_autolist; end
+    def setup_autolist(value); end
+    def short_description; end
+  end
+end
+
+class Byebug::SourceCommand < ::Byebug::Command
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::SourceFileFormatter
+  include ::Byebug::Helpers::FileHelper
+
+  def initialize(file, annotator); end
+
+  def amend(line, ceiling); end
+  def amend_final(line); end
+  def amend_initial(line); end
+  def annotator; end
+  def file; end
+  def lines(min, max); end
+  def lines_around(center); end
+  def max_initial_line; end
+  def max_line; end
+  def range_around(center); end
+  def range_from(min); end
+  def size; end
+end
+
+class Byebug::StackOnErrorSetting < ::Byebug::Setting
+  def banner; end
+end
+
+class Byebug::StepCommand < ::Byebug::Command
+  include ::Byebug::Helpers::ParseHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+module Byebug::Subcommands
+  extend ::Forwardable
+
+  mixes_in_class_methods ::Byebug::Helpers::ReflectionHelper
+  mixes_in_class_methods ::Byebug::Subcommands::ClassMethods
+
+  def execute; end
+  def subcommand_list(*args, &block); end
+
+  class << self
+    def included(command); end
+  end
+end
+
+module Byebug::Subcommands::ClassMethods
+  include ::Byebug::Helpers::ReflectionHelper
+
+  def help; end
+  def subcommand_list; end
+end
+
+class Byebug::ThreadCommand < ::Byebug::Command
+  include ::Byebug::Subcommands
+  extend ::Byebug::Helpers::ReflectionHelper
+  extend ::Byebug::Subcommands::ClassMethods
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::ThreadCommand::CurrentCommand < ::Byebug::Command
+  include ::Byebug::Helpers::ThreadHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::ThreadCommand::ListCommand < ::Byebug::Command
+  include ::Byebug::Helpers::ThreadHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::ThreadCommand::ResumeCommand < ::Byebug::Command
+  include ::Byebug::Helpers::ThreadHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::ThreadCommand::StopCommand < ::Byebug::Command
+  include ::Byebug::Helpers::ThreadHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::ThreadCommand::SwitchCommand < ::Byebug::Command
+  include ::Byebug::Helpers::ThreadHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::ThreadsTable; end
+
+class Byebug::TracevarCommand < ::Byebug::Command
+  def execute; end
+
+  private
+
+  def on_change(name, value, stop); end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::UndisplayCommand < ::Byebug::Command
+  include ::Byebug::Helpers::ParseHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::UntracevarCommand < ::Byebug::Command
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::UpCommand < ::Byebug::Command
+  include ::Byebug::Helpers::FrameHelper
+  include ::Byebug::Helpers::ParseHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::VarCommand < ::Byebug::Command
+  include ::Byebug::Subcommands
+  extend ::Byebug::Helpers::ReflectionHelper
+  extend ::Byebug::Subcommands::ClassMethods
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::VarCommand::AllCommand < ::Byebug::Command
+  include ::Byebug::Helpers::EvalHelper
+  include ::Byebug::Helpers::VarHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::VarCommand::ArgsCommand < ::Byebug::Command
+  include ::Byebug::Helpers::EvalHelper
+  include ::Byebug::Helpers::VarHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::VarCommand::ConstCommand < ::Byebug::Command
+  include ::Byebug::Helpers::EvalHelper
+
+  def execute; end
+
+  private
+
+  def str_obj; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::VarCommand::GlobalCommand < ::Byebug::Command
+  include ::Byebug::Helpers::EvalHelper
+  include ::Byebug::Helpers::VarHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::VarCommand::InstanceCommand < ::Byebug::Command
+  include ::Byebug::Helpers::EvalHelper
+  include ::Byebug::Helpers::VarHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::VarCommand::LocalCommand < ::Byebug::Command
+  include ::Byebug::Helpers::EvalHelper
+  include ::Byebug::Helpers::VarHelper
+
+  def execute; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::WhereCommand < ::Byebug::Command
+  include ::Byebug::Helpers::FrameHelper
+
+  def execute; end
+
+  private
+
+  def print_backtrace; end
+
+  class << self
+    def description; end
+    def regexp; end
+    def short_description; end
+  end
+end
+
+class Byebug::WidthSetting < ::Byebug::Setting
+  def banner; end
+  def to_s; end
+end
+
+Byebug::WidthSetting::DEFAULT = T.let(T.unsafe(nil), Integer)
+
+class Exception
+  def __bb_context; end
+end
+
+module Kernel
+  def byebug; end
+  def debugger; end
+  def remote_byebug(host = T.unsafe(nil), port = T.unsafe(nil)); end
+end
diff --git a/sorbet/rbi/gems/concord@0.1.6.rbi b/sorbet/rbi/gems/concord@0.1.6.rbi
new file mode 100644
index 00000000..109c9142
--- /dev/null
+++ b/sorbet/rbi/gems/concord@0.1.6.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `concord` gem.
+# Please instead update this file by running `bin/tapioca gem concord`.
+
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires
diff --git a/sorbet/rbi/gems/diff-lcs@1.4.4.rbi b/sorbet/rbi/gems/diff-lcs@1.4.4.rbi
new file mode 100644
index 00000000..209c02ea
--- /dev/null
+++ b/sorbet/rbi/gems/diff-lcs@1.4.4.rbi
@@ -0,0 +1,9 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `diff-lcs` gem.
+# Please instead update this file by running `bin/tapioca gem diff-lcs`.
+
+class Integer < ::Numeric
+  include ::JSON::Ext::Generator::GeneratorMethods::Integer
+end
diff --git a/sorbet/rbi/gems/equalizer@0.0.11.rbi b/sorbet/rbi/gems/equalizer@0.0.11.rbi
new file mode 100644
index 00000000..e649360d
--- /dev/null
+++ b/sorbet/rbi/gems/equalizer@0.0.11.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `equalizer` gem.
+# Please instead update this file by running `bin/tapioca gem equalizer`.
+
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires
diff --git a/sorbet/rbi/gems/ice_nine@0.11.2.rbi b/sorbet/rbi/gems/ice_nine@0.11.2.rbi
new file mode 100644
index 00000000..b6bc03e6
--- /dev/null
+++ b/sorbet/rbi/gems/ice_nine@0.11.2.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `ice_nine` gem.
+# Please instead update this file by running `bin/tapioca gem ice_nine`.
+
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires
diff --git a/sorbet/rbi/gems/memoizable@0.4.2.rbi b/sorbet/rbi/gems/memoizable@0.4.2.rbi
new file mode 100644
index 00000000..006b817b
--- /dev/null
+++ b/sorbet/rbi/gems/memoizable@0.4.2.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `memoizable` gem.
+# Please instead update this file by running `bin/tapioca gem memoizable`.
+
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires
diff --git a/sorbet/rbi/gems/method_source@1.0.0.rbi b/sorbet/rbi/gems/method_source@1.0.0.rbi
index 5534cd94..b7ecbb69 100644
--- a/sorbet/rbi/gems/method_source@1.0.0.rbi
+++ b/sorbet/rbi/gems/method_source@1.0.0.rbi
@@ -1,6 +1,72 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca generate
-
 # typed: true
 
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `method_source` gem.
+# Please instead update this file by running `bin/tapioca gem method_source`.
+
+module MethodSource
+  extend ::MethodSource::CodeHelpers
+
+  class << self
+    def comment_helper(source_location, name = T.unsafe(nil)); end
+    def extract_code(source_location); end
+    def lines_for(file_name, name = T.unsafe(nil)); end
+    def source_helper(source_location, name = T.unsafe(nil)); end
+    def valid_expression?(str); end
+  end
+end
+
+module MethodSource::CodeHelpers
+  def comment_describing(file, line_number); end
+  def complete_expression?(str); end
+  def expression_at(file, line_number, options = T.unsafe(nil)); end
+
+  private
+
+  def extract_first_expression(lines, consume = T.unsafe(nil), &block); end
+  def extract_last_comment(lines); end
+end
+
+module MethodSource::CodeHelpers::IncompleteExpression
+  class << self
+    def ===(ex); end
+    def rbx?; end
+  end
+end
+
+MethodSource::CodeHelpers::IncompleteExpression::GENERIC_REGEXPS = T.let(T.unsafe(nil), Array)
+MethodSource::CodeHelpers::IncompleteExpression::RBX_ONLY_REGEXPS = T.let(T.unsafe(nil), Array)
+
+module MethodSource::MethodExtensions
+  def comment; end
+  def source; end
+
+  class << self
+    def included(klass); end
+  end
+end
+
+module MethodSource::ReeSourceLocation
+  def source_location; end
+end
+
+module MethodSource::SourceLocation; end
+
+module MethodSource::SourceLocation::MethodExtensions
+  def source_location; end
+
+  private
+
+  def trace_func(event, file, line, id, binding, classname); end
+end
+
+module MethodSource::SourceLocation::ProcExtensions
+  def source_location; end
+end
+
+module MethodSource::SourceLocation::UnboundMethodExtensions
+  def source_location; end
+end
 
+class MethodSource::SourceNotFoundError < ::StandardError; end
+MethodSource::VERSION = T.let(T.unsafe(nil), String)
diff --git a/sorbet/rbi/gems/minitest@5.14.1.rbi b/sorbet/rbi/gems/minitest@5.14.1.rbi
deleted file mode 100644
index 1bfbab37..00000000
--- a/sorbet/rbi/gems/minitest@5.14.1.rbi
+++ /dev/null
@@ -1,333 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca generate
-
-# typed: true
-
-module Minitest
-  def self.__run(reporter, options); end
-  def self.after_run(&block); end
-  def self.autorun; end
-  def self.backtrace_filter; end
-  def self.backtrace_filter=(_); end
-  def self.clock_time; end
-  def self.extensions; end
-  def self.extensions=(_); end
-  def self.filter_backtrace(bt); end
-  def self.info_signal; end
-  def self.info_signal=(_); end
-  def self.init_plugins(options); end
-  def self.load_plugins; end
-  def self.parallel_executor; end
-  def self.parallel_executor=(_); end
-  def self.process_args(args = _); end
-  def self.reporter; end
-  def self.reporter=(_); end
-  def self.run(args = _); end
-  def self.run_one_method(klass, method_name); end
-end
-
-class Minitest::AbstractReporter
-  include(::Mutex_m)
-
-  def lock; end
-  def locked?; end
-  def passed?; end
-  def prerecord(klass, name); end
-  def record(result); end
-  def report; end
-  def start; end
-  def synchronize(&block); end
-  def try_lock; end
-  def unlock; end
-end
-
-class Minitest::Assertion < ::Exception
-  def error; end
-  def location; end
-  def result_code; end
-  def result_label; end
-end
-
-module Minitest::Assertions
-  def _synchronize; end
-  def assert(test, msg = _); end
-  def assert_empty(obj, msg = _); end
-  def assert_equal(exp, act, msg = _); end
-  def assert_in_delta(exp, act, delta = _, msg = _); end
-  def assert_in_epsilon(exp, act, epsilon = _, msg = _); end
-  def assert_includes(collection, obj, msg = _); end
-  def assert_instance_of(cls, obj, msg = _); end
-  def assert_kind_of(cls, obj, msg = _); end
-  def assert_match(matcher, obj, msg = _); end
-  def assert_nil(obj, msg = _); end
-  def assert_operator(o1, op, o2 = _, msg = _); end
-  def assert_output(stdout = _, stderr = _); end
-  def assert_path_exists(path, msg = _); end
-  def assert_predicate(o1, op, msg = _); end
-  def assert_raises(*exp); end
-  def assert_respond_to(obj, meth, msg = _); end
-  def assert_same(exp, act, msg = _); end
-  def assert_send(send_ary, m = _); end
-  def assert_silent; end
-  def assert_throws(sym, msg = _); end
-  def capture_io; end
-  def capture_subprocess_io; end
-  def diff(exp, act); end
-  def exception_details(e, msg); end
-  def fail_after(y, m, d, msg); end
-  def flunk(msg = _); end
-  def message(msg = _, ending = _, &default); end
-  def mu_pp(obj); end
-  def mu_pp_for_diff(obj); end
-  def pass(_msg = _); end
-  def refute(test, msg = _); end
-  def refute_empty(obj, msg = _); end
-  def refute_equal(exp, act, msg = _); end
-  def refute_in_delta(exp, act, delta = _, msg = _); end
-  def refute_in_epsilon(a, b, epsilon = _, msg = _); end
-  def refute_includes(collection, obj, msg = _); end
-  def refute_instance_of(cls, obj, msg = _); end
-  def refute_kind_of(cls, obj, msg = _); end
-  def refute_match(matcher, obj, msg = _); end
-  def refute_nil(obj, msg = _); end
-  def refute_operator(o1, op, o2 = _, msg = _); end
-  def refute_path_exists(path, msg = _); end
-  def refute_predicate(o1, op, msg = _); end
-  def refute_respond_to(obj, meth, msg = _); end
-  def refute_same(exp, act, msg = _); end
-  def skip(msg = _, bt = _); end
-  def skip_until(y, m, d, msg); end
-  def skipped?; end
-  def things_to_diff(exp, act); end
-
-  def self.diff; end
-  def self.diff=(o); end
-end
-
-Minitest::Assertions::E = T.let(T.unsafe(nil), String)
-
-Minitest::Assertions::UNDEFINED = T.let(T.unsafe(nil), Object)
-
-class Minitest::BacktraceFilter
-  def filter(bt); end
-end
-
-Minitest::BacktraceFilter::MT_RE = T.let(T.unsafe(nil), Regexp)
-
-class Minitest::CompositeReporter < ::Minitest::AbstractReporter
-  def initialize(*reporters); end
-
-  def <<(reporter); end
-  def io; end
-  def passed?; end
-  def prerecord(klass, name); end
-  def record(result); end
-  def report; end
-  def reporters; end
-  def reporters=(_); end
-  def start; end
-end
-
-Minitest::ENCS = T.let(T.unsafe(nil), TrueClass)
-
-module Minitest::Guard
-  def jruby?(platform = _); end
-  def maglev?(platform = _); end
-  def mri?(platform = _); end
-  def osx?(platform = _); end
-  def rubinius?(platform = _); end
-  def windows?(platform = _); end
-end
-
-module Minitest::Parallel
-end
-
-class Minitest::Parallel::Executor
-  def initialize(size); end
-
-  def <<(work); end
-  def shutdown; end
-  def size; end
-  def start; end
-end
-
-module Minitest::Parallel::Test
-  def _synchronize; end
-end
-
-module Minitest::Parallel::Test::ClassMethods
-  def run_one_method(klass, method_name, reporter); end
-  def test_order; end
-end
-
-class Minitest::ProgressReporter < ::Minitest::Reporter
-  def prerecord(klass, name); end
-  def record(result); end
-end
-
-module Minitest::Reportable
-  def class_name; end
-  def error?; end
-  def location; end
-  def passed?; end
-  def result_code; end
-  def skipped?; end
-end
-
-class Minitest::Reporter < ::Minitest::AbstractReporter
-  def initialize(io = _, options = _); end
-
-  def io; end
-  def io=(_); end
-  def options; end
-  def options=(_); end
-end
-
-class Minitest::Result < ::Minitest::Runnable
-  include(::Minitest::Reportable)
-
-  def class_name; end
-  def klass; end
-  def klass=(_); end
-  def source_location; end
-  def source_location=(_); end
-  def to_s; end
-
-  def self.from(runnable); end
-end
-
-class Minitest::Runnable
-  def initialize(name); end
-
-  def assertions; end
-  def assertions=(_); end
-  def failure; end
-  def failures; end
-  def failures=(_); end
-  def marshal_dump; end
-  def marshal_load(ary); end
-  def name; end
-  def name=(o); end
-  def passed?; end
-  def result_code; end
-  def run; end
-  def skipped?; end
-  def time; end
-  def time=(_); end
-  def time_it; end
-
-  def self.inherited(klass); end
-  def self.methods_matching(re); end
-  def self.on_signal(name, action); end
-  def self.reset; end
-  def self.run(reporter, options = _); end
-  def self.run_one_method(klass, method_name, reporter); end
-  def self.runnable_methods; end
-  def self.runnables; end
-  def self.with_info_handler(reporter, &block); end
-end
-
-Minitest::Runnable::SIGNALS = T.let(T.unsafe(nil), Hash)
-
-class Minitest::Skip < ::Minitest::Assertion
-  def result_label; end
-end
-
-class Minitest::StatisticsReporter < ::Minitest::Reporter
-  def initialize(io = _, options = _); end
-
-  def assertions; end
-  def assertions=(_); end
-  def count; end
-  def count=(_); end
-  def errors; end
-  def errors=(_); end
-  def failures; end
-  def failures=(_); end
-  def passed?; end
-  def record(result); end
-  def report; end
-  def results; end
-  def results=(_); end
-  def skips; end
-  def skips=(_); end
-  def start; end
-  def start_time; end
-  def start_time=(_); end
-  def total_time; end
-  def total_time=(_); end
-end
-
-class Minitest::SummaryReporter < ::Minitest::StatisticsReporter
-  def aggregated_results(io); end
-  def old_sync; end
-  def old_sync=(_); end
-  def report; end
-  def start; end
-  def statistics; end
-  def summary; end
-  def sync; end
-  def sync=(_); end
-  def to_s; end
-
-  private
-
-  def binary_string; end
-end
-
-class Minitest::Test < ::Minitest::Runnable
-  include(::Minitest::Assertions)
-  include(::Minitest::Reportable)
-  include(::Minitest::Test::LifecycleHooks)
-  include(::Minitest::Guard)
-  extend(::Minitest::Guard)
-
-  def capture_exceptions; end
-  def class_name; end
-  def run; end
-  def with_info_handler(&block); end
-
-  def self.i_suck_and_my_tests_are_order_dependent!; end
-  def self.io_lock; end
-  def self.io_lock=(_); end
-  def self.make_my_diffs_pretty!; end
-  def self.parallelize_me!; end
-  def self.runnable_methods; end
-  def self.test_order; end
-end
-
-module Minitest::Test::LifecycleHooks
-  def after_setup; end
-  def after_teardown; end
-  def before_setup; end
-  def before_teardown; end
-  def setup; end
-  def teardown; end
-end
-
-Minitest::Test::PASSTHROUGH_EXCEPTIONS = T.let(T.unsafe(nil), Array)
-
-Minitest::Test::TEARDOWN_METHODS = T.let(T.unsafe(nil), Array)
-
-class Minitest::UnexpectedError < ::Minitest::Assertion
-  def initialize(error); end
-
-  def backtrace; end
-  def error; end
-  def error=(_); end
-  def message; end
-  def result_label; end
-end
-
-class Minitest::Unit
-  def self.after_tests(&b); end
-  def self.autorun; end
-end
-
-class Minitest::Unit::TestCase < ::Minitest::Test
-  def self.inherited(klass); end
-end
-
-Minitest::Unit::VERSION = T.let(T.unsafe(nil), String)
-
-Minitest::VERSION = T.let(T.unsafe(nil), String)
diff --git a/sorbet/rbi/gems/minitest@5.14.3.rbi b/sorbet/rbi/gems/minitest@5.14.3.rbi
new file mode 100644
index 00000000..e6d3d3b2
--- /dev/null
+++ b/sorbet/rbi/gems/minitest@5.14.3.rbi
@@ -0,0 +1,344 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `minitest` gem.
+# Please instead update this file by running `bin/tapioca gem minitest`.
+
+module Minitest
+  class << self
+    def __run(reporter, options); end
+    def after_run(&block); end
+    def autorun; end
+    def backtrace_filter; end
+    def backtrace_filter=(_arg0); end
+    def clock_time; end
+    def extensions; end
+    def extensions=(_arg0); end
+    def filter_backtrace(bt); end
+    def info_signal; end
+    def info_signal=(_arg0); end
+    def init_plugins(options); end
+    def load_plugins; end
+    def parallel_executor; end
+    def parallel_executor=(_arg0); end
+    def process_args(args = T.unsafe(nil)); end
+    def reporter; end
+    def reporter=(_arg0); end
+    def run(args = T.unsafe(nil)); end
+    def run_one_method(klass, method_name); end
+  end
+end
+
+class Minitest::AbstractReporter
+  include ::Mutex_m
+
+  def lock; end
+  def locked?; end
+  def passed?; end
+  def prerecord(klass, name); end
+  def record(result); end
+  def report; end
+  def start; end
+  def synchronize(&block); end
+  def try_lock; end
+  def unlock; end
+end
+
+class Minitest::Assertion < ::Exception
+  def error; end
+  def location; end
+  def result_code; end
+  def result_label; end
+end
+
+module Minitest::Assertions
+  def _synchronize; end
+  def assert(test, msg = T.unsafe(nil)); end
+  def assert_empty(obj, msg = T.unsafe(nil)); end
+  def assert_equal(exp, act, msg = T.unsafe(nil)); end
+  def assert_in_delta(exp, act, delta = T.unsafe(nil), msg = T.unsafe(nil)); end
+  def assert_in_epsilon(exp, act, epsilon = T.unsafe(nil), msg = T.unsafe(nil)); end
+  def assert_includes(collection, obj, msg = T.unsafe(nil)); end
+  def assert_instance_of(cls, obj, msg = T.unsafe(nil)); end
+  def assert_kind_of(cls, obj, msg = T.unsafe(nil)); end
+  def assert_match(matcher, obj, msg = T.unsafe(nil)); end
+  def assert_nil(obj, msg = T.unsafe(nil)); end
+  def assert_operator(o1, op, o2 = T.unsafe(nil), msg = T.unsafe(nil)); end
+  def assert_output(stdout = T.unsafe(nil), stderr = T.unsafe(nil)); end
+  def assert_path_exists(path, msg = T.unsafe(nil)); end
+  def assert_predicate(o1, op, msg = T.unsafe(nil)); end
+  def assert_raises(*exp); end
+  def assert_respond_to(obj, meth, msg = T.unsafe(nil)); end
+  def assert_same(exp, act, msg = T.unsafe(nil)); end
+  def assert_send(send_ary, m = T.unsafe(nil)); end
+  def assert_silent; end
+  def assert_throws(sym, msg = T.unsafe(nil)); end
+  def capture_io; end
+  def capture_subprocess_io; end
+  def diff(exp, act); end
+  def exception_details(e, msg); end
+  def fail_after(y, m, d, msg); end
+  def flunk(msg = T.unsafe(nil)); end
+  def message(msg = T.unsafe(nil), ending = T.unsafe(nil), &default); end
+  def mu_pp(obj); end
+  def mu_pp_for_diff(obj); end
+  def pass(_msg = T.unsafe(nil)); end
+  def refute(test, msg = T.unsafe(nil)); end
+  def refute_empty(obj, msg = T.unsafe(nil)); end
+  def refute_equal(exp, act, msg = T.unsafe(nil)); end
+  def refute_in_delta(exp, act, delta = T.unsafe(nil), msg = T.unsafe(nil)); end
+  def refute_in_epsilon(a, b, epsilon = T.unsafe(nil), msg = T.unsafe(nil)); end
+  def refute_includes(collection, obj, msg = T.unsafe(nil)); end
+  def refute_instance_of(cls, obj, msg = T.unsafe(nil)); end
+  def refute_kind_of(cls, obj, msg = T.unsafe(nil)); end
+  def refute_match(matcher, obj, msg = T.unsafe(nil)); end
+  def refute_nil(obj, msg = T.unsafe(nil)); end
+  def refute_operator(o1, op, o2 = T.unsafe(nil), msg = T.unsafe(nil)); end
+  def refute_path_exists(path, msg = T.unsafe(nil)); end
+  def refute_predicate(o1, op, msg = T.unsafe(nil)); end
+  def refute_respond_to(obj, meth, msg = T.unsafe(nil)); end
+  def refute_same(exp, act, msg = T.unsafe(nil)); end
+  def skip(msg = T.unsafe(nil), bt = T.unsafe(nil)); end
+  def skip_until(y, m, d, msg); end
+  def skipped?; end
+  def things_to_diff(exp, act); end
+
+  class << self
+    def diff; end
+    def diff=(o); end
+  end
+end
+
+Minitest::Assertions::E = T.let(T.unsafe(nil), String)
+Minitest::Assertions::UNDEFINED = T.let(T.unsafe(nil), Object)
+
+class Minitest::BacktraceFilter
+  def filter(bt); end
+end
+
+Minitest::BacktraceFilter::MT_RE = T.let(T.unsafe(nil), Regexp)
+
+class Minitest::CompositeReporter < ::Minitest::AbstractReporter
+  def initialize(*reporters); end
+
+  def <<(reporter); end
+  def io; end
+  def passed?; end
+  def prerecord(klass, name); end
+  def record(result); end
+  def report; end
+  def reporters; end
+  def reporters=(_arg0); end
+  def start; end
+end
+
+Minitest::ENCS = T.let(T.unsafe(nil), TrueClass)
+
+module Minitest::Guard
+  def jruby?(platform = T.unsafe(nil)); end
+  def maglev?(platform = T.unsafe(nil)); end
+  def mri?(platform = T.unsafe(nil)); end
+  def osx?(platform = T.unsafe(nil)); end
+  def rubinius?(platform = T.unsafe(nil)); end
+  def windows?(platform = T.unsafe(nil)); end
+end
+
+module Minitest::Parallel; end
+
+class Minitest::Parallel::Executor
+  def initialize(size); end
+
+  def <<(work); end
+  def shutdown; end
+  def size; end
+  def start; end
+end
+
+module Minitest::Parallel::Test
+  def _synchronize; end
+end
+
+module Minitest::Parallel::Test::ClassMethods
+  def run_one_method(klass, method_name, reporter); end
+  def test_order; end
+end
+
+class Minitest::ProgressReporter < ::Minitest::Reporter
+  def prerecord(klass, name); end
+  def record(result); end
+end
+
+module Minitest::Reportable
+  def class_name; end
+  def error?; end
+  def location; end
+  def passed?; end
+  def result_code; end
+  def skipped?; end
+end
+
+class Minitest::Reporter < ::Minitest::AbstractReporter
+  def initialize(io = T.unsafe(nil), options = T.unsafe(nil)); end
+
+  def io; end
+  def io=(_arg0); end
+  def options; end
+  def options=(_arg0); end
+end
+
+class Minitest::Result < ::Minitest::Runnable
+  include ::Minitest::Reportable
+
+  def class_name; end
+  def klass; end
+  def klass=(_arg0); end
+  def source_location; end
+  def source_location=(_arg0); end
+  def to_s; end
+
+  class << self
+    def from(runnable); end
+  end
+end
+
+class Minitest::Runnable
+  def initialize(name); end
+
+  def assertions; end
+  def assertions=(_arg0); end
+  def failure; end
+  def failures; end
+  def failures=(_arg0); end
+  def marshal_dump; end
+  def marshal_load(ary); end
+  def name; end
+  def name=(o); end
+  def passed?; end
+  def result_code; end
+  def run; end
+  def skipped?; end
+  def time; end
+  def time=(_arg0); end
+  def time_it; end
+
+  class << self
+    def inherited(klass); end
+    def methods_matching(re); end
+    def on_signal(name, action); end
+    def reset; end
+    def run(reporter, options = T.unsafe(nil)); end
+    def run_one_method(klass, method_name, reporter); end
+    def runnable_methods; end
+    def runnables; end
+    def with_info_handler(reporter, &block); end
+  end
+end
+
+Minitest::Runnable::SIGNALS = T.let(T.unsafe(nil), Hash)
+
+class Minitest::Skip < ::Minitest::Assertion
+  def result_label; end
+end
+
+class Minitest::StatisticsReporter < ::Minitest::Reporter
+  def initialize(io = T.unsafe(nil), options = T.unsafe(nil)); end
+
+  def assertions; end
+  def assertions=(_arg0); end
+  def count; end
+  def count=(_arg0); end
+  def errors; end
+  def errors=(_arg0); end
+  def failures; end
+  def failures=(_arg0); end
+  def passed?; end
+  def record(result); end
+  def report; end
+  def results; end
+  def results=(_arg0); end
+  def skips; end
+  def skips=(_arg0); end
+  def start; end
+  def start_time; end
+  def start_time=(_arg0); end
+  def total_time; end
+  def total_time=(_arg0); end
+end
+
+class Minitest::SummaryReporter < ::Minitest::StatisticsReporter
+  def aggregated_results(io); end
+  def old_sync; end
+  def old_sync=(_arg0); end
+  def report; end
+  def start; end
+  def statistics; end
+  def summary; end
+  def sync; end
+  def sync=(_arg0); end
+  def to_s; end
+
+  private
+
+  def binary_string; end
+end
+
+class Minitest::Test < ::Minitest::Runnable
+  include ::Minitest::Assertions
+  include ::Minitest::Reportable
+  include ::Minitest::Test::LifecycleHooks
+  include ::Minitest::Guard
+  extend ::Minitest::Guard
+
+  def capture_exceptions; end
+  def class_name; end
+  def run; end
+  def with_info_handler(&block); end
+
+  class << self
+    def i_suck_and_my_tests_are_order_dependent!; end
+    def io_lock; end
+    def io_lock=(_arg0); end
+    def make_my_diffs_pretty!; end
+    def parallelize_me!; end
+    def runnable_methods; end
+    def test_order; end
+  end
+end
+
+module Minitest::Test::LifecycleHooks
+  def after_setup; end
+  def after_teardown; end
+  def before_setup; end
+  def before_teardown; end
+  def setup; end
+  def teardown; end
+end
+
+Minitest::Test::PASSTHROUGH_EXCEPTIONS = T.let(T.unsafe(nil), Array)
+Minitest::Test::TEARDOWN_METHODS = T.let(T.unsafe(nil), Array)
+
+class Minitest::UnexpectedError < ::Minitest::Assertion
+  def initialize(error); end
+
+  def backtrace; end
+  def error; end
+  def error=(_arg0); end
+  def message; end
+  def result_label; end
+end
+
+class Minitest::Unit
+  class << self
+    def after_tests(&b); end
+    def autorun; end
+  end
+end
+
+class Minitest::Unit::TestCase < ::Minitest::Test
+  class << self
+    def inherited(klass); end
+  end
+end
+
+Minitest::Unit::VERSION = T.let(T.unsafe(nil), String)
+Minitest::VERSION = T.let(T.unsafe(nil), String)
diff --git a/sorbet/rbi/gems/mprelude@0.1.0.rbi b/sorbet/rbi/gems/mprelude@0.1.0.rbi
new file mode 100644
index 00000000..3a026ea1
--- /dev/null
+++ b/sorbet/rbi/gems/mprelude@0.1.0.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `mprelude` gem.
+# Please instead update this file by running `bin/tapioca gem mprelude`.
+
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires
diff --git a/sorbet/rbi/gems/parser@2.7.1.4.rbi b/sorbet/rbi/gems/parser@2.7.1.4.rbi
index 5534cd94..c51c504a 100644
--- a/sorbet/rbi/gems/parser@2.7.1.4.rbi
+++ b/sorbet/rbi/gems/parser@2.7.1.4.rbi
@@ -1,6 +1,1696 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca generate
-
 # typed: true
 
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `parser` gem.
+# Please instead update this file by running `bin/tapioca gem parser`.
+
+module Parser
+  class << self
+    private
+
+    def warn_syntax_deviation(feature, version); end
+  end
+end
+
+module Parser::AST; end
+
+class Parser::AST::Node < ::AST::Node
+  def assign_properties(properties); end
+  def loc; end
+  def location; end
+end
+
+class Parser::AST::Processor < ::AST::Processor
+  def on_alias(node); end
+  def on_and(node); end
+  def on_and_asgn(node); end
+  def on_arg(node); end
+  def on_arg_expr(node); end
+  def on_args(node); end
+  def on_argument(node); end
+  def on_array(node); end
+  def on_array_pattern(node); end
+  def on_array_pattern_with_tail(node); end
+  def on_back_ref(node); end
+  def on_begin(node); end
+  def on_block(node); end
+  def on_block_pass(node); end
+  def on_blockarg(node); end
+  def on_blockarg_expr(node); end
+  def on_break(node); end
+  def on_case(node); end
+  def on_case_match(node); end
+  def on_casgn(node); end
+  def on_class(node); end
+  def on_const(node); end
+  def on_const_pattern(node); end
+  def on_csend(node); end
+  def on_cvar(node); end
+  def on_cvasgn(node); end
+  def on_def(node); end
+  def on_def_e(node); end
+  def on_defined?(node); end
+  def on_defs(node); end
+  def on_defs_e(node); end
+  def on_dstr(node); end
+  def on_dsym(node); end
+  def on_eflipflop(node); end
+  def on_empty_else(node); end
+  def on_ensure(node); end
+  def on_erange(node); end
+  def on_find_pattern(node); end
+  def on_for(node); end
+  def on_forward_arg(node); end
+  def on_gvar(node); end
+  def on_gvasgn(node); end
+  def on_hash(node); end
+  def on_hash_pattern(node); end
+  def on_if(node); end
+  def on_if_guard(node); end
+  def on_iflipflop(node); end
+  def on_in_match(node); end
+  def on_in_pattern(node); end
+  def on_index(node); end
+  def on_indexasgn(node); end
+  def on_irange(node); end
+  def on_ivar(node); end
+  def on_ivasgn(node); end
+  def on_kwarg(node); end
+  def on_kwbegin(node); end
+  def on_kwoptarg(node); end
+  def on_kwrestarg(node); end
+  def on_kwsplat(node); end
+  def on_lambda(node); end
+  def on_lvar(node); end
+  def on_lvasgn(node); end
+  def on_masgn(node); end
+  def on_match_alt(node); end
+  def on_match_as(node); end
+  def on_match_current_line(node); end
+  def on_match_rest(node); end
+  def on_match_var(node); end
+  def on_match_with_lvasgn(node); end
+  def on_mlhs(node); end
+  def on_module(node); end
+  def on_mrasgn(node); end
+  def on_next(node); end
+  def on_not(node); end
+  def on_nth_ref(node); end
+  def on_numblock(node); end
+  def on_op_asgn(node); end
+  def on_optarg(node); end
+  def on_or(node); end
+  def on_or_asgn(node); end
+  def on_pair(node); end
+  def on_pin(node); end
+  def on_postexe(node); end
+  def on_preexe(node); end
+  def on_procarg0(node); end
+  def on_rasgn(node); end
+  def on_redo(node); end
+  def on_regexp(node); end
+  def on_resbody(node); end
+  def on_rescue(node); end
+  def on_restarg(node); end
+  def on_restarg_expr(node); end
+  def on_retry(node); end
+  def on_return(node); end
+  def on_sclass(node); end
+  def on_send(node); end
+  def on_shadowarg(node); end
+  def on_splat(node); end
+  def on_super(node); end
+  def on_undef(node); end
+  def on_unless_guard(node); end
+  def on_until(node); end
+  def on_until_post(node); end
+  def on_var(node); end
+  def on_vasgn(node); end
+  def on_when(node); end
+  def on_while(node); end
+  def on_while_post(node); end
+  def on_xstr(node); end
+  def on_yield(node); end
+  def process_argument_node(node); end
+  def process_regular_node(node); end
+  def process_var_asgn_node(node); end
+  def process_variable_node(node); end
+end
+
+class Parser::Base < ::Racc::Parser
+  def initialize(builder = T.unsafe(nil)); end
+
+  def builder; end
+  def context; end
+  def current_arg_stack; end
+  def diagnostics; end
+  def max_numparam_stack; end
+  def parse(source_buffer); end
+  def parse_with_comments(source_buffer); end
+  def pattern_hash_keys; end
+  def pattern_variables; end
+  def reset; end
+  def source_buffer; end
+  def static_env; end
+  def tokenize(source_buffer, recover = T.unsafe(nil)); end
+
+  private
+
+  def check_kwarg_name(name_t); end
+  def diagnostic(level, reason, arguments, location_t, highlights_ts = T.unsafe(nil)); end
+  def next_token; end
+  def on_error(error_token_id, error_value, value_stack); end
+
+  class << self
+    def default_parser; end
+    def parse(string, file = T.unsafe(nil), line = T.unsafe(nil)); end
+    def parse_file(filename); end
+    def parse_file_with_comments(filename); end
+    def parse_with_comments(string, file = T.unsafe(nil), line = T.unsafe(nil)); end
+
+    private
+
+    def setup_source_buffer(file, line, string, encoding); end
+  end
+end
+
+module Parser::Builders; end
+
+class Parser::Builders::Default
+  def initialize; end
+
+  def __ENCODING__(__ENCODING__t); end
+  def __FILE__(__FILE__t); end
+  def __LINE__(__LINE__t); end
+  def accessible(node); end
+  def alias(alias_t, to, from); end
+  def arg(name_t); end
+  def arg_expr(expr); end
+  def args(begin_t, args, end_t, check_args = T.unsafe(nil)); end
+  def array(begin_t, elements, end_t); end
+  def array_pattern(lbrack_t, elements, rbrack_t); end
+  def assign(lhs, eql_t, rhs); end
+  def assignable(node); end
+  def associate(begin_t, pairs, end_t); end
+  def attr_asgn(receiver, dot_t, selector_t); end
+  def back_ref(token); end
+  def begin(begin_t, body, end_t); end
+  def begin_body(compound_stmt, rescue_bodies = T.unsafe(nil), else_t = T.unsafe(nil), else_ = T.unsafe(nil), ensure_t = T.unsafe(nil), ensure_ = T.unsafe(nil)); end
+  def begin_keyword(begin_t, body, end_t); end
+  def binary_op(receiver, operator_t, arg); end
+  def block(method_call, begin_t, args, body, end_t); end
+  def block_pass(amper_t, arg); end
+  def blockarg(amper_t, name_t); end
+  def blockarg_expr(amper_t, expr); end
+  def call_lambda(lambda_t); end
+  def call_method(receiver, dot_t, selector_t, lparen_t = T.unsafe(nil), args = T.unsafe(nil), rparen_t = T.unsafe(nil)); end
+  def call_type_for_dot(dot_t); end
+  def case(case_t, expr, when_bodies, else_t, else_body, end_t); end
+  def case_match(case_t, expr, in_bodies, else_t, else_body, end_t); end
+  def character(char_t); end
+  def complex(complex_t); end
+  def compstmt(statements); end
+  def condition(cond_t, cond, then_t, if_true, else_t, if_false, end_t); end
+  def condition_mod(if_true, if_false, cond_t, cond); end
+  def const(name_t); end
+  def const_fetch(scope, t_colon2, name_t); end
+  def const_global(t_colon3, name_t); end
+  def const_op_assignable(node); end
+  def const_pattern(const, ldelim_t, pattern, rdelim_t); end
+  def cvar(token); end
+  def dedent_string(node, dedent_level); end
+  def def_class(class_t, name, lt_t, superclass, body, end_t); end
+  def def_endless_method(def_t, name_t, args, assignment_t, body); end
+  def def_endless_singleton(def_t, definee, dot_t, name_t, args, assignment_t, body); end
+  def def_method(def_t, name_t, args, body, end_t); end
+  def def_module(module_t, name, body, end_t); end
+  def def_sclass(class_t, lshft_t, expr, body, end_t); end
+  def def_singleton(def_t, definee, dot_t, name_t, args, body, end_t); end
+  def emit_file_line_as_literals; end
+  def emit_file_line_as_literals=(_arg0); end
+  def false(false_t); end
+  def find_pattern(lbrack_t, elements, rbrack_t); end
+  def float(float_t); end
+  def for(for_t, iterator, in_t, iteratee, do_t, body, end_t); end
+  def forward_arg(dots_t); end
+  def forward_only_args(begin_t, dots_t, end_t); end
+  def forwarded_args(dots_t); end
+  def gvar(token); end
+  def hash_pattern(lbrace_t, kwargs, rbrace_t); end
+  def ident(token); end
+  def if_guard(if_t, if_body); end
+  def in_match(lhs, in_t, rhs); end
+  def in_pattern(in_t, pattern, guard, then_t, body); end
+  def index(receiver, lbrack_t, indexes, rbrack_t); end
+  def index_asgn(receiver, lbrack_t, indexes, rbrack_t); end
+  def integer(integer_t); end
+  def ivar(token); end
+  def keyword_cmd(type, keyword_t, lparen_t = T.unsafe(nil), args = T.unsafe(nil), rparen_t = T.unsafe(nil)); end
+  def kwarg(name_t); end
+  def kwnilarg(dstar_t, nil_t); end
+  def kwoptarg(name_t, value); end
+  def kwrestarg(dstar_t, name_t = T.unsafe(nil)); end
+  def kwsplat(dstar_t, arg); end
+  def logical_op(type, lhs, op_t, rhs); end
+  def loop(type, keyword_t, cond, do_t, body, end_t); end
+  def loop_mod(type, body, keyword_t, cond); end
+  def match_alt(left, pipe_t, right); end
+  def match_as(value, assoc_t, as); end
+  def match_hash_var(name_t); end
+  def match_hash_var_from_str(begin_t, strings, end_t); end
+  def match_label(label_type, label); end
+  def match_nil_pattern(dstar_t, nil_t); end
+  def match_op(receiver, match_t, arg); end
+  def match_pair(label_type, label, value); end
+  def match_rest(star_t, name_t = T.unsafe(nil)); end
+  def match_var(name_t); end
+  def match_with_trailing_comma(match, comma_t); end
+  def multi_assign(lhs, eql_t, rhs); end
+  def multi_lhs(begin_t, items, end_t); end
+  def multi_rassign(lhs, assoc_t, rhs); end
+  def nil(nil_t); end
+  def not_op(not_t, begin_t = T.unsafe(nil), receiver = T.unsafe(nil), end_t = T.unsafe(nil)); end
+  def nth_ref(token); end
+  def numargs(max_numparam); end
+  def objc_kwarg(kwname_t, assoc_t, name_t); end
+  def objc_restarg(star_t, name = T.unsafe(nil)); end
+  def objc_varargs(pair, rest_of_varargs); end
+  def op_assign(lhs, op_t, rhs); end
+  def optarg(name_t, eql_t, value); end
+  def pair(key, assoc_t, value); end
+  def pair_keyword(key_t, value); end
+  def pair_list_18(list); end
+  def pair_quoted(begin_t, parts, end_t, value); end
+  def parser; end
+  def parser=(_arg0); end
+  def pin(pin_t, var); end
+  def postexe(postexe_t, lbrace_t, compstmt, rbrace_t); end
+  def preexe(preexe_t, lbrace_t, compstmt, rbrace_t); end
+  def procarg0(arg); end
+  def range_exclusive(lhs, dot3_t, rhs); end
+  def range_inclusive(lhs, dot2_t, rhs); end
+  def rassign(lhs, assoc_t, rhs); end
+  def rational(rational_t); end
+  def regexp_compose(begin_t, parts, end_t, options); end
+  def regexp_options(regopt_t); end
+  def rescue_body(rescue_t, exc_list, assoc_t, exc_var, then_t, compound_stmt); end
+  def restarg(star_t, name_t = T.unsafe(nil)); end
+  def restarg_expr(star_t, expr = T.unsafe(nil)); end
+  def self(token); end
+  def shadowarg(name_t); end
+  def splat(star_t, arg = T.unsafe(nil)); end
+  def string(string_t); end
+  def string_compose(begin_t, parts, end_t); end
+  def string_internal(string_t); end
+  def symbol(symbol_t); end
+  def symbol_compose(begin_t, parts, end_t); end
+  def symbol_internal(symbol_t); end
+  def symbols_compose(begin_t, parts, end_t); end
+  def ternary(cond, question_t, if_true, colon_t, if_false); end
+  def true(true_t); end
+  def unary_num(unary_t, numeric); end
+  def unary_op(op_t, receiver); end
+  def undef_method(undef_t, names); end
+  def unless_guard(unless_t, unless_body); end
+  def when(when_t, patterns, then_t, body); end
+  def word(parts); end
+  def words_compose(begin_t, parts, end_t); end
+  def xstring_compose(begin_t, parts, end_t); end
+
+  private
+
+  def arg_name_collides?(this_name, that_name); end
+  def arg_prefix_map(op_t, name_t = T.unsafe(nil)); end
+  def binary_op_map(left_e, op_t, right_e); end
+  def block_map(receiver_l, begin_t, end_t); end
+  def check_assignment_to_numparam(node); end
+  def check_condition(cond); end
+  def check_duplicate_arg(this_arg, map = T.unsafe(nil)); end
+  def check_duplicate_args(args, map = T.unsafe(nil)); end
+  def check_duplicate_pattern_key(name, loc); end
+  def check_duplicate_pattern_variable(name, loc); end
+  def check_lvar_name(name, loc); end
+  def collapse_string_parts?(parts); end
+  def collection_map(begin_t, parts, end_t); end
+  def condition_map(keyword_t, cond_e, begin_t, body_e, else_t, else_e, end_t); end
+  def constant_map(scope, colon2_t, name_t); end
+  def definition_map(keyword_t, operator_t, name_t, end_t); end
+  def delimited_string_map(string_t); end
+  def diagnostic(type, reason, arguments, location, highlights = T.unsafe(nil)); end
+  def eh_keyword_map(compstmt_e, keyword_t, body_es, else_t, else_e); end
+  def endless_definition_map(keyword_t, operator_t, name_t, assignment_t, body_e); end
+  def expr_map(loc); end
+  def for_map(keyword_t, in_t, begin_t, end_t); end
+  def guard_map(keyword_t, guard_body_e); end
+  def index_map(receiver_e, lbrack_t, rbrack_t); end
+  def join_exprs(left_expr, right_expr); end
+  def keyword_map(keyword_t, begin_t, args, end_t); end
+  def keyword_mod_map(pre_e, keyword_t, post_e); end
+  def kwarg_map(name_t, value_e = T.unsafe(nil)); end
+  def loc(token); end
+  def module_definition_map(keyword_t, name_e, operator_t, end_t); end
+  def n(type, children, source_map); end
+  def n0(type, source_map); end
+  def numeric(kind, token); end
+  def pair_keyword_map(key_t, value_e); end
+  def pair_quoted_map(begin_t, end_t, value_e); end
+  def prefix_string_map(symbol); end
+  def range_map(start_e, op_t, end_e); end
+  def regexp_map(begin_t, end_t, options_e); end
+  def rescue_body_map(keyword_t, exc_list_e, assoc_t, exc_var_e, then_t, compstmt_e); end
+  def send_binary_op_map(lhs_e, selector_t, rhs_e); end
+  def send_index_map(receiver_e, lbrack_t, rbrack_t); end
+  def send_map(receiver_e, dot_t, selector_t, begin_t = T.unsafe(nil), args = T.unsafe(nil), end_t = T.unsafe(nil)); end
+  def send_unary_op_map(selector_t, arg_e); end
+  def static_regexp(parts, options); end
+  def static_regexp_node(node); end
+  def static_string(nodes); end
+  def string_map(begin_t, parts, end_t); end
+  def string_value(token); end
+  def ternary_map(begin_e, question_t, mid_e, colon_t, end_e); end
+  def token_map(token); end
+  def unary_op_map(op_t, arg_e = T.unsafe(nil)); end
+  def unquoted_map(token); end
+  def validate_definee(definee); end
+  def value(token); end
+  def var_send_map(variable_e); end
+  def variable_map(name_t); end
+
+  class << self
+    def emit_arg_inside_procarg0; end
+    def emit_arg_inside_procarg0=(_arg0); end
+    def emit_encoding; end
+    def emit_encoding=(_arg0); end
+    def emit_forward_arg; end
+    def emit_forward_arg=(_arg0); end
+    def emit_index; end
+    def emit_index=(_arg0); end
+    def emit_lambda; end
+    def emit_lambda=(_arg0); end
+    def emit_procarg0; end
+    def emit_procarg0=(_arg0); end
+    def modernize; end
+  end
+end
+
+class Parser::ClobberingError < ::RuntimeError; end
+
+class Parser::Context
+  def initialize; end
+
+  def class_definition_allowed?; end
+  def dynamic_const_definition_allowed?; end
+  def in_block?; end
+  def in_class?; end
+  def in_dynamic_block?; end
+  def in_lambda?; end
+  def indirectly_in_def?; end
+  def module_definition_allowed?; end
+  def pop; end
+  def push(state); end
+  def reset; end
+  def stack; end
+end
+
+class Parser::CurrentArgStack
+  def initialize; end
+
+  def pop; end
+  def push(value); end
+  def reset; end
+  def set(value); end
+  def stack; end
+  def top; end
+end
+
+Parser::CurrentRuby = Parser::Ruby27
+
+module Parser::Deprecation
+  def warn_of_deprecation; end
+  def warned_of_deprecation=(_arg0); end
+end
+
+class Parser::Diagnostic
+  def initialize(level, reason, arguments, location, highlights = T.unsafe(nil)); end
+
+  def arguments; end
+  def highlights; end
+  def level; end
+  def location; end
+  def message; end
+  def reason; end
+  def render; end
+
+  private
+
+  def first_line_only(range); end
+  def last_line_only(range); end
+  def render_line(range, ellipsis = T.unsafe(nil), range_end = T.unsafe(nil)); end
+end
+
+class Parser::Diagnostic::Engine
+  def initialize(consumer = T.unsafe(nil)); end
+
+  def all_errors_are_fatal; end
+  def all_errors_are_fatal=(_arg0); end
+  def consumer; end
+  def consumer=(_arg0); end
+  def ignore_warnings; end
+  def ignore_warnings=(_arg0); end
+  def process(diagnostic); end
+
+  protected
+
+  def ignore?(diagnostic); end
+  def raise?(diagnostic); end
+end
+
+Parser::Diagnostic::LEVELS = T.let(T.unsafe(nil), Array)
+
+class Parser::Lexer
+  def initialize(version); end
+
+  def advance; end
+  def cmdarg; end
+  def cmdarg=(_arg0); end
+  def command_start; end
+  def command_start=(_arg0); end
+  def comments; end
+  def comments=(_arg0); end
+  def cond; end
+  def cond=(_arg0); end
+  def context; end
+  def context=(_arg0); end
+  def dedent_level; end
+  def diagnostics; end
+  def diagnostics=(_arg0); end
+  def encoding; end
+  def force_utf32; end
+  def force_utf32=(_arg0); end
+  def in_kwarg; end
+  def in_kwarg=(_arg0); end
+  def pop_cmdarg; end
+  def pop_cond; end
+  def push_cmdarg; end
+  def push_cond; end
+  def reset(reset_state = T.unsafe(nil)); end
+  def source_buffer; end
+  def source_buffer=(source_buffer); end
+  def state; end
+  def state=(state); end
+  def static_env; end
+  def static_env=(_arg0); end
+  def tokens; end
+  def tokens=(_arg0); end
+
+  protected
+
+  def arg_or_cmdarg(cmd_state); end
+  def diagnostic(type, reason, arguments = T.unsafe(nil), location = T.unsafe(nil), highlights = T.unsafe(nil)); end
+  def emit(type, value = T.unsafe(nil), s = T.unsafe(nil), e = T.unsafe(nil)); end
+  def emit_comment(s = T.unsafe(nil), e = T.unsafe(nil)); end
+  def emit_do(do_block = T.unsafe(nil)); end
+  def emit_table(table, s = T.unsafe(nil), e = T.unsafe(nil)); end
+  def encode_escape(ord); end
+  def eof_codepoint?(point); end
+  def literal; end
+  def next_state_for_literal(literal); end
+  def pop_literal; end
+  def push_literal(*args); end
+  def range(s = T.unsafe(nil), e = T.unsafe(nil)); end
+  def stack_pop; end
+  def tok(s = T.unsafe(nil), e = T.unsafe(nil)); end
+  def version?(*versions); end
+
+  class << self
+    def lex_en_expr_arg; end
+    def lex_en_expr_arg=(_arg0); end
+    def lex_en_expr_beg; end
+    def lex_en_expr_beg=(_arg0); end
+    def lex_en_expr_cmdarg; end
+    def lex_en_expr_cmdarg=(_arg0); end
+    def lex_en_expr_dot; end
+    def lex_en_expr_dot=(_arg0); end
+    def lex_en_expr_end; end
+    def lex_en_expr_end=(_arg0); end
+    def lex_en_expr_endarg; end
+    def lex_en_expr_endarg=(_arg0); end
+    def lex_en_expr_endfn; end
+    def lex_en_expr_endfn=(_arg0); end
+    def lex_en_expr_fname; end
+    def lex_en_expr_fname=(_arg0); end
+    def lex_en_expr_labelarg; end
+    def lex_en_expr_labelarg=(_arg0); end
+    def lex_en_expr_mid; end
+    def lex_en_expr_mid=(_arg0); end
+    def lex_en_expr_value; end
+    def lex_en_expr_value=(_arg0); end
+    def lex_en_expr_variable; end
+    def lex_en_expr_variable=(_arg0); end
+    def lex_en_interp_backslash_delimited; end
+    def lex_en_interp_backslash_delimited=(_arg0); end
+    def lex_en_interp_backslash_delimited_words; end
+    def lex_en_interp_backslash_delimited_words=(_arg0); end
+    def lex_en_interp_string; end
+    def lex_en_interp_string=(_arg0); end
+    def lex_en_interp_words; end
+    def lex_en_interp_words=(_arg0); end
+    def lex_en_leading_dot; end
+    def lex_en_leading_dot=(_arg0); end
+    def lex_en_line_begin; end
+    def lex_en_line_begin=(_arg0); end
+    def lex_en_line_comment; end
+    def lex_en_line_comment=(_arg0); end
+    def lex_en_plain_backslash_delimited; end
+    def lex_en_plain_backslash_delimited=(_arg0); end
+    def lex_en_plain_backslash_delimited_words; end
+    def lex_en_plain_backslash_delimited_words=(_arg0); end
+    def lex_en_plain_string; end
+    def lex_en_plain_string=(_arg0); end
+    def lex_en_plain_words; end
+    def lex_en_plain_words=(_arg0); end
+    def lex_en_regexp_modifiers; end
+    def lex_en_regexp_modifiers=(_arg0); end
+    def lex_error; end
+    def lex_error=(_arg0); end
+    def lex_start; end
+    def lex_start=(_arg0); end
+
+    private
+
+    def _lex_eof_trans; end
+    def _lex_eof_trans=(_arg0); end
+    def _lex_from_state_actions; end
+    def _lex_from_state_actions=(_arg0); end
+    def _lex_index_offsets; end
+    def _lex_index_offsets=(_arg0); end
+    def _lex_indicies; end
+    def _lex_indicies=(_arg0); end
+    def _lex_key_spans; end
+    def _lex_key_spans=(_arg0); end
+    def _lex_to_state_actions; end
+    def _lex_to_state_actions=(_arg0); end
+    def _lex_trans_actions; end
+    def _lex_trans_actions=(_arg0); end
+    def _lex_trans_keys; end
+    def _lex_trans_keys=(_arg0); end
+    def _lex_trans_targs; end
+    def _lex_trans_targs=(_arg0); end
+  end
+end
+
+class Parser::Lexer::Dedenter
+  def initialize(dedent_level); end
+
+  def dedent(string); end
+  def interrupt; end
+end
+
+Parser::Lexer::Dedenter::TAB_WIDTH = T.let(T.unsafe(nil), Integer)
+Parser::Lexer::ESCAPES = T.let(T.unsafe(nil), Hash)
+Parser::Lexer::KEYWORDS = T.let(T.unsafe(nil), Hash)
+Parser::Lexer::KEYWORDS_BEGIN = T.let(T.unsafe(nil), Hash)
+Parser::Lexer::LEX_STATES = T.let(T.unsafe(nil), Hash)
+
+class Parser::Lexer::Literal
+  def initialize(lexer, str_type, delimiter, str_s, heredoc_e = T.unsafe(nil), indent = T.unsafe(nil), dedent_body = T.unsafe(nil), label_allowed = T.unsafe(nil)); end
+
+  def backslash_delimited?; end
+  def dedent_level; end
+  def end_interp_brace_and_try_closing; end
+  def extend_content; end
+  def extend_space(ts, te); end
+  def extend_string(string, ts, te); end
+  def flush_string; end
+  def heredoc?; end
+  def heredoc_e; end
+  def infer_indent_level(line); end
+  def interpolate?; end
+  def munge_escape?(character); end
+  def nest_and_try_closing(delimiter, ts, te, lookahead = T.unsafe(nil)); end
+  def plain_heredoc?; end
+  def regexp?; end
+  def saved_herebody_s; end
+  def saved_herebody_s=(_arg0); end
+  def squiggly_heredoc?; end
+  def start_interp_brace; end
+  def str_s; end
+  def supports_line_continuation_via_slash?; end
+  def type; end
+  def words?; end
+
+  protected
+
+  def clear_buffer; end
+  def coerce_encoding(string); end
+  def delimiter?(delimiter); end
+  def emit(token, type, s, e); end
+  def emit_start_tok; end
+end
+
+Parser::Lexer::Literal::DELIMITERS = T.let(T.unsafe(nil), Hash)
+Parser::Lexer::Literal::TYPES = T.let(T.unsafe(nil), Hash)
+Parser::Lexer::PUNCTUATION = T.let(T.unsafe(nil), Hash)
+Parser::Lexer::PUNCTUATION_BEGIN = T.let(T.unsafe(nil), Hash)
+Parser::Lexer::REGEXP_META_CHARACTERS = T.let(T.unsafe(nil), Regexp)
+
+class Parser::Lexer::StackState
+  def initialize(name); end
+
+  def active?; end
+  def clear; end
+  def empty?; end
+  def inspect; end
+  def lexpop; end
+  def pop; end
+  def push(bit); end
+  def to_s; end
+end
+
+Parser::MESSAGES = T.let(T.unsafe(nil), Hash)
+
+class Parser::MaxNumparamStack
+  def initialize; end
+
+  def has_numparams?; end
+  def has_ordinary_params!; end
+  def has_ordinary_params?; end
+  def pop; end
+  def push; end
+  def register(numparam); end
+  def stack; end
+  def top; end
+
+  private
+
+  def set(value); end
+end
+
+module Parser::Messages
+  class << self
+    def compile(reason, arguments); end
+  end
+end
+
+module Parser::Meta; end
+Parser::Meta::NODE_TYPES = T.let(T.unsafe(nil), Set)
+
+class Parser::Rewriter < ::Parser::AST::Processor
+  extend ::Parser::Deprecation
+
+  def initialize(*_arg0); end
+
+  def assignment?(node); end
+  def insert_after(range, content); end
+  def insert_before(range, content); end
+  def remove(range); end
+  def replace(range, content); end
+  def rewrite(source_buffer, ast); end
+  def wrap(range, before, after); end
+end
+
+Parser::Rewriter::DEPRECATION_WARNING = T.let(T.unsafe(nil), String)
+
+class Parser::Ruby27 < ::Parser::Base
+  def _reduce_10(val, _values, result); end
+  def _reduce_100(val, _values, result); end
+  def _reduce_101(val, _values, result); end
+  def _reduce_102(val, _values, result); end
+  def _reduce_103(val, _values, result); end
+  def _reduce_104(val, _values, result); end
+  def _reduce_105(val, _values, result); end
+  def _reduce_106(val, _values, result); end
+  def _reduce_107(val, _values, result); end
+  def _reduce_108(val, _values, result); end
+  def _reduce_109(val, _values, result); end
+  def _reduce_11(val, _values, result); end
+  def _reduce_110(val, _values, result); end
+  def _reduce_111(val, _values, result); end
+  def _reduce_112(val, _values, result); end
+  def _reduce_113(val, _values, result); end
+  def _reduce_114(val, _values, result); end
+  def _reduce_116(val, _values, result); end
+  def _reduce_117(val, _values, result); end
+  def _reduce_118(val, _values, result); end
+  def _reduce_12(val, _values, result); end
+  def _reduce_124(val, _values, result); end
+  def _reduce_126(val, _values, result); end
+  def _reduce_127(val, _values, result); end
+  def _reduce_128(val, _values, result); end
+  def _reduce_13(val, _values, result); end
+  def _reduce_14(val, _values, result); end
+  def _reduce_15(val, _values, result); end
+  def _reduce_17(val, _values, result); end
+  def _reduce_18(val, _values, result); end
+  def _reduce_19(val, _values, result); end
+  def _reduce_2(val, _values, result); end
+  def _reduce_20(val, _values, result); end
+  def _reduce_200(val, _values, result); end
+  def _reduce_201(val, _values, result); end
+  def _reduce_202(val, _values, result); end
+  def _reduce_203(val, _values, result); end
+  def _reduce_204(val, _values, result); end
+  def _reduce_205(val, _values, result); end
+  def _reduce_206(val, _values, result); end
+  def _reduce_207(val, _values, result); end
+  def _reduce_208(val, _values, result); end
+  def _reduce_209(val, _values, result); end
+  def _reduce_21(val, _values, result); end
+  def _reduce_210(val, _values, result); end
+  def _reduce_211(val, _values, result); end
+  def _reduce_212(val, _values, result); end
+  def _reduce_213(val, _values, result); end
+  def _reduce_214(val, _values, result); end
+  def _reduce_215(val, _values, result); end
+  def _reduce_216(val, _values, result); end
+  def _reduce_217(val, _values, result); end
+  def _reduce_218(val, _values, result); end
+  def _reduce_219(val, _values, result); end
+  def _reduce_22(val, _values, result); end
+  def _reduce_220(val, _values, result); end
+  def _reduce_221(val, _values, result); end
+  def _reduce_222(val, _values, result); end
+  def _reduce_223(val, _values, result); end
+  def _reduce_224(val, _values, result); end
+  def _reduce_225(val, _values, result); end
+  def _reduce_226(val, _values, result); end
+  def _reduce_227(val, _values, result); end
+  def _reduce_229(val, _values, result); end
+  def _reduce_23(val, _values, result); end
+  def _reduce_230(val, _values, result); end
+  def _reduce_231(val, _values, result); end
+  def _reduce_232(val, _values, result); end
+  def _reduce_233(val, _values, result); end
+  def _reduce_234(val, _values, result); end
+  def _reduce_235(val, _values, result); end
+  def _reduce_236(val, _values, result); end
+  def _reduce_237(val, _values, result); end
+  def _reduce_238(val, _values, result); end
+  def _reduce_239(val, _values, result); end
+  def _reduce_24(val, _values, result); end
+  def _reduce_240(val, _values, result); end
+  def _reduce_241(val, _values, result); end
+  def _reduce_247(val, _values, result); end
+  def _reduce_248(val, _values, result); end
+  def _reduce_25(val, _values, result); end
+  def _reduce_252(val, _values, result); end
+  def _reduce_253(val, _values, result); end
+  def _reduce_255(val, _values, result); end
+  def _reduce_256(val, _values, result); end
+  def _reduce_257(val, _values, result); end
+  def _reduce_258(val, _values, result); end
+  def _reduce_26(val, _values, result); end
+  def _reduce_260(val, _values, result); end
+  def _reduce_263(val, _values, result); end
+  def _reduce_264(val, _values, result); end
+  def _reduce_265(val, _values, result); end
+  def _reduce_266(val, _values, result); end
+  def _reduce_267(val, _values, result); end
+  def _reduce_268(val, _values, result); end
+  def _reduce_269(val, _values, result); end
+  def _reduce_27(val, _values, result); end
+  def _reduce_270(val, _values, result); end
+  def _reduce_271(val, _values, result); end
+  def _reduce_272(val, _values, result); end
+  def _reduce_273(val, _values, result); end
+  def _reduce_274(val, _values, result); end
+  def _reduce_275(val, _values, result); end
+  def _reduce_276(val, _values, result); end
+  def _reduce_277(val, _values, result); end
+  def _reduce_278(val, _values, result); end
+  def _reduce_279(val, _values, result); end
+  def _reduce_28(val, _values, result); end
+  def _reduce_281(val, _values, result); end
+  def _reduce_282(val, _values, result); end
+  def _reduce_283(val, _values, result); end
+  def _reduce_29(val, _values, result); end
+  def _reduce_294(val, _values, result); end
+  def _reduce_295(val, _values, result); end
+  def _reduce_296(val, _values, result); end
+  def _reduce_297(val, _values, result); end
+  def _reduce_298(val, _values, result); end
+  def _reduce_299(val, _values, result); end
+  def _reduce_3(val, _values, result); end
+  def _reduce_300(val, _values, result); end
+  def _reduce_301(val, _values, result); end
+  def _reduce_302(val, _values, result); end
+  def _reduce_303(val, _values, result); end
+  def _reduce_304(val, _values, result); end
+  def _reduce_305(val, _values, result); end
+  def _reduce_306(val, _values, result); end
+  def _reduce_307(val, _values, result); end
+  def _reduce_308(val, _values, result); end
+  def _reduce_309(val, _values, result); end
+  def _reduce_31(val, _values, result); end
+  def _reduce_310(val, _values, result); end
+  def _reduce_311(val, _values, result); end
+  def _reduce_312(val, _values, result); end
+  def _reduce_313(val, _values, result); end
+  def _reduce_315(val, _values, result); end
+  def _reduce_316(val, _values, result); end
+  def _reduce_317(val, _values, result); end
+  def _reduce_318(val, _values, result); end
+  def _reduce_319(val, _values, result); end
+  def _reduce_32(val, _values, result); end
+  def _reduce_320(val, _values, result); end
+  def _reduce_321(val, _values, result); end
+  def _reduce_322(val, _values, result); end
+  def _reduce_323(val, _values, result); end
+  def _reduce_324(val, _values, result); end
+  def _reduce_325(val, _values, result); end
+  def _reduce_326(val, _values, result); end
+  def _reduce_327(val, _values, result); end
+  def _reduce_328(val, _values, result); end
+  def _reduce_329(val, _values, result); end
+  def _reduce_33(val, _values, result); end
+  def _reduce_330(val, _values, result); end
+  def _reduce_331(val, _values, result); end
+  def _reduce_332(val, _values, result); end
+  def _reduce_333(val, _values, result); end
+  def _reduce_334(val, _values, result); end
+  def _reduce_335(val, _values, result); end
+  def _reduce_336(val, _values, result); end
+  def _reduce_337(val, _values, result); end
+  def _reduce_338(val, _values, result); end
+  def _reduce_339(val, _values, result); end
+  def _reduce_34(val, _values, result); end
+  def _reduce_340(val, _values, result); end
+  def _reduce_342(val, _values, result); end
+  def _reduce_345(val, _values, result); end
+  def _reduce_349(val, _values, result); end
+  def _reduce_351(val, _values, result); end
+  def _reduce_354(val, _values, result); end
+  def _reduce_355(val, _values, result); end
+  def _reduce_356(val, _values, result); end
+  def _reduce_357(val, _values, result); end
+  def _reduce_359(val, _values, result); end
+  def _reduce_36(val, _values, result); end
+  def _reduce_360(val, _values, result); end
+  def _reduce_361(val, _values, result); end
+  def _reduce_362(val, _values, result); end
+  def _reduce_363(val, _values, result); end
+  def _reduce_364(val, _values, result); end
+  def _reduce_365(val, _values, result); end
+  def _reduce_366(val, _values, result); end
+  def _reduce_367(val, _values, result); end
+  def _reduce_368(val, _values, result); end
+  def _reduce_369(val, _values, result); end
+  def _reduce_37(val, _values, result); end
+  def _reduce_370(val, _values, result); end
+  def _reduce_371(val, _values, result); end
+  def _reduce_372(val, _values, result); end
+  def _reduce_373(val, _values, result); end
+  def _reduce_374(val, _values, result); end
+  def _reduce_375(val, _values, result); end
+  def _reduce_376(val, _values, result); end
+  def _reduce_378(val, _values, result); end
+  def _reduce_379(val, _values, result); end
+  def _reduce_38(val, _values, result); end
+  def _reduce_380(val, _values, result); end
+  def _reduce_381(val, _values, result); end
+  def _reduce_382(val, _values, result); end
+  def _reduce_383(val, _values, result); end
+  def _reduce_384(val, _values, result); end
+  def _reduce_385(val, _values, result); end
+  def _reduce_387(val, _values, result); end
+  def _reduce_388(val, _values, result); end
+  def _reduce_389(val, _values, result); end
+  def _reduce_39(val, _values, result); end
+  def _reduce_390(val, _values, result); end
+  def _reduce_391(val, _values, result); end
+  def _reduce_392(val, _values, result); end
+  def _reduce_393(val, _values, result); end
+  def _reduce_394(val, _values, result); end
+  def _reduce_395(val, _values, result); end
+  def _reduce_397(val, _values, result); end
+  def _reduce_398(val, _values, result); end
+  def _reduce_399(val, _values, result); end
+  def _reduce_4(val, _values, result); end
+  def _reduce_40(val, _values, result); end
+  def _reduce_400(val, _values, result); end
+  def _reduce_401(val, _values, result); end
+  def _reduce_402(val, _values, result); end
+  def _reduce_403(val, _values, result); end
+  def _reduce_404(val, _values, result); end
+  def _reduce_405(val, _values, result); end
+  def _reduce_406(val, _values, result); end
+  def _reduce_407(val, _values, result); end
+  def _reduce_408(val, _values, result); end
+  def _reduce_409(val, _values, result); end
+  def _reduce_41(val, _values, result); end
+  def _reduce_410(val, _values, result); end
+  def _reduce_411(val, _values, result); end
+  def _reduce_412(val, _values, result); end
+  def _reduce_413(val, _values, result); end
+  def _reduce_414(val, _values, result); end
+  def _reduce_415(val, _values, result); end
+  def _reduce_416(val, _values, result); end
+  def _reduce_417(val, _values, result); end
+  def _reduce_418(val, _values, result); end
+  def _reduce_419(val, _values, result); end
+  def _reduce_42(val, _values, result); end
+  def _reduce_420(val, _values, result); end
+  def _reduce_421(val, _values, result); end
+  def _reduce_422(val, _values, result); end
+  def _reduce_423(val, _values, result); end
+  def _reduce_424(val, _values, result); end
+  def _reduce_425(val, _values, result); end
+  def _reduce_426(val, _values, result); end
+  def _reduce_427(val, _values, result); end
+  def _reduce_428(val, _values, result); end
+  def _reduce_429(val, _values, result); end
+  def _reduce_43(val, _values, result); end
+  def _reduce_430(val, _values, result); end
+  def _reduce_431(val, _values, result); end
+  def _reduce_433(val, _values, result); end
+  def _reduce_434(val, _values, result); end
+  def _reduce_435(val, _values, result); end
+  def _reduce_436(val, _values, result); end
+  def _reduce_438(val, _values, result); end
+  def _reduce_439(val, _values, result); end
+  def _reduce_440(val, _values, result); end
+  def _reduce_442(val, _values, result); end
+  def _reduce_443(val, _values, result); end
+  def _reduce_444(val, _values, result); end
+  def _reduce_445(val, _values, result); end
+  def _reduce_447(val, _values, result); end
+  def _reduce_449(val, _values, result); end
+  def _reduce_45(val, _values, result); end
+  def _reduce_451(val, _values, result); end
+  def _reduce_452(val, _values, result); end
+  def _reduce_454(val, _values, result); end
+  def _reduce_455(val, _values, result); end
+  def _reduce_456(val, _values, result); end
+  def _reduce_457(val, _values, result); end
+  def _reduce_458(val, _values, result); end
+  def _reduce_459(val, _values, result); end
+  def _reduce_460(val, _values, result); end
+  def _reduce_461(val, _values, result); end
+  def _reduce_462(val, _values, result); end
+  def _reduce_463(val, _values, result); end
+  def _reduce_464(val, _values, result); end
+  def _reduce_465(val, _values, result); end
+  def _reduce_466(val, _values, result); end
+  def _reduce_467(val, _values, result); end
+  def _reduce_468(val, _values, result); end
+  def _reduce_469(val, _values, result); end
+  def _reduce_470(val, _values, result); end
+  def _reduce_471(val, _values, result); end
+  def _reduce_472(val, _values, result); end
+  def _reduce_473(val, _values, result); end
+  def _reduce_474(val, _values, result); end
+  def _reduce_476(val, _values, result); end
+  def _reduce_477(val, _values, result); end
+  def _reduce_478(val, _values, result); end
+  def _reduce_479(val, _values, result); end
+  def _reduce_48(val, _values, result); end
+  def _reduce_480(val, _values, result); end
+  def _reduce_481(val, _values, result); end
+  def _reduce_482(val, _values, result); end
+  def _reduce_483(val, _values, result); end
+  def _reduce_485(val, _values, result); end
+  def _reduce_486(val, _values, result); end
+  def _reduce_487(val, _values, result); end
+  def _reduce_488(val, _values, result); end
+  def _reduce_489(val, _values, result); end
+  def _reduce_49(val, _values, result); end
+  def _reduce_490(val, _values, result); end
+  def _reduce_491(val, _values, result); end
+  def _reduce_492(val, _values, result); end
+  def _reduce_493(val, _values, result); end
+  def _reduce_494(val, _values, result); end
+  def _reduce_495(val, _values, result); end
+  def _reduce_496(val, _values, result); end
+  def _reduce_497(val, _values, result); end
+  def _reduce_498(val, _values, result); end
+  def _reduce_499(val, _values, result); end
+  def _reduce_5(val, _values, result); end
+  def _reduce_50(val, _values, result); end
+  def _reduce_501(val, _values, result); end
+  def _reduce_502(val, _values, result); end
+  def _reduce_503(val, _values, result); end
+  def _reduce_504(val, _values, result); end
+  def _reduce_508(val, _values, result); end
+  def _reduce_509(val, _values, result); end
+  def _reduce_51(val, _values, result); end
+  def _reduce_518(val, _values, result); end
+  def _reduce_519(val, _values, result); end
+  def _reduce_52(val, _values, result); end
+  def _reduce_520(val, _values, result); end
+  def _reduce_521(val, _values, result); end
+  def _reduce_522(val, _values, result); end
+  def _reduce_523(val, _values, result); end
+  def _reduce_524(val, _values, result); end
+  def _reduce_525(val, _values, result); end
+  def _reduce_526(val, _values, result); end
+  def _reduce_527(val, _values, result); end
+  def _reduce_528(val, _values, result); end
+  def _reduce_53(val, _values, result); end
+  def _reduce_531(val, _values, result); end
+  def _reduce_533(val, _values, result); end
+  def _reduce_537(val, _values, result); end
+  def _reduce_538(val, _values, result); end
+  def _reduce_539(val, _values, result); end
+  def _reduce_540(val, _values, result); end
+  def _reduce_541(val, _values, result); end
+  def _reduce_542(val, _values, result); end
+  def _reduce_543(val, _values, result); end
+  def _reduce_544(val, _values, result); end
+  def _reduce_545(val, _values, result); end
+  def _reduce_546(val, _values, result); end
+  def _reduce_547(val, _values, result); end
+  def _reduce_548(val, _values, result); end
+  def _reduce_549(val, _values, result); end
+  def _reduce_550(val, _values, result); end
+  def _reduce_551(val, _values, result); end
+  def _reduce_552(val, _values, result); end
+  def _reduce_553(val, _values, result); end
+  def _reduce_554(val, _values, result); end
+  def _reduce_555(val, _values, result); end
+  def _reduce_556(val, _values, result); end
+  def _reduce_557(val, _values, result); end
+  def _reduce_558(val, _values, result); end
+  def _reduce_559(val, _values, result); end
+  def _reduce_56(val, _values, result); end
+  def _reduce_560(val, _values, result); end
+  def _reduce_561(val, _values, result); end
+  def _reduce_562(val, _values, result); end
+  def _reduce_563(val, _values, result); end
+  def _reduce_564(val, _values, result); end
+  def _reduce_565(val, _values, result); end
+  def _reduce_566(val, _values, result); end
+  def _reduce_567(val, _values, result); end
+  def _reduce_568(val, _values, result); end
+  def _reduce_569(val, _values, result); end
+  def _reduce_57(val, _values, result); end
+  def _reduce_570(val, _values, result); end
+  def _reduce_571(val, _values, result); end
+  def _reduce_575(val, _values, result); end
+  def _reduce_576(val, _values, result); end
+  def _reduce_577(val, _values, result); end
+  def _reduce_578(val, _values, result); end
+  def _reduce_579(val, _values, result); end
+  def _reduce_580(val, _values, result); end
+  def _reduce_581(val, _values, result); end
+  def _reduce_582(val, _values, result); end
+  def _reduce_583(val, _values, result); end
+  def _reduce_584(val, _values, result); end
+  def _reduce_585(val, _values, result); end
+  def _reduce_586(val, _values, result); end
+  def _reduce_587(val, _values, result); end
+  def _reduce_588(val, _values, result); end
+  def _reduce_589(val, _values, result); end
+  def _reduce_590(val, _values, result); end
+  def _reduce_591(val, _values, result); end
+  def _reduce_592(val, _values, result); end
+  def _reduce_593(val, _values, result); end
+  def _reduce_594(val, _values, result); end
+  def _reduce_595(val, _values, result); end
+  def _reduce_596(val, _values, result); end
+  def _reduce_597(val, _values, result); end
+  def _reduce_598(val, _values, result); end
+  def _reduce_599(val, _values, result); end
+  def _reduce_6(val, _values, result); end
+  def _reduce_600(val, _values, result); end
+  def _reduce_601(val, _values, result); end
+  def _reduce_602(val, _values, result); end
+  def _reduce_603(val, _values, result); end
+  def _reduce_604(val, _values, result); end
+  def _reduce_605(val, _values, result); end
+  def _reduce_606(val, _values, result); end
+  def _reduce_607(val, _values, result); end
+  def _reduce_608(val, _values, result); end
+  def _reduce_609(val, _values, result); end
+  def _reduce_61(val, _values, result); end
+  def _reduce_610(val, _values, result); end
+  def _reduce_611(val, _values, result); end
+  def _reduce_612(val, _values, result); end
+  def _reduce_613(val, _values, result); end
+  def _reduce_614(val, _values, result); end
+  def _reduce_615(val, _values, result); end
+  def _reduce_616(val, _values, result); end
+  def _reduce_617(val, _values, result); end
+  def _reduce_618(val, _values, result); end
+  def _reduce_619(val, _values, result); end
+  def _reduce_62(val, _values, result); end
+  def _reduce_620(val, _values, result); end
+  def _reduce_621(val, _values, result); end
+  def _reduce_622(val, _values, result); end
+  def _reduce_623(val, _values, result); end
+  def _reduce_624(val, _values, result); end
+  def _reduce_625(val, _values, result); end
+  def _reduce_626(val, _values, result); end
+  def _reduce_627(val, _values, result); end
+  def _reduce_628(val, _values, result); end
+  def _reduce_629(val, _values, result); end
+  def _reduce_63(val, _values, result); end
+  def _reduce_630(val, _values, result); end
+  def _reduce_631(val, _values, result); end
+  def _reduce_632(val, _values, result); end
+  def _reduce_633(val, _values, result); end
+  def _reduce_634(val, _values, result); end
+  def _reduce_636(val, _values, result); end
+  def _reduce_637(val, _values, result); end
+  def _reduce_638(val, _values, result); end
+  def _reduce_639(val, _values, result); end
+  def _reduce_640(val, _values, result); end
+  def _reduce_641(val, _values, result); end
+  def _reduce_642(val, _values, result); end
+  def _reduce_643(val, _values, result); end
+  def _reduce_644(val, _values, result); end
+  def _reduce_645(val, _values, result); end
+  def _reduce_646(val, _values, result); end
+  def _reduce_647(val, _values, result); end
+  def _reduce_648(val, _values, result); end
+  def _reduce_649(val, _values, result); end
+  def _reduce_65(val, _values, result); end
+  def _reduce_650(val, _values, result); end
+  def _reduce_653(val, _values, result); end
+  def _reduce_654(val, _values, result); end
+  def _reduce_655(val, _values, result); end
+  def _reduce_656(val, _values, result); end
+  def _reduce_657(val, _values, result); end
+  def _reduce_658(val, _values, result); end
+  def _reduce_659(val, _values, result); end
+  def _reduce_66(val, _values, result); end
+  def _reduce_660(val, _values, result); end
+  def _reduce_661(val, _values, result); end
+  def _reduce_664(val, _values, result); end
+  def _reduce_665(val, _values, result); end
+  def _reduce_668(val, _values, result); end
+  def _reduce_669(val, _values, result); end
+  def _reduce_67(val, _values, result); end
+  def _reduce_670(val, _values, result); end
+  def _reduce_672(val, _values, result); end
+  def _reduce_673(val, _values, result); end
+  def _reduce_675(val, _values, result); end
+  def _reduce_676(val, _values, result); end
+  def _reduce_677(val, _values, result); end
+  def _reduce_678(val, _values, result); end
+  def _reduce_679(val, _values, result); end
+  def _reduce_68(val, _values, result); end
+  def _reduce_680(val, _values, result); end
+  def _reduce_69(val, _values, result); end
+  def _reduce_693(val, _values, result); end
+  def _reduce_694(val, _values, result); end
+  def _reduce_699(val, _values, result); end
+  def _reduce_70(val, _values, result); end
+  def _reduce_700(val, _values, result); end
+  def _reduce_701(val, _values, result); end
+  def _reduce_705(val, _values, result); end
+  def _reduce_709(val, _values, result); end
+  def _reduce_71(val, _values, result); end
+  def _reduce_72(val, _values, result); end
+  def _reduce_73(val, _values, result); end
+  def _reduce_74(val, _values, result); end
+  def _reduce_75(val, _values, result); end
+  def _reduce_76(val, _values, result); end
+  def _reduce_77(val, _values, result); end
+  def _reduce_78(val, _values, result); end
+  def _reduce_79(val, _values, result); end
+  def _reduce_8(val, _values, result); end
+  def _reduce_81(val, _values, result); end
+  def _reduce_82(val, _values, result); end
+  def _reduce_83(val, _values, result); end
+  def _reduce_84(val, _values, result); end
+  def _reduce_85(val, _values, result); end
+  def _reduce_86(val, _values, result); end
+  def _reduce_87(val, _values, result); end
+  def _reduce_88(val, _values, result); end
+  def _reduce_89(val, _values, result); end
+  def _reduce_9(val, _values, result); end
+  def _reduce_91(val, _values, result); end
+  def _reduce_92(val, _values, result); end
+  def _reduce_93(val, _values, result); end
+  def _reduce_94(val, _values, result); end
+  def _reduce_95(val, _values, result); end
+  def _reduce_96(val, _values, result); end
+  def _reduce_97(val, _values, result); end
+  def _reduce_98(val, _values, result); end
+  def _reduce_99(val, _values, result); end
+  def _reduce_none(val, _values, result); end
+  def default_encoding; end
+  def version; end
+end
+
+Parser::Ruby27::Racc_arg = T.let(T.unsafe(nil), Array)
+Parser::Ruby27::Racc_token_to_s_table = T.let(T.unsafe(nil), Array)
+module Parser::Source; end
+
+class Parser::Source::Buffer
+  def initialize(name, first_line = T.unsafe(nil), source: T.unsafe(nil)); end
+
+  def column_for_position(position); end
+  def decompose_position(position); end
+  def first_line; end
+  def last_line; end
+  def line_for_position(position); end
+  def line_range(lineno); end
+  def name; end
+  def raw_source=(input); end
+  def read; end
+  def slice(range); end
+  def source; end
+  def source=(input); end
+  def source_line(lineno); end
+  def source_lines; end
+  def source_range; end
+
+  private
+
+  def line_begins; end
+  def line_for(position); end
+
+  class << self
+    def recognize_encoding(string); end
+    def reencode_string(input); end
+  end
+end
+
+Parser::Source::Buffer::ENCODING_RE = T.let(T.unsafe(nil), Regexp)
+
+class Parser::Source::Comment
+  def initialize(range); end
+
+  def ==(other); end
+  def document?; end
+  def inline?; end
+  def inspect; end
+  def loc; end
+  def location; end
+  def text; end
+  def type; end
+
+  class << self
+    def associate(ast, comments); end
+    def associate_locations(ast, comments); end
+  end
+end
+
+class Parser::Source::Comment::Associator
+  def initialize(ast, comments); end
+
+  def associate; end
+  def associate_locations; end
+  def skip_directives; end
+  def skip_directives=(_arg0); end
+
+  private
+
+  def advance_comment; end
+  def advance_through_directives; end
+  def associate_and_advance_comment(node); end
+  def children_in_source_order(node); end
+  def current_comment_before?(node); end
+  def current_comment_before_end?(node); end
+  def current_comment_decorates?(node); end
+  def do_associate; end
+  def process_leading_comments(node); end
+  def process_trailing_comments(node); end
+  def visit(node); end
+end
+
+Parser::Source::Comment::Associator::MAGIC_COMMENT_RE = T.let(T.unsafe(nil), Regexp)
+Parser::Source::Comment::Associator::POSTFIX_TYPES = T.let(T.unsafe(nil), Set)
+
+class Parser::Source::Map
+  def initialize(expression); end
+
+  def ==(other); end
+  def column; end
+  def expression; end
+  def first_line; end
+  def last_column; end
+  def last_line; end
+  def line; end
+  def node; end
+  def node=(node); end
+  def to_hash; end
+  def with_expression(expression_l); end
+
+  protected
+
+  def update_expression(expression_l); end
+  def with(&block); end
+
+  private
+
+  def initialize_copy(other); end
+end
+
+class Parser::Source::Map::Collection < ::Parser::Source::Map
+  def initialize(begin_l, end_l, expression_l); end
+
+  def begin; end
+  def end; end
+end
+
+class Parser::Source::Map::Condition < ::Parser::Source::Map
+  def initialize(keyword_l, begin_l, else_l, end_l, expression_l); end
+
+  def begin; end
+  def else; end
+  def end; end
+  def keyword; end
+end
+
+class Parser::Source::Map::Constant < ::Parser::Source::Map
+  def initialize(double_colon, name, expression); end
+
+  def double_colon; end
+  def name; end
+  def operator; end
+  def with_operator(operator_l); end
+
+  protected
+
+  def update_operator(operator_l); end
+end
+
+class Parser::Source::Map::Definition < ::Parser::Source::Map
+  def initialize(keyword_l, operator_l, name_l, end_l); end
+
+  def end; end
+  def keyword; end
+  def name; end
+  def operator; end
+end
+
+class Parser::Source::Map::EndlessDefinition < ::Parser::Source::Map
+  def initialize(keyword_l, operator_l, name_l, assignment_l, body_l); end
+
+  def assignment; end
+  def keyword; end
+  def name; end
+  def operator; end
+end
+
+class Parser::Source::Map::For < ::Parser::Source::Map
+  def initialize(keyword_l, in_l, begin_l, end_l, expression_l); end
+
+  def begin; end
+  def end; end
+  def in; end
+  def keyword; end
+end
+
+class Parser::Source::Map::Heredoc < ::Parser::Source::Map
+  def initialize(begin_l, body_l, end_l); end
+
+  def heredoc_body; end
+  def heredoc_end; end
+end
+
+class Parser::Source::Map::Index < ::Parser::Source::Map
+  def initialize(begin_l, end_l, expression_l); end
+
+  def begin; end
+  def end; end
+  def operator; end
+  def with_operator(operator_l); end
+
+  protected
+
+  def update_operator(operator_l); end
+end
+
+class Parser::Source::Map::Keyword < ::Parser::Source::Map
+  def initialize(keyword_l, begin_l, end_l, expression_l); end
+
+  def begin; end
+  def end; end
+  def keyword; end
+end
+
+class Parser::Source::Map::ObjcKwarg < ::Parser::Source::Map
+  def initialize(keyword_l, operator_l, argument_l, expression_l); end
+
+  def argument; end
+  def keyword; end
+  def operator; end
+end
+
+class Parser::Source::Map::Operator < ::Parser::Source::Map
+  def initialize(operator, expression); end
+
+  def operator; end
+end
+
+class Parser::Source::Map::RescueBody < ::Parser::Source::Map
+  def initialize(keyword_l, assoc_l, begin_l, expression_l); end
+
+  def assoc; end
+  def begin; end
+  def keyword; end
+end
+
+class Parser::Source::Map::Send < ::Parser::Source::Map
+  def initialize(dot_l, selector_l, begin_l, end_l, expression_l); end
+
+  def begin; end
+  def dot; end
+  def end; end
+  def operator; end
+  def selector; end
+  def with_operator(operator_l); end
+
+  protected
+
+  def update_operator(operator_l); end
+end
+
+class Parser::Source::Map::Ternary < ::Parser::Source::Map
+  def initialize(question_l, colon_l, expression_l); end
+
+  def colon; end
+  def question; end
+end
+
+class Parser::Source::Map::Variable < ::Parser::Source::Map
+  def initialize(name_l, expression_l = T.unsafe(nil)); end
+
+  def name; end
+  def operator; end
+  def with_operator(operator_l); end
+
+  protected
+
+  def update_operator(operator_l); end
+end
+
+class Parser::Source::Range
+  include ::Comparable
+
+  def initialize(source_buffer, begin_pos, end_pos); end
+
+  def <=>(other); end
+  def adjust(begin_pos: T.unsafe(nil), end_pos: T.unsafe(nil)); end
+  def begin; end
+  def begin_pos; end
+  def column; end
+  def column_range; end
+  def contained?(other); end
+  def contains?(other); end
+  def crossing?(other); end
+  def disjoint?(other); end
+  def empty?; end
+  def end; end
+  def end_pos; end
+  def eql?(_arg0); end
+  def first_line; end
+  def hash; end
+  def inspect; end
+  def intersect(other); end
+  def is?(*what); end
+  def join(other); end
+  def last_column; end
+  def last_line; end
+  def length; end
+  def line; end
+  def overlaps?(other); end
+  def resize(new_size); end
+  def size; end
+  def source; end
+  def source_buffer; end
+  def source_line; end
+  def to_a; end
+  def to_range; end
+  def to_s; end
+  def with(begin_pos: T.unsafe(nil), end_pos: T.unsafe(nil)); end
+end
+
+class Parser::Source::Rewriter
+  extend ::Parser::Deprecation
+
+  def initialize(source_buffer); end
+
+  def diagnostics; end
+  def insert_after(range, content); end
+  def insert_after_multi(range, content); end
+  def insert_before(range, content); end
+  def insert_before_multi(range, content); end
+  def process; end
+  def remove(range); end
+  def replace(range, content); end
+  def source_buffer; end
+  def transaction; end
+  def wrap(range, before, after); end
+
+  private
+
+  def active_clobber; end
+  def active_clobber=(value); end
+  def active_insertions; end
+  def active_insertions=(value); end
+  def active_queue; end
+  def adjacent?(range1, range2); end
+  def adjacent_insertion_mask(range); end
+  def adjacent_insertions?(range); end
+  def adjacent_position_mask(range); end
+  def adjacent_updates?(range); end
+  def append(action); end
+  def can_merge?(action, existing); end
+  def clobbered_insertion?(insertion); end
+  def clobbered_position_mask(range); end
+  def in_transaction?; end
+  def merge_actions(action, existing); end
+  def merge_actions!(action, existing); end
+  def merge_replacements(actions); end
+  def raise_clobber_error(action, existing); end
+  def record_insertion(range); end
+  def record_replace(range); end
+  def replace_actions(old, updated); end
+  def replace_compatible_with_insertion?(replace, insertion); end
+end
+
+class Parser::Source::Rewriter::Action
+  include ::Comparable
+
+  def initialize(range, replacement = T.unsafe(nil), allow_multiple_insertions = T.unsafe(nil), order = T.unsafe(nil)); end
+
+  def <=>(other); end
+  def allow_multiple_insertions; end
+  def allow_multiple_insertions?; end
+  def order; end
+  def range; end
+  def replacement; end
+  def to_s; end
+end
+
+Parser::Source::Rewriter::DEPRECATION_WARNING = T.let(T.unsafe(nil), String)
+
+class Parser::Source::TreeRewriter
+  extend ::Parser::Deprecation
+
+  def initialize(source_buffer, crossing_deletions: T.unsafe(nil), different_replacements: T.unsafe(nil), swallowed_insertions: T.unsafe(nil)); end
+
+  def as_nested_actions; end
+  def as_replacements; end
+  def diagnostics; end
+  def empty?; end
+  def import!(foreign_rewriter, offset: T.unsafe(nil)); end
+  def in_transaction?; end
+  def insert_after(range, content); end
+  def insert_after_multi(range, text); end
+  def insert_before(range, content); end
+  def insert_before_multi(range, text); end
+  def merge(with); end
+  def merge!(with); end
+  def process; end
+  def remove(range); end
+  def replace(range, content); end
+  def source_buffer; end
+  def transaction; end
+  def wrap(range, insert_before, insert_after); end
+
+  protected
+
+  def action_root; end
+
+  private
+
+  def check_policy_validity; end
+  def check_range_validity(range); end
+  def combine(range, attributes); end
+  def enforce_policy(event); end
+  def trigger_policy(event, range: T.unsafe(nil), conflict: T.unsafe(nil), **arguments); end
+end
+
+Parser::Source::TreeRewriter::ACTIONS = T.let(T.unsafe(nil), Array)
+
+class Parser::Source::TreeRewriter::Action
+  def initialize(range, enforcer, insert_before: T.unsafe(nil), replacement: T.unsafe(nil), insert_after: T.unsafe(nil), children: T.unsafe(nil)); end
+
+  def combine(action); end
+  def contract; end
+  def empty?; end
+  def insert_after; end
+  def insert_before; end
+  def insertion?; end
+  def moved(source_buffer, offset); end
+  def nested_actions; end
+  def ordered_replacements; end
+  def range; end
+  def replacement; end
+
+  protected
+
+  def analyse_hierarchy(action); end
+  def bsearch_child_index(from = T.unsafe(nil)); end
+  def call_enforcer_for_merge(action); end
+  def check_fusible(action, *fusible); end
+  def children; end
+  def combine_children(more_children); end
+  def do_combine(action); end
+  def fuse_deletions(action, fusible, other_sibblings); end
+  def merge(action); end
+  def place_in_hierarchy(action); end
+  def swallow(children); end
+  def with(range: T.unsafe(nil), enforcer: T.unsafe(nil), children: T.unsafe(nil), insert_before: T.unsafe(nil), replacement: T.unsafe(nil), insert_after: T.unsafe(nil)); end
+end
+
+Parser::Source::TreeRewriter::DEPRECATION_WARNING = T.let(T.unsafe(nil), String)
+Parser::Source::TreeRewriter::POLICY_TO_LEVEL = T.let(T.unsafe(nil), Hash)
+
+class Parser::StaticEnvironment
+  def initialize; end
+
+  def declare(name); end
+  def declare_forward_args; end
+  def declared?(name); end
+  def declared_forward_args?; end
+  def extend_dynamic; end
+  def extend_static; end
+  def reset; end
+  def unextend; end
+end
+
+Parser::StaticEnvironment::FORWARD_ARGS = T.let(T.unsafe(nil), Symbol)
+
+class Parser::SyntaxError < ::StandardError
+  def initialize(diagnostic); end
+
+  def diagnostic; end
+end
+
+class Parser::TreeRewriter < ::Parser::AST::Processor
+  def assignment?(node); end
+  def insert_after(range, content); end
+  def insert_before(range, content); end
+  def remove(range); end
+  def replace(range, content); end
+  def rewrite(source_buffer, ast, **policy); end
+  def wrap(range, before, after); end
+end
+
+Parser::VERSION = T.let(T.unsafe(nil), String)
+
+class Parser::VariablesStack
+  def initialize; end
 
+  def declare(name); end
+  def declared?(name); end
+  def pop; end
+  def push; end
+  def reset; end
+end
diff --git a/sorbet/rbi/gems/procto@0.0.3.rbi b/sorbet/rbi/gems/procto@0.0.3.rbi
new file mode 100644
index 00000000..6319e949
--- /dev/null
+++ b/sorbet/rbi/gems/procto@0.0.3.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `procto` gem.
+# Please instead update this file by running `bin/tapioca gem procto`.
+
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires
diff --git a/sorbet/rbi/gems/pry-byebug@3.9.0.rbi b/sorbet/rbi/gems/pry-byebug@3.9.0.rbi
new file mode 100644
index 00000000..53539a3f
--- /dev/null
+++ b/sorbet/rbi/gems/pry-byebug@3.9.0.rbi
@@ -0,0 +1,461 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `pry-byebug` gem.
+# Please instead update this file by running `bin/tapioca gem pry-byebug`.
+
+module Byebug
+  include ::Byebug::Helpers::ReflectionHelper
+  extend ::Byebug::Helpers::ReflectionHelper
+  extend ::Byebug
+
+  def displays; end
+  def displays=(_arg0); end
+  def init_file; end
+  def init_file=(_arg0); end
+  def mode; end
+  def mode=(_arg0); end
+  def run_init_script; end
+
+  private
+
+  def add_catchpoint(_arg0); end
+  def breakpoints; end
+  def catchpoints; end
+  def contexts; end
+  def current_context; end
+  def debug_load(*_arg0); end
+  def lock; end
+  def post_mortem=(_arg0); end
+  def post_mortem?; end
+  def raised_exception; end
+  def rc_dirs; end
+  def run_rc_file(rc_file); end
+  def start; end
+  def started?; end
+  def stop; end
+  def stoppable?; end
+  def thread_context(_arg0); end
+  def tracing=(_arg0); end
+  def tracing?; end
+  def unlock; end
+  def verbose=(_arg0); end
+  def verbose?; end
+
+  class << self
+    def actual_control_port; end
+    def actual_port; end
+    def add_catchpoint(_arg0); end
+    def attach; end
+    def breakpoints; end
+    def catchpoints; end
+    def contexts; end
+    def current_context; end
+    def debug_load(*_arg0); end
+    def handle_post_mortem; end
+    def interrupt; end
+    def load_settings; end
+    def lock; end
+    def parse_host_and_port(host_port_spec); end
+    def post_mortem=(_arg0); end
+    def post_mortem?; end
+    def raised_exception; end
+    def spawn(host = T.unsafe(nil), port = T.unsafe(nil)); end
+    def start; end
+    def start_client(host = T.unsafe(nil), port = T.unsafe(nil)); end
+    def start_control(host = T.unsafe(nil), port = T.unsafe(nil)); end
+    def start_server(host = T.unsafe(nil), port = T.unsafe(nil)); end
+    def started?; end
+    def stop; end
+    def stoppable?; end
+    def thread_context(_arg0); end
+    def tracing=(_arg0); end
+    def tracing?; end
+    def unlock; end
+    def verbose=(_arg0); end
+    def verbose?; end
+    def wait_connection; end
+    def wait_connection=(_arg0); end
+
+    private
+
+    def client; end
+    def control; end
+    def server; end
+  end
+end
+
+class Byebug::DebugThread < ::Thread
+  class << self
+    def inherited; end
+  end
+end
+
+Byebug::PORT = T.let(T.unsafe(nil), Integer)
+
+class Byebug::PryProcessor < ::Byebug::CommandProcessor
+  def at_breakpoint(breakpoint); end
+  def at_end; end
+  def at_line; end
+  def at_return(_return_value); end
+  def bold(*args, &block); end
+  def output(*args, &block); end
+  def perform(action, options = T.unsafe(nil)); end
+  def pry; end
+  def pry=(_arg0); end
+  def run(&_block); end
+
+  private
+
+  def n_hits(breakpoint); end
+  def perform_backtrace(_options); end
+  def perform_down(options); end
+  def perform_finish(*_arg0); end
+  def perform_frame(options); end
+  def perform_next(options); end
+  def perform_step(options); end
+  def perform_up(options); end
+  def resume_pry; end
+
+  class << self
+    def start; end
+  end
+end
+
+class Byebug::ThreadsTable; end
+
+class Pry
+  extend ::Forwardable
+  extend ::Pry::Forwardable
+
+  def initialize(options = T.unsafe(nil)); end
+
+  def add_sticky_local(name, &block); end
+  def backtrace; end
+  def backtrace=(_arg0); end
+  def binding_stack; end
+  def binding_stack=(_arg0); end
+  def color(*args, &block); end
+  def color=(*args, &block); end
+  def commands(*args, &block); end
+  def commands=(*args, &block); end
+  def complete(str); end
+  def config; end
+  def current_binding; end
+  def current_context; end
+  def custom_completions; end
+  def custom_completions=(_arg0); end
+  def editor(*args, &block); end
+  def editor=(*args, &block); end
+  def eval(line, options = T.unsafe(nil)); end
+  def eval_string; end
+  def eval_string=(_arg0); end
+  def evaluate_ruby(code); end
+  def exception_handler(*args, &block); end
+  def exception_handler=(*args, &block); end
+  def exec_hook(name, *args, &block); end
+  def exit_value; end
+  def extra_sticky_locals(*args, &block); end
+  def extra_sticky_locals=(*args, &block); end
+  def hooks(*args, &block); end
+  def hooks=(*args, &block); end
+  def inject_local(name, value, binding); end
+  def inject_sticky_locals!; end
+  def input(*args, &block); end
+  def input=(*args, &block); end
+  def input_ring; end
+  def last_dir; end
+  def last_dir=(_arg0); end
+  def last_exception; end
+  def last_exception=(exception); end
+  def last_file; end
+  def last_file=(_arg0); end
+  def last_result; end
+  def last_result=(_arg0); end
+  def last_result_is_exception?; end
+  def memory_size; end
+  def memory_size=(size); end
+  def output; end
+  def output=(*args, &block); end
+  def output_ring; end
+  def pager; end
+  def pager=(*args, &block); end
+  def pop_prompt; end
+  def print(*args, &block); end
+  def print=(*args, &block); end
+  def process_command(val); end
+  def process_command_safely(val); end
+  def prompt; end
+  def prompt=(new_prompt); end
+  def push_binding(object); end
+  def push_initial_binding(target = T.unsafe(nil)); end
+  def push_prompt(new_prompt); end
+  def quiet?; end
+  def raise_up(*args); end
+  def raise_up!(*args); end
+  def raise_up_common(force, *args); end
+  def repl(target = T.unsafe(nil)); end
+  def reset_eval_string; end
+  def run_command(val); end
+  def select_prompt; end
+  def set_last_result(result, code = T.unsafe(nil)); end
+  def should_print?; end
+  def show_result(result); end
+  def sticky_locals; end
+  def suppress_output; end
+  def suppress_output=(_arg0); end
+  def update_input_history(code); end
+
+  private
+
+  def ensure_correct_encoding!(val); end
+  def generate_prompt(prompt_proc, conf); end
+  def handle_line(line, options); end
+  def prompt_stack; end
+
+  class << self
+    def Code(obj); end
+    def Method(obj); end
+    def WrappedModule(obj); end
+    def auto_resize!; end
+    def binding_for(target); end
+    def cli; end
+    def cli=(_arg0); end
+    def color(*args, &block); end
+    def color=(*args, &block); end
+    def commands(*args, &block); end
+    def commands=(*args, &block); end
+    def config; end
+    def config=(_arg0); end
+    def configure; end
+    def critical_section; end
+    def current; end
+    def current_line; end
+    def current_line=(_arg0); end
+    def custom_completions; end
+    def custom_completions=(_arg0); end
+    def editor(*args, &block); end
+    def editor=(*args, &block); end
+    def eval_path; end
+    def eval_path=(_arg0); end
+    def exception_handler(*args, &block); end
+    def exception_handler=(*args, &block); end
+    def extra_sticky_locals(*args, &block); end
+    def extra_sticky_locals=(*args, &block); end
+    def final_session_setup; end
+    def history(*args, &block); end
+    def history=(*args, &block); end
+    def hooks(*args, &block); end
+    def hooks=(*args, &block); end
+    def in_critical_section?; end
+    def init; end
+    def initial_session?; end
+    def initial_session_setup; end
+    def input(*args, &block); end
+    def input=(*args, &block); end
+    def last_internal_error; end
+    def last_internal_error=(_arg0); end
+    def line_buffer; end
+    def line_buffer=(_arg0); end
+    def load_file_at_toplevel(file); end
+    def load_file_through_repl(file_name); end
+    def load_history; end
+    def load_plugins(*args, &block); end
+    def load_rc_files; end
+    def load_requires; end
+    def load_traps; end
+    def load_win32console; end
+    def locate_plugins(*args, &block); end
+    def main; end
+    def memory_size(*args, &block); end
+    def memory_size=(*args, &block); end
+    def output(*args, &block); end
+    def output=(*args, &block); end
+    def pager(*args, &block); end
+    def pager=(*args, &block); end
+    def plugins(*args, &block); end
+    def print(*args, &block); end
+    def print=(*args, &block); end
+    def prompt(*args, &block); end
+    def prompt=(*args, &block); end
+    def quiet; end
+    def quiet=(_arg0); end
+    def rc_files_to_load; end
+    def real_path_to(file); end
+    def reset_defaults; end
+    def run_command(command_string, options = T.unsafe(nil)); end
+    def start(target = T.unsafe(nil), options = T.unsafe(nil)); end
+    def start_with_pry_byebug(target = T.unsafe(nil), options = T.unsafe(nil)); end
+    def start_without_pry_byebug(target = T.unsafe(nil), options = T.unsafe(nil)); end
+    def toplevel_binding; end
+    def toplevel_binding=(_arg0); end
+    def view_clip(obj, options = T.unsafe(nil)); end
+  end
+end
+
+Pry::BINDING_METHOD_IMPL = T.let(T.unsafe(nil), Array)
+module Pry::Byebug; end
+
+module Pry::Byebug::Breakpoints
+  extend ::Enumerable
+  extend ::Pry::Byebug::Breakpoints
+
+  def add_file(file, line, expression = T.unsafe(nil)); end
+  def add_method(method, expression = T.unsafe(nil)); end
+  def breakpoints; end
+  def change(id, expression = T.unsafe(nil)); end
+  def delete(id); end
+  def delete_all; end
+  def disable(id); end
+  def disable_all; end
+  def each(&block); end
+  def enable(id); end
+  def find_by_id(id); end
+  def last; end
+  def size; end
+  def to_a; end
+
+  private
+
+  def change_status(id, enabled = T.unsafe(nil)); end
+  def validate_expression(exp); end
+end
+
+class Pry::Byebug::Breakpoints::FileBreakpoint < ::SimpleDelegator
+  def source_code; end
+  def to_s; end
+end
+
+class Pry::Byebug::Breakpoints::MethodBreakpoint < ::SimpleDelegator
+  def initialize(byebug_bp, method); end
+
+  def source_code; end
+  def to_s; end
+end
+
+Pry::Commands = T.let(T.unsafe(nil), Pry::CommandSet)
+Pry::EMPTY_COMPLETIONS = T.let(T.unsafe(nil), Array)
+Pry::LOCAL_RC_FILE = T.let(T.unsafe(nil), String)
+Pry::VERSION = T.let(T.unsafe(nil), String)
+
+module PryByebug
+  def current_remote_server; end
+  def current_remote_server=(_arg0); end
+
+  private
+
+  def check_file_context(target, msg = T.unsafe(nil)); end
+  def file_context?(target); end
+
+  class << self
+    def check_file_context(target, msg = T.unsafe(nil)); end
+    def file_context?(target); end
+  end
+end
+
+class PryByebug::BacktraceCommand < ::Pry::ClassCommand
+  include ::PryByebug::Helpers::Navigation
+
+  def process; end
+end
+
+class PryByebug::BreakCommand < ::Pry::ClassCommand
+  include ::PryByebug::Helpers::Breakpoints
+  include ::PryByebug::Helpers::Location
+  include ::PryByebug::Helpers::Multiline
+
+  def options(opt); end
+  def process; end
+
+  private
+
+  def add_breakpoint(place, condition); end
+  def new_breakpoint; end
+  def option_to_method(option); end
+  def print_all; end
+  def process_condition; end
+  def process_delete; end
+  def process_delete_all; end
+  def process_disable; end
+  def process_disable_all; end
+  def process_enable; end
+  def process_show; end
+end
+
+class PryByebug::ContinueCommand < ::Pry::ClassCommand
+  include ::PryByebug::Helpers::Navigation
+  include ::PryByebug::Helpers::Breakpoints
+  include ::PryByebug::Helpers::Location
+
+  def process; end
+end
+
+class PryByebug::DownCommand < ::Pry::ClassCommand
+  include ::PryByebug::Helpers::Navigation
+
+  def process; end
+end
+
+class PryByebug::ExitAllCommand < ::Pry::Command::ExitAll
+  def process; end
+end
+
+class PryByebug::FinishCommand < ::Pry::ClassCommand
+  include ::PryByebug::Helpers::Navigation
+
+  def process; end
+end
+
+class PryByebug::FrameCommand < ::Pry::ClassCommand
+  include ::PryByebug::Helpers::Navigation
+
+  def process; end
+end
+
+module PryByebug::Helpers; end
+
+module PryByebug::Helpers::Breakpoints
+  def bold_puts(msg); end
+  def breakpoints; end
+  def max_width; end
+  def print_breakpoints_header; end
+  def print_full_breakpoint(breakpoint); end
+  def print_short_breakpoint(breakpoint); end
+end
+
+module PryByebug::Helpers::Location
+  private
+
+  def current_file(source = T.unsafe(nil)); end
+
+  class << self
+    def current_file(source = T.unsafe(nil)); end
+  end
+end
+
+module PryByebug::Helpers::Multiline
+  def check_multiline_context; end
+end
+
+module PryByebug::Helpers::Navigation
+  def breakout_navigation(action, options = T.unsafe(nil)); end
+end
+
+class PryByebug::NextCommand < ::Pry::ClassCommand
+  include ::PryByebug::Helpers::Navigation
+  include ::PryByebug::Helpers::Multiline
+
+  def process; end
+end
+
+class PryByebug::StepCommand < ::Pry::ClassCommand
+  include ::PryByebug::Helpers::Navigation
+
+  def process; end
+end
+
+class PryByebug::UpCommand < ::Pry::ClassCommand
+  include ::PryByebug::Helpers::Navigation
+
+  def process; end
+end
diff --git a/sorbet/rbi/gems/pry@0.13.1.rbi b/sorbet/rbi/gems/pry@0.13.1.rbi
index 5534cd94..61cc42c0 100644
--- a/sorbet/rbi/gems/pry@0.13.1.rbi
+++ b/sorbet/rbi/gems/pry@0.13.1.rbi
@@ -1,6 +1,2553 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca generate
-
 # typed: true
 
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `pry` gem.
+# Please instead update this file by running `bin/tapioca gem pry`.
+
+::RUBY19 = T.let(T.unsafe(nil), TrueClass)
+
+class BasicObject
+  def __binding__; end
+end
+
+class Object < ::BasicObject
+  include ::Kernel
+  include ::JSON::Ext::Generator::GeneratorMethods::Object
+  include ::PP::ObjectMixin
+
+  def __binding__; end
+  def pry(object = T.unsafe(nil), hash = T.unsafe(nil)); end
+end
+
+class Pry
+  extend ::Forwardable
+  extend ::Pry::Forwardable
+
+  def initialize(options = T.unsafe(nil)); end
+
+  def add_sticky_local(name, &block); end
+  def backtrace; end
+  def backtrace=(_arg0); end
+  def binding_stack; end
+  def binding_stack=(_arg0); end
+  def color(*args, &block); end
+  def color=(*args, &block); end
+  def commands(*args, &block); end
+  def commands=(*args, &block); end
+  def complete(str); end
+  def config; end
+  def current_binding; end
+  def current_context; end
+  def custom_completions; end
+  def custom_completions=(_arg0); end
+  def editor(*args, &block); end
+  def editor=(*args, &block); end
+  def eval(line, options = T.unsafe(nil)); end
+  def eval_string; end
+  def eval_string=(_arg0); end
+  def evaluate_ruby(code); end
+  def exception_handler(*args, &block); end
+  def exception_handler=(*args, &block); end
+  def exec_hook(name, *args, &block); end
+  def exit_value; end
+  def extra_sticky_locals(*args, &block); end
+  def extra_sticky_locals=(*args, &block); end
+  def hooks(*args, &block); end
+  def hooks=(*args, &block); end
+  def inject_local(name, value, binding); end
+  def inject_sticky_locals!; end
+  def input(*args, &block); end
+  def input=(*args, &block); end
+  def input_ring; end
+  def last_dir; end
+  def last_dir=(_arg0); end
+  def last_exception; end
+  def last_exception=(exception); end
+  def last_file; end
+  def last_file=(_arg0); end
+  def last_result; end
+  def last_result=(_arg0); end
+  def last_result_is_exception?; end
+  def memory_size; end
+  def memory_size=(size); end
+  def output; end
+  def output=(*args, &block); end
+  def output_ring; end
+  def pager; end
+  def pager=(*args, &block); end
+  def pop_prompt; end
+  def print(*args, &block); end
+  def print=(*args, &block); end
+  def process_command(val); end
+  def process_command_safely(val); end
+  def prompt; end
+  def prompt=(new_prompt); end
+  def push_binding(object); end
+  def push_initial_binding(target = T.unsafe(nil)); end
+  def push_prompt(new_prompt); end
+  def quiet?; end
+  def raise_up(*args); end
+  def raise_up!(*args); end
+  def raise_up_common(force, *args); end
+  def repl(target = T.unsafe(nil)); end
+  def reset_eval_string; end
+  def run_command(val); end
+  def select_prompt; end
+  def set_last_result(result, code = T.unsafe(nil)); end
+  def should_print?; end
+  def show_result(result); end
+  def sticky_locals; end
+  def suppress_output; end
+  def suppress_output=(_arg0); end
+  def update_input_history(code); end
+
+  private
+
+  def ensure_correct_encoding!(val); end
+  def generate_prompt(prompt_proc, conf); end
+  def handle_line(line, options); end
+  def prompt_stack; end
+
+  class << self
+    def Code(obj); end
+    def Method(obj); end
+    def WrappedModule(obj); end
+    def auto_resize!; end
+    def binding_for(target); end
+    def cli; end
+    def cli=(_arg0); end
+    def color(*args, &block); end
+    def color=(*args, &block); end
+    def commands(*args, &block); end
+    def commands=(*args, &block); end
+    def config; end
+    def config=(_arg0); end
+    def configure; end
+    def critical_section; end
+    def current; end
+    def current_line; end
+    def current_line=(_arg0); end
+    def custom_completions; end
+    def custom_completions=(_arg0); end
+    def editor(*args, &block); end
+    def editor=(*args, &block); end
+    def eval_path; end
+    def eval_path=(_arg0); end
+    def exception_handler(*args, &block); end
+    def exception_handler=(*args, &block); end
+    def extra_sticky_locals(*args, &block); end
+    def extra_sticky_locals=(*args, &block); end
+    def final_session_setup; end
+    def history(*args, &block); end
+    def history=(*args, &block); end
+    def hooks(*args, &block); end
+    def hooks=(*args, &block); end
+    def in_critical_section?; end
+    def init; end
+    def initial_session?; end
+    def initial_session_setup; end
+    def input(*args, &block); end
+    def input=(*args, &block); end
+    def last_internal_error; end
+    def last_internal_error=(_arg0); end
+    def line_buffer; end
+    def line_buffer=(_arg0); end
+    def load_file_at_toplevel(file); end
+    def load_file_through_repl(file_name); end
+    def load_history; end
+    def load_plugins(*args, &block); end
+    def load_rc_files; end
+    def load_requires; end
+    def load_traps; end
+    def load_win32console; end
+    def locate_plugins(*args, &block); end
+    def main; end
+    def memory_size(*args, &block); end
+    def memory_size=(*args, &block); end
+    def output(*args, &block); end
+    def output=(*args, &block); end
+    def pager(*args, &block); end
+    def pager=(*args, &block); end
+    def plugins(*args, &block); end
+    def print(*args, &block); end
+    def print=(*args, &block); end
+    def prompt(*args, &block); end
+    def prompt=(*args, &block); end
+    def quiet; end
+    def quiet=(_arg0); end
+    def rc_files_to_load; end
+    def real_path_to(file); end
+    def reset_defaults; end
+    def run_command(command_string, options = T.unsafe(nil)); end
+    def start(target = T.unsafe(nil), options = T.unsafe(nil)); end
+    def start_with_pry_byebug(target = T.unsafe(nil), options = T.unsafe(nil)); end
+    def start_without_pry_byebug(target = T.unsafe(nil), options = T.unsafe(nil)); end
+    def toplevel_binding; end
+    def toplevel_binding=(_arg0); end
+    def view_clip(obj, options = T.unsafe(nil)); end
+  end
+end
+
+Pry::BINDING_METHOD_IMPL = T.let(T.unsafe(nil), Array)
+
+class Pry::BasicObject < ::BasicObject
+  include ::Kernel
+end
+
+Pry::BasicObject::Dir = Dir
+Pry::BasicObject::ENV = T.let(T.unsafe(nil), Object)
+Pry::BasicObject::File = File
+Pry::BasicObject::Kernel = Kernel
+Pry::BasicObject::LoadError = LoadError
+Pry::BasicObject::Pry = Pry
+
+class Pry::BlockCommand < ::Pry::Command
+  def call(*args); end
+  def help; end
+end
+
+class Pry::CLI
+  class << self
+    def add_option_processor(&block); end
+    def add_options(&block); end
+    def add_plugin_options; end
+    def input_args; end
+    def input_args=(_arg0); end
+    def option_processors; end
+    def option_processors=(_arg0); end
+    def options; end
+    def options=(_arg0); end
+    def parse_options(args = T.unsafe(nil)); end
+    def reset; end
+    def start(opts); end
+  end
+end
+
+class Pry::CLI::NoOptionsError < ::StandardError; end
+
+class Pry::ClassCommand < ::Pry::Command
+  def args; end
+  def args=(_arg0); end
+  def call(*args); end
+  def complete(search); end
+  def help; end
+  def options(opt); end
+  def opts; end
+  def opts=(_arg0); end
+  def process; end
+  def setup; end
+  def slop; end
+  def subcommands(cmd); end
+
+  class << self
+    def doc; end
+    def file; end
+    def inherited(klass); end
+    def line; end
+    def source; end
+    def source_file; end
+    def source_line; end
+    def source_location; end
+
+    private
+
+    def source_object; end
+  end
+end
+
+class Pry::Code
+  extend ::MethodSource::CodeHelpers
+
+  def initialize(lines = T.unsafe(nil), start_line = T.unsafe(nil), code_type = T.unsafe(nil)); end
+
+  def <<(line); end
+  def ==(other); end
+  def after(lineno, lines = T.unsafe(nil)); end
+  def around(lineno, lines = T.unsafe(nil)); end
+  def before(lineno, lines = T.unsafe(nil)); end
+  def between(start_line, end_line = T.unsafe(nil)); end
+  def code_type; end
+  def code_type=(_arg0); end
+  def comment_describing(line_number); end
+  def expression_at(line_number, consume = T.unsafe(nil)); end
+  def grep(pattern); end
+  def highlighted; end
+  def length; end
+  def max_lineno_width; end
+  def method_missing(method_name, *args, &block); end
+  def nesting_at(line_number); end
+  def print_to_output(output, color = T.unsafe(nil)); end
+  def push(line); end
+  def raw; end
+  def reject(&block); end
+  def select(&block); end
+  def take_lines(start_line, num_lines); end
+  def to_s; end
+  def with_indentation(spaces = T.unsafe(nil)); end
+  def with_line_numbers(y_n = T.unsafe(nil)); end
+  def with_marker(lineno = T.unsafe(nil)); end
+
+  protected
+
+  def alter(&block); end
+
+  private
+
+  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
+
+  class << self
+    def from_file(filename, code_type = T.unsafe(nil)); end
+    def from_method(meth, start_line = T.unsafe(nil)); end
+    def from_module(mod, candidate_rank = T.unsafe(nil), start_line = T.unsafe(nil)); end
+  end
+end
+
+class Pry::Code::CodeRange
+  def initialize(start_line, end_line = T.unsafe(nil)); end
+
+  def indices_range(lines); end
+
+  private
+
+  def end_line; end
+  def find_end_index(lines); end
+  def find_start_index(lines); end
+  def force_set_end_line; end
+  def indices(lines); end
+  def set_end_line_from_range; end
+  def start_line; end
+end
+
+class Pry::Code::LOC
+  def initialize(line, lineno); end
+
+  def ==(other); end
+  def add_line_number(max_width = T.unsafe(nil), color = T.unsafe(nil)); end
+  def add_marker(marker_lineno); end
+  def colorize(code_type); end
+  def dup; end
+  def handle_multiline_entries_from_edit_command(line, max_width); end
+  def indent(distance); end
+  def line; end
+  def lineno; end
+  def tuple; end
+end
+
+class Pry::CodeFile
+  def initialize(filename, code_type = T.unsafe(nil)); end
+
+  def code; end
+  def code_type; end
+
+  private
+
+  def abs_path; end
+  def code_path; end
+  def from_load_path; end
+  def from_pry_init_pwd; end
+  def from_pwd; end
+  def readable?(path); end
+  def type_from_filename(filename, default = T.unsafe(nil)); end
+end
+
+Pry::CodeFile::DEFAULT_EXT = T.let(T.unsafe(nil), String)
+Pry::CodeFile::EXTENSIONS = T.let(T.unsafe(nil), Hash)
+Pry::CodeFile::FILES = T.let(T.unsafe(nil), Hash)
+Pry::CodeFile::INITIAL_PWD = T.let(T.unsafe(nil), String)
+
+class Pry::CodeObject
+  include ::Pry::Helpers::OptionsHelpers
+  include ::Pry::Helpers::CommandHelpers
+
+  def initialize(str, pry_instance, options = T.unsafe(nil)); end
+
+  def command_lookup; end
+  def default_lookup; end
+  def empty_lookup; end
+  def method_or_class_lookup; end
+  def pry_instance; end
+  def pry_instance=(_arg0); end
+  def str; end
+  def str=(_arg0); end
+  def super_level; end
+  def super_level=(_arg0); end
+  def target; end
+  def target=(_arg0); end
+
+  private
+
+  def looks_like_an_instance_method?(str); end
+  def lookup_super(obj, super_level); end
+  def safe_to_evaluate?(str); end
+  def sourcable_object?(obj); end
+  def target_self; end
+
+  class << self
+    def lookup(str, pry_instance, options = T.unsafe(nil)); end
+  end
+end
+
+module Pry::CodeObject::Helpers
+  def c_method?; end
+  def c_module?; end
+  def command?; end
+  def module_with_yard_docs?; end
+  def real_method_object?; end
+end
+
+class Pry::ColorPrinter < ::PP
+  def pp(object); end
+  def text(str, max_width = T.unsafe(nil)); end
+
+  private
+
+  def highlight_object_literal(object_literal); end
+  def inspect_object(object); end
+
+  class << self
+    def default(_output, value, pry_instance); end
+    def pp(obj, output = T.unsafe(nil), max_width = T.unsafe(nil)); end
+  end
+end
+
+class Pry::Command
+  include ::Pry::Helpers::BaseHelpers
+  include ::Pry::Helpers::OptionsHelpers
+  include ::Pry::Helpers::CommandHelpers
+  include ::Pry::Helpers::Text
+  extend ::Pry::Helpers::DocumentationHelpers
+  extend ::Pry::CodeObject::Helpers
+
+  def initialize(context = T.unsafe(nil)); end
+
+  def _pry_; end
+  def _pry_=(_arg0); end
+  def arg_string; end
+  def arg_string=(_arg0); end
+  def block; end
+  def captures; end
+  def captures=(_arg0); end
+  def check_for_command_collision(command_match, arg_string); end
+  def command_block; end
+  def command_block=(_arg0); end
+  def command_name; end
+  def command_options; end
+  def command_set; end
+  def command_set=(_arg0); end
+  def commands; end
+  def complete(_search); end
+  def context; end
+  def context=(_arg0); end
+  def description; end
+  def eval_string; end
+  def eval_string=(_arg0); end
+  def hooks; end
+  def hooks=(_arg0); end
+  def interpolate_string(str); end
+  def match; end
+  def name; end
+  def output; end
+  def output=(_arg0); end
+  def process_line(line); end
+  def pry_instance; end
+  def pry_instance=(_arg0); end
+  def run(command_string, *args); end
+  def source; end
+  def state; end
+  def target; end
+  def target=(_arg0); end
+  def target_self; end
+  def tokenize(val); end
+  def void; end
+
+  private
+
+  def after_hooks; end
+  def before_hooks; end
+  def call_safely(*args); end
+  def call_with_hooks(*args); end
+  def find_hooks(event); end
+  def normalize_method_args(method, args); end
+  def pass_block(arg_string); end
+  def use_unpatched_symbol; end
+
+  class << self
+    def banner(arg = T.unsafe(nil)); end
+    def block; end
+    def block=(_arg0); end
+    def command_name; end
+    def command_options(arg = T.unsafe(nil)); end
+    def command_options=(_arg0); end
+    def command_regex; end
+    def convert_to_regex(obj); end
+    def default_options(match); end
+    def description(arg = T.unsafe(nil)); end
+    def description=(_arg0); end
+    def doc; end
+    def file; end
+    def group(name = T.unsafe(nil)); end
+    def inspect; end
+    def line; end
+    def match(arg = T.unsafe(nil)); end
+    def match=(_arg0); end
+    def match_score(val); end
+    def matches?(val); end
+    def name; end
+    def options(arg = T.unsafe(nil)); end
+    def options=(_arg0); end
+    def source; end
+    def source_file; end
+    def source_line; end
+    def state; end
+    def subclass(match, description, options, helpers, &block); end
+  end
+end
+
+class Pry::Command::AmendLine < ::Pry::ClassCommand
+  def process; end
+
+  private
+
+  def amend_input; end
+  def delete_from_array(array, range); end
+  def insert_into_array(array, range); end
+  def line_count; end
+  def line_range; end
+  def replace_in_array(array, range); end
+  def start_and_end_line_number; end
+  def zero_indexed_range_from_one_indexed_numbers(start_line_number, end_line_number); end
+end
+
+class Pry::Command::Bang < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::BangPry < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::Cat < ::Pry::ClassCommand
+  def complete(search); end
+  def load_path_completions; end
+  def options(opt); end
+  def process; end
+end
+
+class Pry::Command::Cat::AbstractFormatter
+  include ::Pry::Helpers::OptionsHelpers
+  include ::Pry::Helpers::CommandHelpers
+  include ::Pry::Helpers::BaseHelpers
+
+  private
+
+  def between_lines; end
+  def code_type; end
+  def decorate(content); end
+  def use_line_numbers?; end
+end
+
+class Pry::Command::Cat::ExceptionFormatter < ::Pry::Command::Cat::AbstractFormatter
+  include ::Pry::Helpers::Text
+
+  def initialize(exception, pry_instance, opts); end
+
+  def ex; end
+  def format; end
+  def opts; end
+  def pry_instance; end
+
+  private
+
+  def backtrace_file; end
+  def backtrace_level; end
+  def backtrace_line; end
+  def check_for_errors; end
+  def code_window_size; end
+  def header; end
+  def increment_backtrace_level; end
+  def start_and_end_line_for_code_window; end
+end
+
+class Pry::Command::Cat::FileFormatter < ::Pry::Command::Cat::AbstractFormatter
+  def initialize(file_with_embedded_line, pry_instance, opts); end
+
+  def file_and_line; end
+  def file_with_embedded_line; end
+  def format; end
+  def opts; end
+  def pry_instance; end
+
+  private
+
+  def code_type; end
+  def code_window_size; end
+  def decorate(content); end
+  def detect_code_type_from_file(file_name); end
+  def file_name; end
+  def line_number; end
+end
+
+class Pry::Command::Cat::InputExpressionFormatter < ::Pry::Command::Cat::AbstractFormatter
+  def initialize(input_expressions, opts); end
+
+  def format; end
+  def input_expressions; end
+  def input_expressions=(_arg0); end
+  def opts; end
+  def opts=(_arg0); end
+
+  private
+
+  def normalized_expression_range; end
+  def numbered_input_items; end
+  def selected_input_items; end
+end
+
+class Pry::Command::Cd < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::ChangeInspector < ::Pry::ClassCommand
+  def process(inspector); end
+
+  private
+
+  def inspector_map; end
+end
+
+class Pry::Command::ChangePrompt < ::Pry::ClassCommand
+  def options(opt); end
+  def process(prompt); end
+
+  private
+
+  def change_prompt(prompt); end
+  def list_prompts; end
+end
+
+class Pry::Command::ClearScreen < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::CodeCollector
+  include ::Pry::Helpers::OptionsHelpers
+  include ::Pry::Helpers::CommandHelpers
+
+  def initialize(args, opts, pry_instance); end
+
+  def args; end
+  def code_object; end
+  def content; end
+  def file; end
+  def file=(_arg0); end
+  def line_range; end
+  def obj_name; end
+  def opts; end
+  def pry_input_content; end
+  def pry_instance; end
+  def pry_output_content; end
+  def restrict_to_lines(content, range); end
+
+  private
+
+  def bad_option_combination?; end
+  def code_object_doc; end
+  def code_object_source_or_file; end
+  def convert_to_range(range); end
+  def could_not_locate(name); end
+  def file_content; end
+  def pry_array_content_as_string(array, ranges); end
+
+  class << self
+    def inject_options(opt); end
+    def input_expression_ranges; end
+    def input_expression_ranges=(_arg0); end
+    def output_result_ranges; end
+    def output_result_ranges=(_arg0); end
+  end
+end
+
+class Pry::Command::DisablePry < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::Edit < ::Pry::ClassCommand
+  def apply_runtime_patch; end
+  def bad_option_combination?; end
+  def code_object; end
+  def ensure_file_name_is_valid(file_name); end
+  def file_and_line; end
+  def file_and_line_for_current_exception; end
+  def file_based_exception?; end
+  def file_edit; end
+  def filename_argument; end
+  def initial_temp_file_content; end
+  def input_expression; end
+  def never_reload?; end
+  def options(opt); end
+  def patch_exception?; end
+  def previously_patched?(code_object); end
+  def probably_a_file?(str); end
+  def process; end
+  def pry_method?(code_object); end
+  def reload?(file_name = T.unsafe(nil)); end
+  def reloadable?; end
+  def repl_edit; end
+  def repl_edit?; end
+  def runtime_patch?; end
+end
+
+class Pry::Command::Edit::ExceptionPatcher
+  def initialize(pry_instance, state, exception_file_and_line); end
+
+  def file_and_line; end
+  def file_and_line=(_arg0); end
+  def perform_patch; end
+  def pry_instance; end
+  def pry_instance=(_arg0); end
+  def state; end
+  def state=(_arg0); end
+end
+
+module Pry::Command::Edit::FileAndLineLocator
+  class << self
+    def from_binding(target); end
+    def from_code_object(code_object, filename_argument); end
+    def from_exception(exception, backtrace_level); end
+    def from_filename_argument(filename_argument); end
+  end
+end
+
+class Pry::Command::Exit < ::Pry::ClassCommand
+  def process; end
+  def process_pop_and_return; end
+end
+
+class Pry::Command::ExitAll < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::ExitProgram < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::FindMethod < ::Pry::ClassCommand
+  extend ::Pry::Helpers::BaseHelpers
+
+  def options(opt); end
+  def process; end
+
+  private
+
+  def additional_info(header, method); end
+  def content_search(namespace); end
+  def matched_method_lines(header, method); end
+  def name_search(namespace); end
+  def pattern; end
+  def print_matches(matches); end
+  def print_matches_for_class(klass, grouped); end
+  def recurse_namespace(klass, done = T.unsafe(nil), &block); end
+  def search_all_methods(namespace); end
+  def search_class; end
+  def show_search_results(matches); end
+end
+
+class Pry::Command::FixIndent < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::Help < ::Pry::ClassCommand
+  def command_groups; end
+  def display_command(command); end
+  def display_filtered_commands(search); end
+  def display_filtered_search_results(search); end
+  def display_index(groups); end
+  def display_search(search); end
+  def group_sort_key(group_name); end
+  def help_text_for_commands(name, commands); end
+  def normalize(key); end
+  def process; end
+  def search_hash(search, hash); end
+  def sorted_commands(commands); end
+  def sorted_group_names(groups); end
+  def visible_commands; end
+end
+
+class Pry::Command::Hist < ::Pry::ClassCommand
+  def options(opt); end
+  def process; end
+
+  private
+
+  def check_for_juxtaposed_replay(replay_sequence); end
+  def find_history; end
+  def process_clear; end
+  def process_display; end
+  def process_replay; end
+  def process_save; end
+end
+
+class Pry::Command::ImportSet < ::Pry::ClassCommand
+  def process(_command_set_name); end
+end
+
+class Pry::Command::JumpTo < ::Pry::ClassCommand
+  def process(break_level); end
+end
+
+class Pry::Command::ListInspectors < ::Pry::ClassCommand
+  def process; end
+
+  private
+
+  def inspector_map; end
+  def selected_inspector?(inspector); end
+  def selected_text; end
+end
+
+class Pry::Command::Ls < ::Pry::ClassCommand
+  def no_user_opts?; end
+  def options(opt); end
+  def process; end
+
+  private
+
+  def error_list; end
+  def raise_errors_if_arguments_are_weird; end
+end
+
+class Pry::Command::Ls::Constants < ::Pry::Command::Ls::Formatter
+  include ::Pry::Command::Ls::Interrogatable
+
+  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
+
+  def correct_opts?; end
+  def output_self; end
+
+  private
+
+  def format(mod, constants); end
+  def show_deprecated_constants?; end
+end
+
+Pry::Command::Ls::Constants::DEPRECATED_CONSTANTS = T.let(T.unsafe(nil), Array)
+Pry::Command::Ls::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+
+class Pry::Command::Ls::Formatter
+  def initialize(pry_instance); end
+
+  def grep=(_arg0); end
+  def pry_instance; end
+  def write_out; end
+
+  private
+
+  def color(type, str); end
+  def correct_opts?; end
+  def format_value(value); end
+  def grep; end
+  def output_section(heading, body); end
+  def output_self; end
+end
+
+class Pry::Command::Ls::Globals < ::Pry::Command::Ls::Formatter
+  def initialize(opts, pry_instance); end
+
+  def output_self; end
+
+  private
+
+  def format(globals); end
+end
+
+Pry::Command::Ls::Globals::BUILTIN_GLOBALS = T.let(T.unsafe(nil), Array)
+Pry::Command::Ls::Globals::PSEUDO_GLOBALS = T.let(T.unsafe(nil), Array)
+
+class Pry::Command::Ls::Grep
+  def initialize(grep_regexp); end
+
+  def regexp; end
+end
+
+class Pry::Command::Ls::InstanceVars < ::Pry::Command::Ls::Formatter
+  include ::Pry::Command::Ls::Interrogatable
+
+  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
+
+  def correct_opts?; end
+  def output_self; end
+
+  private
+
+  def format(type, vars); end
+end
+
+module Pry::Command::Ls::Interrogatable
+  private
+
+  def interrogatee_mod; end
+  def interrogating_a_module?; end
+end
+
+module Pry::Command::Ls::JRubyHacks
+  private
+
+  def rubbishness(name); end
+  def trim_jruby_aliases(methods); end
+end
+
+class Pry::Command::Ls::LocalNames < ::Pry::Command::Ls::Formatter
+  def initialize(no_user_opts, args, pry_instance); end
+
+  def correct_opts?; end
+  def output_self; end
+
+  private
+
+  def format(locals); end
+end
+
+class Pry::Command::Ls::LocalVars < ::Pry::Command::Ls::Formatter
+  def initialize(opts, pry_instance); end
+
+  def output_self; end
+
+  private
+
+  def colorized_assignment_style(lhs, rhs, desired_width = T.unsafe(nil)); end
+  def format(name_value_pairs); end
+end
+
+class Pry::Command::Ls::LsEntity
+  def initialize(opts); end
+
+  def entities_table; end
+  def pry_instance; end
+
+  private
+
+  def constants; end
+  def entities; end
+  def globals; end
+  def grep(entity); end
+  def instance_vars; end
+  def local_names; end
+  def local_vars; end
+  def methods; end
+  def self_methods; end
+end
+
+class Pry::Command::Ls::Methods < ::Pry::Command::Ls::Formatter
+  include ::Pry::Command::Ls::Interrogatable
+  include ::Pry::Command::Ls::JRubyHacks
+  include ::Pry::Command::Ls::MethodsHelper
+
+  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
+
+  def output_self; end
+
+  private
+
+  def below_ceiling; end
+  def correct_opts?; end
+end
+
+module Pry::Command::Ls::MethodsHelper
+  include ::Pry::Command::Ls::JRubyHacks
+
+  private
+
+  def all_methods(instance_methods = T.unsafe(nil)); end
+  def format(methods); end
+  def resolution_order; end
+end
+
+class Pry::Command::Ls::SelfMethods < ::Pry::Command::Ls::Formatter
+  include ::Pry::Command::Ls::Interrogatable
+  include ::Pry::Command::Ls::JRubyHacks
+  include ::Pry::Command::Ls::MethodsHelper
+
+  def initialize(interrogatee, no_user_opts, opts, pry_instance); end
+
+  def output_self; end
+
+  private
+
+  def correct_opts?; end
+end
+
+class Pry::Command::Nesting < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::Play < ::Pry::ClassCommand
+  def code_object; end
+  def content; end
+  def content_after_options; end
+  def content_at_expression; end
+  def default_file; end
+  def file_content; end
+  def options(opt); end
+  def perform_play; end
+  def process; end
+  def should_use_default_file?; end
+  def show_input; end
+end
+
+class Pry::Command::PryBacktrace < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::RaiseUp < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::ReloadCode < ::Pry::ClassCommand
+  def process; end
+
+  private
+
+  def check_for_reloadability(code_object, identifier); end
+  def current_file; end
+  def reload_current_file; end
+  def reload_object(identifier); end
+end
+
+class Pry::Command::Reset < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::Ri < ::Pry::ClassCommand
+  def process(spec); end
+end
+
+class Pry::Command::SaveFile < ::Pry::ClassCommand
+  def display_content; end
+  def file_name; end
+  def mode; end
+  def options(opt); end
+  def process; end
+  def save_file; end
+end
+
+class Pry::Command::ShellCommand < ::Pry::ClassCommand
+  def process(cmd); end
+
+  private
+
+  def cd_path_env; end
+  def cd_path_exists?; end
+  def parse_destination(dest); end
+  def path_from_cd_path(dest); end
+  def process_cd(dest); end
+  def special_case_path?(dest); end
+end
+
+class Pry::Command::ShellMode < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::ShowDoc < ::Pry::Command::ShowInfo
+  include ::Pry::Helpers::DocumentationHelpers
+
+  def content_for(code_object); end
+  def docs_for(code_object); end
+  def header_options; end
+  def process; end
+  def render_doc_markup_for(code_object); end
+  def start_line_for(code_object); end
+end
+
+class Pry::Command::ShowInfo < ::Pry::ClassCommand
+  extend ::Pry::Helpers::BaseHelpers
+
+  def initialize(*_arg0); end
+
+  def code_object_header(code_object, line_num); end
+  def code_object_with_accessible_source(code_object); end
+  def complete(input); end
+  def content_and_header_for_code_object(code_object); end
+  def content_and_headers_for_all_module_candidates(mod); end
+  def file_and_line_for(code_object); end
+  def header(code_object); end
+  def header_options; end
+  def method_header(code_object, line_num); end
+  def method_sections(code_object); end
+  def module_header(code_object, line_num); end
+  def no_definition_message; end
+  def obj_name; end
+  def options(opt); end
+  def process; end
+  def show_all_modules?(code_object); end
+  def start_line_for(code_object); end
+  def use_line_numbers?; end
+  def valid_superclass?(code_object); end
+end
+
+class Pry::Command::ShowInput < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::ShowSource < ::Pry::Command::ShowInfo
+  include ::Pry::Helpers::DocumentationHelpers
+
+  def content_for(code_object); end
+  def docs_for(code_object); end
+  def header_options; end
+  def options(opt); end
+  def process; end
+  def render_doc_markup_for(code_object); end
+  def start_line_for(code_object); end
+end
+
+class Pry::Command::Stat < ::Pry::ClassCommand
+  def options(opt); end
+  def process; end
+end
+
+class Pry::Command::SwitchTo < ::Pry::ClassCommand
+  def process(selection); end
+end
+
+class Pry::Command::ToggleColor < ::Pry::ClassCommand
+  def color_toggle; end
+  def process; end
+end
+
+Pry::Command::VOID_VALUE = T.let(T.unsafe(nil), Object)
+
+class Pry::Command::Version < ::Pry::ClassCommand
+  def process; end
+end
+
+class Pry::Command::WatchExpression < ::Pry::ClassCommand
+  def options(opt); end
+  def process; end
+
+  private
+
+  def add_expression(_arguments); end
+  def add_hook; end
+  def delete(index); end
+  def eval_and_print_changed(output); end
+  def expressions; end
+  def list; end
+end
+
+class Pry::Command::WatchExpression::Expression
+  def initialize(pry_instance, target, source); end
+
+  def changed?; end
+  def eval!; end
+  def previous_value; end
+  def pry_instance; end
+  def source; end
+  def target; end
+  def to_s; end
+  def value; end
+
+  private
+
+  def target_eval(target, source); end
+end
+
+class Pry::Command::Whereami < ::Pry::ClassCommand
+  def initialize(*_arg0); end
+
+  def bad_option_combination?; end
+  def code; end
+  def code?; end
+  def location; end
+  def options(opt); end
+  def process; end
+  def setup; end
+
+  private
+
+  def class_code; end
+  def code_window; end
+  def default_code; end
+  def expand_path(filename); end
+  def handle_internal_binding; end
+  def marker; end
+  def method_code; end
+  def nothing_to_do?; end
+  def small_method?; end
+  def target_class; end
+  def top_level?; end
+  def use_line_numbers?; end
+  def valid_method?; end
+  def window_size; end
+
+  class << self
+    def method_size_cutoff; end
+    def method_size_cutoff=(_arg0); end
+  end
+end
+
+class Pry::Command::Wtf < ::Pry::ClassCommand
+  def options(opt); end
+  def process; end
+
+  private
+
+  def format_backtrace(backtrace); end
+  def format_header(title, exception); end
+  def read_line(file, line); end
+  def trim_backtrace(backtrace); end
+  def unwind_exceptions; end
+end
+
+Pry::Command::Wtf::RUBY_FRAME_PATTERN = T.let(T.unsafe(nil), Regexp)
+class Pry::CommandError < ::StandardError; end
+
+class Pry::CommandSet
+  include ::Enumerable
+  include ::Pry::Helpers::BaseHelpers
+
+  def initialize(*imported_sets, &block); end
+
+  def [](pattern); end
+  def []=(pattern, command); end
+  def add_command(command); end
+  def alias_command(match, action, options = T.unsafe(nil)); end
+  def block_command(match, description = T.unsafe(nil), options = T.unsafe(nil), &block); end
+  def command(match, description = T.unsafe(nil), options = T.unsafe(nil), &block); end
+  def complete(search, context = T.unsafe(nil)); end
+  def create_command(match, description = T.unsafe(nil), options = T.unsafe(nil), &block); end
+  def delete(*searches); end
+  def desc(search, description = T.unsafe(nil)); end
+  def each(&block); end
+  def find_command(pattern); end
+  def find_command_by_match_or_listing(match_or_listing); end
+  def find_command_for_help(search); end
+  def helper_module; end
+  def import(*sets); end
+  def import_from(set, *matches); end
+  def keys; end
+  def list_commands; end
+  def process_line(val, context = T.unsafe(nil)); end
+  def rename_command(new_match, search, options = T.unsafe(nil)); end
+  def to_h; end
+  def to_hash; end
+  def valid_command?(val); end
+
+  private
+
+  def helpers(&block); end
+end
+
+class Pry::CommandState
+  def initialize; end
+
+  def reset(command_name); end
+  def state_for(command_name); end
+
+  class << self
+    def default; end
+  end
+end
+
+Pry::Commands = T.let(T.unsafe(nil), Pry::CommandSet)
+
+class Pry::Config
+  extend ::Pry::Config::Attributable
+
+  def initialize; end
+
+  def [](attr); end
+  def []=(attr, value); end
+  def auto_indent; end
+  def auto_indent=(_arg0); end
+  def collision_warning; end
+  def collision_warning=(_arg0); end
+  def color; end
+  def color=(_arg0); end
+  def command_completions; end
+  def command_completions=(_arg0); end
+  def command_prefix; end
+  def command_prefix=(_arg0); end
+  def commands; end
+  def commands=(_arg0); end
+  def completer; end
+  def completer=(_arg0); end
+  def control_d_handler; end
+  def control_d_handler=(value); end
+  def correct_indent; end
+  def correct_indent=(_arg0); end
+  def default_window_size; end
+  def default_window_size=(_arg0); end
+  def disable_auto_reload; end
+  def disable_auto_reload=(_arg0); end
+  def editor; end
+  def editor=(_arg0); end
+  def exception_handler; end
+  def exception_handler=(_arg0); end
+  def exception_whitelist; end
+  def exception_whitelist=(_arg0); end
+  def exec_string; end
+  def exec_string=(_arg0); end
+  def extra_sticky_locals; end
+  def extra_sticky_locals=(_arg0); end
+  def file_completions; end
+  def file_completions=(_arg0); end
+  def history; end
+  def history=(_arg0); end
+  def history_file; end
+  def history_file=(_arg0); end
+  def history_ignorelist; end
+  def history_ignorelist=(_arg0); end
+  def history_load; end
+  def history_load=(_arg0); end
+  def history_save; end
+  def history_save=(_arg0); end
+  def hooks; end
+  def hooks=(_arg0); end
+  def input; end
+  def input=(_arg0); end
+  def ls; end
+  def ls=(_arg0); end
+  def memory_size; end
+  def memory_size=(_arg0); end
+  def merge(config_hash); end
+  def merge!(config_hash); end
+  def method_missing(method_name, *args, &_block); end
+  def output; end
+  def output=(_arg0); end
+  def output_prefix; end
+  def output_prefix=(_arg0); end
+  def pager; end
+  def pager=(_arg0); end
+  def print; end
+  def print=(_arg0); end
+  def prompt; end
+  def prompt=(_arg0); end
+  def prompt_name; end
+  def prompt_name=(_arg0); end
+  def prompt_safe_contexts; end
+  def prompt_safe_contexts=(_arg0); end
+  def quiet; end
+  def quiet=(_arg0); end
+  def rc_file; end
+  def rc_file=(_arg0); end
+  def requires; end
+  def requires=(_arg0); end
+  def should_load_local_rc; end
+  def should_load_local_rc=(_arg0); end
+  def should_load_plugins; end
+  def should_load_plugins=(_arg0); end
+  def should_load_rc; end
+  def should_load_rc=(_arg0); end
+  def should_load_requires; end
+  def should_load_requires=(_arg0); end
+  def should_trap_interrupts; end
+  def should_trap_interrupts=(_arg0); end
+  def system; end
+  def system=(_arg0); end
+  def unrescued_exceptions; end
+  def unrescued_exceptions=(_arg0); end
+  def windows_console_warning; end
+  def windows_console_warning=(_arg0); end
+
+  private
+
+  def default_rc_file; end
+  def initialize_dup(other); end
+  def lazy_readline; end
+  def respond_to_missing?(method_name, include_all = T.unsafe(nil)); end
+end
+
+module Pry::Config::Attributable
+  def attribute(attr_name); end
+end
+
+class Pry::Config::LazyValue
+  def initialize(&block); end
+
+  def call; end
+end
+
+class Pry::Config::MemoizedValue
+  def initialize(&block); end
+
+  def call; end
+end
+
+class Pry::Config::Value
+  def initialize(value); end
+
+  def call; end
+end
+
+module Pry::ControlDHandler
+  class << self
+    def default(pry_instance); end
+  end
+end
+
+Pry::EMPTY_COMPLETIONS = T.let(T.unsafe(nil), Array)
+
+class Pry::Editor
+  include ::Pry::Helpers::OptionsHelpers
+  include ::Pry::Helpers::CommandHelpers
+
+  def initialize(pry_instance); end
+
+  def build_editor_invocation_string(file, line, blocking); end
+  def edit_tempfile_with_content(initial_content, line = T.unsafe(nil)); end
+  def invoke_editor(file, line, blocking = T.unsafe(nil)); end
+  def pry_instance; end
+
+  private
+
+  def blocking_flag_for_editor(blocking); end
+  def editor_name; end
+  def open_editor(editor_invocation); end
+  def open_editor_on_jruby(editor_invocation); end
+  def start_line_syntax_for_editor(file_name, line_number); end
+
+  class << self
+    def default; end
+  end
+end
+
+module Pry::Env
+  class << self
+    def [](key); end
+  end
+end
+
+module Pry::ExceptionHandler
+  class << self
+    def handle_exception(output, exception, _pry_instance); end
+
+    private
+
+    def cause_text(cause); end
+    def exception_text(exception); end
+    def standard_error_text_for(exception); end
+  end
+end
+
+module Pry::Forwardable
+  include ::Forwardable
+
+  def def_private_delegators(target, *private_delegates); end
+end
+
+module Pry::FrozenObjectException
+  class << self
+    def ===(exception); end
+  end
+end
+
+module Pry::Helpers
+  class << self
+    def tablify(things, line_length, pry_instance = T.unsafe(nil)); end
+    def tablify_or_one_line(heading, things, pry_instance = T.unsafe(nil)); end
+    def tablify_to_screen_width(things, options, pry_instance = T.unsafe(nil)); end
+  end
+end
+
+module Pry::Helpers::BaseHelpers
+  extend ::Pry::Helpers::BaseHelpers
+
+  def colorize_code(code); end
+  def find_command(name, set = T.unsafe(nil)); end
+  def heading(text); end
+  def highlight(string, regexp, highlight_color = T.unsafe(nil)); end
+  def not_a_real_file?(file); end
+  def safe_send(obj, method, *args, &block); end
+  def silence_warnings; end
+  def stagger_output(text, _out = T.unsafe(nil)); end
+  def use_ansi_codes?; end
+end
+
+module Pry::Helpers::CommandHelpers
+  include ::Pry::Helpers::OptionsHelpers
+  extend ::Pry::Helpers::OptionsHelpers
+  extend ::Pry::Helpers::CommandHelpers
+
+  def absolute_index_number(line_number, array_length); end
+  def absolute_index_range(range_or_number, array_length); end
+  def get_method_or_raise(method_name, context, opts = T.unsafe(nil)); end
+  def internal_binding?(context); end
+  def one_index_number(line_number); end
+  def one_index_range(range); end
+  def one_index_range_or_number(range_or_number); end
+  def restrict_to_lines(content, lines); end
+  def set_file_and_dir_locals(file_name, pry = T.unsafe(nil), ctx = T.unsafe(nil)); end
+  def temp_file(ext = T.unsafe(nil)); end
+  def unindent(dirty_text, left_padding = T.unsafe(nil)); end
+end
+
+module Pry::Helpers::DocumentationHelpers
+  private
+
+  def get_comment_content(comment); end
+  def process_comment_markup(comment); end
+  def process_rdoc(comment); end
+  def process_yardoc(comment); end
+  def process_yardoc_tag(comment, tag); end
+  def strip_comments_from_c_code(code); end
+  def strip_leading_whitespace(text); end
+
+  class << self
+    def get_comment_content(comment); end
+    def process_comment_markup(comment); end
+    def process_rdoc(comment); end
+    def process_yardoc(comment); end
+    def process_yardoc_tag(comment, tag); end
+    def strip_comments_from_c_code(code); end
+    def strip_leading_whitespace(text); end
+  end
+end
+
+Pry::Helpers::DocumentationHelpers::YARD_TAGS = T.let(T.unsafe(nil), Array)
+
+module Pry::Helpers::OptionsHelpers
+  private
+
+  def method_object; end
+  def method_options(opt); end
+
+  class << self
+    def method_object; end
+    def method_options(opt); end
+  end
+end
+
+module Pry::Helpers::Platform
+  class << self
+    def jruby?; end
+    def jruby_19?; end
+    def linux?; end
+    def mac_osx?; end
+    def mri?; end
+    def mri_19?; end
+    def mri_2?; end
+    def windows?; end
+    def windows_ansi?; end
+  end
+end
+
+class Pry::Helpers::Table
+  def initialize(items, args, pry_instance = T.unsafe(nil)); end
+
+  def ==(other); end
+  def column_count; end
+  def column_count=(count); end
+  def columns; end
+  def fits_on_line?(line_length); end
+  def items; end
+  def items=(items); end
+  def rows_to_s(style = T.unsafe(nil)); end
+  def to_a; end
+  def to_s; end
+
+  private
+
+  def _max_width(things); end
+  def _rebuild_colorless_cache; end
+  def _recall_color_for(thing); end
+  def _recolumn; end
+end
+
+module Pry::Helpers::Text
+  extend ::Pry::Helpers::Text
+
+  def black(text); end
+  def black_on_black(text); end
+  def black_on_blue(text); end
+  def black_on_cyan(text); end
+  def black_on_green(text); end
+  def black_on_magenta(text); end
+  def black_on_purple(text); end
+  def black_on_red(text); end
+  def black_on_white(text); end
+  def black_on_yellow(text); end
+  def blue(text); end
+  def blue_on_black(text); end
+  def blue_on_blue(text); end
+  def blue_on_cyan(text); end
+  def blue_on_green(text); end
+  def blue_on_magenta(text); end
+  def blue_on_purple(text); end
+  def blue_on_red(text); end
+  def blue_on_white(text); end
+  def blue_on_yellow(text); end
+  def bold(text); end
+  def bright_black(text); end
+  def bright_black_on_black(text); end
+  def bright_black_on_blue(text); end
+  def bright_black_on_cyan(text); end
+  def bright_black_on_green(text); end
+  def bright_black_on_magenta(text); end
+  def bright_black_on_purple(text); end
+  def bright_black_on_red(text); end
+  def bright_black_on_white(text); end
+  def bright_black_on_yellow(text); end
+  def bright_blue(text); end
+  def bright_blue_on_black(text); end
+  def bright_blue_on_blue(text); end
+  def bright_blue_on_cyan(text); end
+  def bright_blue_on_green(text); end
+  def bright_blue_on_magenta(text); end
+  def bright_blue_on_purple(text); end
+  def bright_blue_on_red(text); end
+  def bright_blue_on_white(text); end
+  def bright_blue_on_yellow(text); end
+  def bright_cyan(text); end
+  def bright_cyan_on_black(text); end
+  def bright_cyan_on_blue(text); end
+  def bright_cyan_on_cyan(text); end
+  def bright_cyan_on_green(text); end
+  def bright_cyan_on_magenta(text); end
+  def bright_cyan_on_purple(text); end
+  def bright_cyan_on_red(text); end
+  def bright_cyan_on_white(text); end
+  def bright_cyan_on_yellow(text); end
+  def bright_green(text); end
+  def bright_green_on_black(text); end
+  def bright_green_on_blue(text); end
+  def bright_green_on_cyan(text); end
+  def bright_green_on_green(text); end
+  def bright_green_on_magenta(text); end
+  def bright_green_on_purple(text); end
+  def bright_green_on_red(text); end
+  def bright_green_on_white(text); end
+  def bright_green_on_yellow(text); end
+  def bright_magenta(text); end
+  def bright_magenta_on_black(text); end
+  def bright_magenta_on_blue(text); end
+  def bright_magenta_on_cyan(text); end
+  def bright_magenta_on_green(text); end
+  def bright_magenta_on_magenta(text); end
+  def bright_magenta_on_purple(text); end
+  def bright_magenta_on_red(text); end
+  def bright_magenta_on_white(text); end
+  def bright_magenta_on_yellow(text); end
+  def bright_purple(text); end
+  def bright_purple_on_black(text); end
+  def bright_purple_on_blue(text); end
+  def bright_purple_on_cyan(text); end
+  def bright_purple_on_green(text); end
+  def bright_purple_on_magenta(text); end
+  def bright_purple_on_purple(text); end
+  def bright_purple_on_red(text); end
+  def bright_purple_on_white(text); end
+  def bright_purple_on_yellow(text); end
+  def bright_red(text); end
+  def bright_red_on_black(text); end
+  def bright_red_on_blue(text); end
+  def bright_red_on_cyan(text); end
+  def bright_red_on_green(text); end
+  def bright_red_on_magenta(text); end
+  def bright_red_on_purple(text); end
+  def bright_red_on_red(text); end
+  def bright_red_on_white(text); end
+  def bright_red_on_yellow(text); end
+  def bright_white(text); end
+  def bright_white_on_black(text); end
+  def bright_white_on_blue(text); end
+  def bright_white_on_cyan(text); end
+  def bright_white_on_green(text); end
+  def bright_white_on_magenta(text); end
+  def bright_white_on_purple(text); end
+  def bright_white_on_red(text); end
+  def bright_white_on_white(text); end
+  def bright_white_on_yellow(text); end
+  def bright_yellow(text); end
+  def bright_yellow_on_black(text); end
+  def bright_yellow_on_blue(text); end
+  def bright_yellow_on_cyan(text); end
+  def bright_yellow_on_green(text); end
+  def bright_yellow_on_magenta(text); end
+  def bright_yellow_on_purple(text); end
+  def bright_yellow_on_red(text); end
+  def bright_yellow_on_white(text); end
+  def bright_yellow_on_yellow(text); end
+  def cyan(text); end
+  def cyan_on_black(text); end
+  def cyan_on_blue(text); end
+  def cyan_on_cyan(text); end
+  def cyan_on_green(text); end
+  def cyan_on_magenta(text); end
+  def cyan_on_purple(text); end
+  def cyan_on_red(text); end
+  def cyan_on_white(text); end
+  def cyan_on_yellow(text); end
+  def default(text); end
+  def green(text); end
+  def green_on_black(text); end
+  def green_on_blue(text); end
+  def green_on_cyan(text); end
+  def green_on_green(text); end
+  def green_on_magenta(text); end
+  def green_on_purple(text); end
+  def green_on_red(text); end
+  def green_on_white(text); end
+  def green_on_yellow(text); end
+  def indent(text, chars); end
+  def magenta(text); end
+  def magenta_on_black(text); end
+  def magenta_on_blue(text); end
+  def magenta_on_cyan(text); end
+  def magenta_on_green(text); end
+  def magenta_on_magenta(text); end
+  def magenta_on_purple(text); end
+  def magenta_on_red(text); end
+  def magenta_on_white(text); end
+  def magenta_on_yellow(text); end
+  def no_color; end
+  def no_pager; end
+  def purple(text); end
+  def purple_on_black(text); end
+  def purple_on_blue(text); end
+  def purple_on_cyan(text); end
+  def purple_on_green(text); end
+  def purple_on_magenta(text); end
+  def purple_on_purple(text); end
+  def purple_on_red(text); end
+  def purple_on_white(text); end
+  def purple_on_yellow(text); end
+  def red(text); end
+  def red_on_black(text); end
+  def red_on_blue(text); end
+  def red_on_cyan(text); end
+  def red_on_green(text); end
+  def red_on_magenta(text); end
+  def red_on_purple(text); end
+  def red_on_red(text); end
+  def red_on_white(text); end
+  def red_on_yellow(text); end
+  def strip_color(text); end
+  def white(text); end
+  def white_on_black(text); end
+  def white_on_blue(text); end
+  def white_on_cyan(text); end
+  def white_on_green(text); end
+  def white_on_magenta(text); end
+  def white_on_purple(text); end
+  def white_on_red(text); end
+  def white_on_white(text); end
+  def white_on_yellow(text); end
+  def with_line_numbers(text, offset, color = T.unsafe(nil)); end
+  def yellow(text); end
+  def yellow_on_black(text); end
+  def yellow_on_blue(text); end
+  def yellow_on_cyan(text); end
+  def yellow_on_green(text); end
+  def yellow_on_magenta(text); end
+  def yellow_on_purple(text); end
+  def yellow_on_red(text); end
+  def yellow_on_white(text); end
+  def yellow_on_yellow(text); end
+end
+
+Pry::Helpers::Text::COLORS = T.let(T.unsafe(nil), Hash)
+
+class Pry::History
+  def initialize(options = T.unsafe(nil)); end
+
+  def <<(line); end
+  def clear; end
+  def filter(history); end
+  def history_line_count; end
+  def load; end
+  def loader; end
+  def loader=(_arg0); end
+  def original_lines; end
+  def push(line); end
+  def saver; end
+  def saver=(_arg0); end
+  def session_line_count; end
+  def to_a; end
+
+  private
+
+  def history_file; end
+  def history_file_path; end
+  def invalid_readline_line?(line); end
+  def read_from_file; end
+  def save_to_file(line); end
+  def should_ignore?(line); end
+
+  class << self
+    def default_file; end
+  end
+end
+
+class Pry::Hooks
+  def initialize; end
+
+  def add_hook(event_name, hook_name, callable = T.unsafe(nil), &block); end
+  def clear_event_hooks(event_name); end
+  def delete_hook(event_name, hook_name); end
+  def errors; end
+  def exec_hook(event_name, *args, &block); end
+  def get_hook(event_name, hook_name); end
+  def get_hooks(event_name); end
+  def hook_count(event_name); end
+  def hook_exists?(event_name, hook_name); end
+  def merge(other); end
+  def merge!(other); end
+
+  protected
+
+  def hooks; end
+
+  private
+
+  def initialize_copy(_orig); end
+
+  class << self
+    def default; end
+  end
+end
+
+class Pry::Indent
+  include ::Pry::Helpers::BaseHelpers
+
+  def initialize(pry_instance = T.unsafe(nil)); end
+
+  def correct_indentation(prompt, code, overhang = T.unsafe(nil)); end
+  def current_prefix; end
+  def end_of_statement?(last_token, last_kind); end
+  def in_string?; end
+  def indent(input); end
+  def indent_level; end
+  def indentation_delta(tokens); end
+  def module_nesting; end
+  def open_delimiters; end
+  def open_delimiters_line; end
+  def reset; end
+  def stack; end
+  def tokenize(string); end
+  def track_delimiter(token); end
+  def track_module_nesting(token, kind); end
+  def track_module_nesting_end(token, kind = T.unsafe(nil)); end
+
+  class << self
+    def indent(str); end
+    def nesting_at(str, line_number); end
+  end
+end
+
+Pry::Indent::IGNORE_TOKENS = T.let(T.unsafe(nil), Array)
+Pry::Indent::MIDWAY_TOKENS = T.let(T.unsafe(nil), Array)
+Pry::Indent::OPEN_TOKENS = T.let(T.unsafe(nil), Hash)
+Pry::Indent::OPTIONAL_DO_TOKENS = T.let(T.unsafe(nil), Array)
+Pry::Indent::SINGLELINE_TOKENS = T.let(T.unsafe(nil), Array)
+Pry::Indent::SPACES = T.let(T.unsafe(nil), String)
+Pry::Indent::STATEMENT_END_TOKENS = T.let(T.unsafe(nil), Array)
+class Pry::Indent::UnparseableNestingError < ::StandardError; end
+
+class Pry::InputCompleter
+  def initialize(input, pry = T.unsafe(nil)); end
+
+  def build_path(input); end
+  def call(str, options = T.unsafe(nil)); end
+  def ignored_modules; end
+  def select_message(path, receiver, message, candidates); end
+end
+
+Pry::InputCompleter::ARRAY_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::CONSTANT_OR_METHOD_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::CONSTANT_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::GLOBALVARIABLE_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::HEX_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::NUMERIC_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::PROC_OR_HASH_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::REGEX_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::RESERVED_WORDS = T.let(T.unsafe(nil), Array)
+Pry::InputCompleter::SYMBOL_METHOD_CALL_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::SYMBOL_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::TOPLEVEL_LOOKUP_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::VARIABLE_REGEXP = T.let(T.unsafe(nil), Regexp)
+Pry::InputCompleter::WORD_ESCAPE_STR = T.let(T.unsafe(nil), String)
+
+class Pry::InputLock
+  def initialize; end
+
+  def __with_ownership; end
+  def enter_interruptible_region; end
+  def interruptible_region; end
+  def leave_interruptible_region; end
+  def with_ownership(&block); end
+
+  class << self
+    def for(input); end
+    def global_lock; end
+    def global_lock=(_arg0); end
+    def input_locks; end
+    def input_locks=(_arg0); end
+  end
+end
+
+class Pry::InputLock::Interrupt < ::Exception; end
+class Pry::Inspector; end
+Pry::Inspector::MAP = T.let(T.unsafe(nil), Hash)
+Pry::LOCAL_RC_FILE = T.let(T.unsafe(nil), String)
+
+class Pry::LastException < ::BasicObject
+  def initialize(exception); end
+
+  def bt_index; end
+  def bt_index=(_arg0); end
+  def bt_source_location_for(index); end
+  def file; end
+  def inc_bt_index; end
+  def line; end
+  def method_missing(name, *args, &block); end
+  def wrapped_exception; end
+
+  private
+
+  def respond_to_missing?(name, include_all = T.unsafe(nil)); end
+end
+
+class Pry::Method
+  include ::Pry::Helpers::BaseHelpers
+  include ::Pry::Helpers::DocumentationHelpers
+  include ::Pry::CodeObject::Helpers
+  extend ::Pry::Helpers::BaseHelpers
+  extend ::Forwardable
+  extend ::Pry::Forwardable
+
+  def initialize(method, known_info = T.unsafe(nil)); end
+
+  def ==(other); end
+  def alias?; end
+  def aliases; end
+  def bound_method?; end
+  def comment; end
+  def doc; end
+  def dynamically_defined?; end
+  def is_a?(klass); end
+  def kind_of?(klass); end
+  def method_missing(method_name, *args, &block); end
+  def name; end
+  def name_with_owner; end
+  def original_name; end
+  def owner(*args, &block); end
+  def parameters(*args, &block); end
+  def pry_method?; end
+  def receiver(*args, &block); end
+  def redefine(source); end
+  def respond_to?(method_name, include_all = T.unsafe(nil)); end
+  def signature; end
+  def singleton_method?; end
+  def source; end
+  def source?; end
+  def source_file; end
+  def source_line; end
+  def source_range; end
+  def source_type; end
+  def super(times = T.unsafe(nil)); end
+  def unbound_method?; end
+  def undefined?; end
+  def visibility; end
+  def wrapped; end
+  def wrapped_owner; end
+
+  private
+
+  def c_source; end
+  def method_name_from_first_line(first_ln); end
+  def pry_doc_info; end
+  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
+  def ruby_source; end
+  def super_using_ancestors(ancestors, times = T.unsafe(nil)); end
+
+  class << self
+    def all_from_class(klass, include_super = T.unsafe(nil)); end
+    def all_from_obj(obj, include_super = T.unsafe(nil)); end
+    def from_binding(binding); end
+    def from_class(klass, name, target = T.unsafe(nil)); end
+    def from_module(klass, name, target = T.unsafe(nil)); end
+    def from_obj(obj, name, target = T.unsafe(nil)); end
+    def from_str(name, target = T.unsafe(nil), options = T.unsafe(nil)); end
+    def instance_method_definition?(name, definition_line); end
+    def instance_resolution_order(klass); end
+    def lookup_method_via_binding(obj, method_name, method_type, target = T.unsafe(nil)); end
+    def method_definition?(name, definition_line); end
+    def resolution_order(obj); end
+    def singleton_class_of(obj); end
+    def singleton_class_resolution_order(klass); end
+    def singleton_method_definition?(name, definition_line); end
+  end
+end
+
+class Pry::Method::Disowned < ::Pry::Method
+  def initialize(receiver, method_name); end
+
+  def method_missing(method_name, *args, &block); end
+  def name; end
+  def owner; end
+  def receiver; end
+  def source?; end
+  def undefined?; end
+
+  private
+
+  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
+end
+
+class Pry::Method::Patcher
+  def initialize(method); end
+
+  def method; end
+  def method=(_arg0); end
+  def patch_in_ram(source); end
+
+  private
+
+  def cache_key; end
+  def definition_for_owner(line); end
+  def redefine(source); end
+  def with_method_transaction; end
+  def wrap(source); end
+  def wrap_for_nesting(source); end
+  def wrap_for_owner(source); end
+
+  class << self
+    def code_for(filename); end
+  end
+end
+
+class Pry::Method::WeirdMethodLocator
+  def initialize(method, target); end
+
+  def find_method; end
+  def lost_method?; end
+  def method; end
+  def method=(_arg0); end
+  def target; end
+  def target=(_arg0); end
+
+  private
+
+  def all_methods_for(obj); end
+  def expanded_source_location(source_location); end
+  def find_method_in_superclass; end
+  def find_renamed_method; end
+  def index_to_line_number(index); end
+  def lines_for_file(file); end
+  def normal_method?(method); end
+  def pry_file?; end
+  def renamed_method_source_location; end
+  def skip_superclass_search?; end
+  def target_file; end
+  def target_line; end
+  def target_self; end
+  def valid_file?(file); end
+
+  class << self
+    def normal_method?(method, binding); end
+    def weird_method?(method, binding); end
+  end
+end
+
+class Pry::MethodNotFound < ::Pry::CommandError; end
+
+class Pry::NoCommandError < ::StandardError
+  def initialize(match, owner); end
+end
+
+class Pry::ObjectPath
+  def initialize(path_string, current_stack); end
+
+  def resolve; end
+
+  private
+
+  def complete?(segment); end
+  def handle_failure(context, err); end
+end
+
+Pry::ObjectPath::SPECIAL_TERMS = T.let(T.unsafe(nil), Array)
+class Pry::ObsoleteError < ::StandardError; end
+
+class Pry::Output
+  def initialize(pry_instance); end
+
+  def <<(*objs); end
+  def decolorize_maybe(str); end
+  def height; end
+  def method_missing(method_name, *args, &block); end
+  def print(*objs); end
+  def pry_instance; end
+  def puts(*objs); end
+  def size; end
+  def tty?; end
+  def width; end
+  def write(*objs); end
+
+  private
+
+  def actual_screen_size; end
+  def ansicon_env_size; end
+  def env_size; end
+  def io_console_size; end
+  def nonzero_column?(size); end
+  def readline_size; end
+  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
+end
+
+Pry::Output::DEFAULT_SIZE = T.let(T.unsafe(nil), Array)
+
+class Pry::Pager
+  def initialize(pry_instance); end
+
+  def open; end
+  def page(text); end
+  def pry_instance; end
+
+  private
+
+  def best_available; end
+  def enabled?; end
+  def output; end
+end
+
+class Pry::Pager::NullPager
+  def initialize(out); end
+
+  def <<(str); end
+  def close; end
+  def print(str); end
+  def puts(str); end
+  def write(str); end
+
+  private
+
+  def height; end
+  def width; end
+end
+
+class Pry::Pager::PageTracker
+  def initialize(rows, cols); end
+
+  def page?; end
+  def record(str); end
+  def reset; end
+
+  private
+
+  def line_length(line); end
+end
+
+class Pry::Pager::SimplePager < ::Pry::Pager::NullPager
+  def initialize(*_arg0); end
+
+  def write(str); end
+end
+
+class Pry::Pager::StopPaging < ::StandardError; end
+
+class Pry::Pager::SystemPager < ::Pry::Pager::NullPager
+  def initialize(*_arg0); end
+
+  def close; end
+  def write(str); end
+
+  private
+
+  def invoked_pager?; end
+  def pager; end
+  def write_to_pager(text); end
+
+  class << self
+    def available?; end
+    def default_pager; end
+  end
+end
+
+class Pry::PluginManager
+  def initialize; end
+
+  def load_plugins; end
+  def locate_plugins; end
+  def plugins; end
+
+  private
+
+  def gem_list; end
+  def plugin_located?(plugin); end
+end
+
+class Pry::PluginManager::NoPlugin
+  def initialize(name); end
+
+  def method_missing(*_arg0); end
+
+  private
+
+  def respond_to_missing?(*_arg0); end
+end
+
+Pry::PluginManager::PRY_PLUGIN_PREFIX = T.let(T.unsafe(nil), Regexp)
+
+class Pry::PluginManager::Plugin
+  def initialize(name, gem_name, spec, enabled); end
+
+  def activate!; end
+  def active; end
+  def active=(_arg0); end
+  def active?; end
+  def disable!; end
+  def enable!; end
+  def enabled; end
+  def enabled=(_arg0); end
+  def enabled?; end
+  def gem_name; end
+  def gem_name=(_arg0); end
+  def load_cli_options; end
+  def name; end
+  def name=(_arg0); end
+  def spec; end
+  def spec=(_arg0); end
+  def supported?; end
+end
+
+class Pry::Prompt
+  def initialize(name, description, prompt_procs); end
+
+  def [](key); end
+  def description; end
+  def incomplete_proc; end
+  def name; end
+  def prompt_procs; end
+  def wait_proc; end
+
+  class << self
+    def [](name); end
+    def add(name, description = T.unsafe(nil), separators = T.unsafe(nil)); end
+    def all; end
+  end
+end
+
+class Pry::REPL
+  extend ::Forwardable
+  extend ::Pry::Forwardable
+
+  def initialize(pry, options = T.unsafe(nil)); end
+
+  def input(*args, &block); end
+  def output(*args, &block); end
+  def pry; end
+  def pry=(_arg0); end
+  def start; end
+
+  private
+
+  def calculate_overhang(current_prompt, original_val, indented_val); end
+  def coolline_available?; end
+  def epilogue; end
+  def handle_read_errors; end
+  def input_readline(*args); end
+  def piping?; end
+  def prologue; end
+  def read; end
+  def read_line(current_prompt); end
+  def readline_available?; end
+  def repl; end
+  def set_readline_output; end
+
+  class << self
+    def start(options); end
+  end
+end
+
+class Pry::REPLFileLoader
+  def initialize(file_name); end
+
+  def define_additional_commands; end
+  def interactive_mode(pry_instance); end
+  def load; end
+  def non_interactive_mode(pry_instance, content); end
+end
+
+module Pry::RescuableException
+  class << self
+    def ===(exception); end
+  end
+end
+
+class Pry::Result
+  def initialize(is_command, retval = T.unsafe(nil)); end
+
+  def command?; end
+  def retval; end
+  def void_command?; end
+end
+
+class Pry::Ring
+  def initialize(max_size); end
+
+  def <<(value); end
+  def [](index); end
+  def clear; end
+  def count; end
+  def max_size; end
+  def size; end
+  def to_a; end
+
+  private
+
+  def transpose_buffer_tail; end
+end
+
+class Pry::Slop
+  include ::Enumerable
+
+  def initialize(config = T.unsafe(nil), &block); end
+
+  def [](key); end
+  def add_callback(label, &block); end
+  def banner(banner = T.unsafe(nil)); end
+  def banner=(banner); end
+  def command(command, options = T.unsafe(nil), &block); end
+  def config; end
+  def description(desc = T.unsafe(nil)); end
+  def description=(desc); end
+  def each(&block); end
+  def fetch_command(command); end
+  def fetch_option(key); end
+  def get(key); end
+  def help; end
+  def missing; end
+  def on(*objects, &block); end
+  def opt(*objects, &block); end
+  def option(*objects, &block); end
+  def options; end
+  def parse(items = T.unsafe(nil), &block); end
+  def parse!(items = T.unsafe(nil), &block); end
+  def present?(*keys); end
+  def run(callable = T.unsafe(nil), &block); end
+  def separator(text); end
+  def strict?; end
+  def to_h(include_commands = T.unsafe(nil)); end
+  def to_hash(include_commands = T.unsafe(nil)); end
+  def to_s; end
+
+  private
+
+  def autocreate(items, index); end
+  def build_option(objects, &block); end
+  def clean(object); end
+  def commands_to_help; end
+  def execute_multiple_switches(option, argument, index); end
+  def execute_option(option, argument, index, item = T.unsafe(nil)); end
+  def extract_long_flag(objects, config); end
+  def extract_option(flag); end
+  def extract_short_flag(objects, config); end
+  def method_missing(method, *args, &block); end
+  def process_item(items, index, &block); end
+  def respond_to_missing?(method_name, include_all = T.unsafe(nil)); end
+
+  class << self
+    def optspec(string, config = T.unsafe(nil)); end
+    def parse(items = T.unsafe(nil), config = T.unsafe(nil), &block); end
+    def parse!(items = T.unsafe(nil), config = T.unsafe(nil), &block); end
+  end
+end
+
+class Pry::Slop::Commands
+  include ::Enumerable
+
+  def initialize(config = T.unsafe(nil), &block); end
+
+  def [](key); end
+  def arguments; end
+  def banner(banner = T.unsafe(nil)); end
+  def banner=(_arg0); end
+  def commands; end
+  def config; end
+  def default(config = T.unsafe(nil), &block); end
+  def each(&block); end
+  def get(key); end
+  def global(config = T.unsafe(nil), &block); end
+  def help; end
+  def inspect; end
+  def on(command, config = T.unsafe(nil), &block); end
+  def parse(items = T.unsafe(nil)); end
+  def parse!(items = T.unsafe(nil)); end
+  def present?(key); end
+  def to_hash; end
+  def to_s; end
+
+  private
+
+  def execute_arguments!(items); end
+  def execute_global_opts!(items); end
+end
+
+Pry::Slop::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+class Pry::Slop::Error < ::StandardError; end
+class Pry::Slop::InvalidArgumentError < ::Pry::Slop::Error; end
+class Pry::Slop::InvalidCommandError < ::Pry::Slop::Error; end
+class Pry::Slop::InvalidOptionError < ::Pry::Slop::Error; end
+class Pry::Slop::MissingArgumentError < ::Pry::Slop::Error; end
+class Pry::Slop::MissingOptionError < ::Pry::Slop::Error; end
+
+class Pry::Slop::Option
+  def initialize(slop, short, long, description, config = T.unsafe(nil), &block); end
+
+  def accepts_optional_argument?; end
+  def argument?; end
+  def argument_in_value; end
+  def argument_in_value=(_arg0); end
+  def as?; end
+  def autocreated?; end
+  def call(*objects); end
+  def callback?; end
+  def config; end
+  def count; end
+  def count=(_arg0); end
+  def default?; end
+  def delimiter?; end
+  def description; end
+  def expects_argument?; end
+  def help; end
+  def inspect; end
+  def key; end
+  def limit?; end
+  def long; end
+  def match?; end
+  def optional?; end
+  def optional_argument?; end
+  def required?; end
+  def short; end
+  def tail?; end
+  def to_s; end
+  def types; end
+  def value; end
+  def value=(new_value); end
+
+  private
+
+  def value_to_float(value); end
+  def value_to_integer(value); end
+  def value_to_range(value); end
+end
+
+Pry::Slop::Option::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+Pry::Slop::VERSION = T.let(T.unsafe(nil), String)
+
+class Pry::SyntaxHighlighter
+  class << self
+    def highlight(code, language = T.unsafe(nil)); end
+    def keyword_token_color; end
+    def overwrite_coderay_comment_token!; end
+    def tokenize(code, language = T.unsafe(nil)); end
+  end
+end
+
+module Pry::SystemCommandHandler
+  class << self
+    def default(output, command, _pry_instance); end
+  end
+end
+
+module Pry::TooSafeException
+  class << self
+    def ===(exception); end
+  end
+end
+
+module Pry::UserError; end
+Pry::VERSION = T.let(T.unsafe(nil), String)
+
+module Pry::Warning
+  class << self
+    def warn(message); end
+  end
+end
+
+class Pry::WrappedModule
+  include ::Pry::Helpers::BaseHelpers
+  include ::Pry::CodeObject::Helpers
+
+  def initialize(mod); end
+
+  def candidate(rank); end
+  def candidates; end
+  def class?; end
+  def constants(inherit = T.unsafe(nil)); end
+  def doc; end
+  def file; end
+  def line; end
+  def method_missing(method_name, *args, &block); end
+  def method_prefix; end
+  def module?; end
+  def nonblank_name; end
+  def number_of_candidates; end
+  def singleton_class?; end
+  def singleton_instance; end
+  def source; end
+  def source_file; end
+  def source_line; end
+  def source_location; end
+  def super(times = T.unsafe(nil)); end
+  def wrapped; end
+  def yard_doc; end
+  def yard_docs?; end
+  def yard_file; end
+  def yard_line; end
+
+  private
+
+  def all_methods_for(mod); end
+  def all_relevant_methods_for(mod); end
+  def all_source_locations_by_popularity; end
+  def lines_for_file(file); end
+  def method_candidates; end
+  def method_defined_by_forwardable_module?(method); end
+  def nested_module?(parent, name); end
+  def primary_candidate; end
+  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
+
+  class << self
+    def from_str(mod_name, target = T.unsafe(nil)); end
+
+    private
+
+    def safe_to_evaluate?(str, target); end
+  end
+end
+
+class Pry::WrappedModule::Candidate
+  include ::Pry::Helpers::DocumentationHelpers
+  include ::Pry::CodeObject::Helpers
+  extend ::Forwardable
+  extend ::Pry::Forwardable
+
+  def initialize(wrapper, rank); end
+
+  def class?(*args, &block); end
+  def doc; end
+  def file; end
+  def line; end
+  def module?(*args, &block); end
+  def nonblank_name(*args, &block); end
+  def number_of_candidates(*args, &block); end
+  def source; end
+  def source_file; end
+  def source_line; end
+  def source_location; end
+  def wrapped(*args, &block); end
+
+  private
 
+  def class_regexes; end
+  def first_line_of_module_definition(file, line); end
+  def first_method_source_location; end
+  def last_method_source_location; end
+  def lines_for_file(*a, &b); end
+  def method_candidates(*a, &b); end
+  def name(*a, &b); end
+  def number_of_lines_in_first_chunk; end
+  def yard_docs?(*a, &b); end
+end
diff --git a/sorbet/rbi/gems/rake@10.5.0.rbi b/sorbet/rbi/gems/rake@13.0.1.rbi
similarity index 69%
rename from sorbet/rbi/gems/rake@10.5.0.rbi
rename to sorbet/rbi/gems/rake@13.0.1.rbi
index 04c1c41d..e91b424d 100644
--- a/sorbet/rbi/gems/rake@10.5.0.rbi
+++ b/sorbet/rbi/gems/rake@13.0.1.rbi
@@ -1,68 +1,55 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca generate
-
 # typed: true
 
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rake` gem.
+# Please instead update this file by running `bin/tapioca gem rake`.
+
 FileList = Rake::FileList
 
 module FileUtils
-  include(::FileUtils::StreamUtils_)
-  extend(::FileUtils::StreamUtils_)
+  include ::FileUtils::StreamUtils_
+  extend ::FileUtils::StreamUtils_
 
-  def ruby(*args, &block); end
-  def safe_ln(*args); end
+  def ruby(*args, **options, &block); end
+  def safe_ln(*args, **options); end
   def sh(*cmd, &block); end
   def split_all(path); end
 
   private
 
   def create_shell_runner(cmd); end
-  def rake_system(*cmd); end
   def set_verbose_option(options); end
+  def sh_show_command(cmd); end
 end
 
 FileUtils::LN_SUPPORTED = T.let(T.unsafe(nil), Array)
-
 FileUtils::RUBY = T.let(T.unsafe(nil), String)
 
 class Module
   def rake_extension(method); end
 end
 
-RAKEVERSION = T.let(T.unsafe(nil), String)
-
 module Rake
-  extend(::FileUtils::StreamUtils_)
-  extend(::FileUtils)
-  extend(::Rake::FileUtilsExt)
-
-  def self.add_rakelib(*files); end
-  def self.application; end
-  def self.application=(app); end
-  def self.each_dir_parent(dir); end
-  def self.from_pathname(path); end
-  def self.load_rakefile(path); end
-  def self.original_dir; end
-  def self.suggested_thread_count; end
-end
-
-module Rake::AltSystem
-
-  private
-
-  def `(_); end
-  def backticks(_); end
-  def system(*_); end
-
-  def self.`(_); end
-  def self.backticks(_); end
-  def self.define_module_function(name, &block); end
-  def self.system(*_); end
+  extend ::FileUtils::StreamUtils_
+  extend ::FileUtils
+  extend ::Rake::FileUtilsExt
+
+  class << self
+    def add_rakelib(*files); end
+    def application; end
+    def application=(app); end
+    def each_dir_parent(dir); end
+    def from_pathname(path); end
+    def load_rakefile(path); end
+    def original_dir; end
+    def suggested_thread_count; end
+    def with_application(block_application = T.unsafe(nil)); end
+  end
 end
 
 class Rake::Application
-  include(::Rake::TaskManager)
-  include(::Rake::TraceOutput)
+  include ::Rake::TaskManager
+  include ::Rake::TraceOutput
 
   def initialize; end
 
@@ -71,9 +58,11 @@ class Rake::Application
   def collect_command_line_tasks(args); end
   def default_task_name; end
   def deprecate(old_usage, new_usage, call_site); end
+  def display_cause_details(ex); end
   def display_error_message(ex); end
   def display_exception_backtrace(ex); end
   def display_exception_details(ex); end
+  def display_exception_details_seen; end
   def display_exception_message_details(ex); end
   def display_prerequisites; end
   def display_tasks_and_comments; end
@@ -82,10 +71,10 @@ class Rake::Application
   def dynamic_width_tput; end
   def exit_because_of_exception(ex); end
   def find_rakefile_location; end
-  def handle_options; end
+  def handle_options(argv); end
   def has_cause?(ex); end
   def have_rakefile; end
-  def init(app_name = _); end
+  def init(app_name = T.unsafe(nil), argv = T.unsafe(nil)); end
   def invoke_task(task_string); end
   def load_imports; end
   def load_rakefile; end
@@ -94,17 +83,18 @@ class Rake::Application
   def original_dir; end
   def parse_task_string(string); end
   def print_rakefile_directory(location); end
-  def rake_require(file_name, paths = _, loaded = _); end
+  def rake_require(file_name, paths = T.unsafe(nil), loaded = T.unsafe(nil)); end
   def rakefile; end
-  def rakefile_location(backtrace = _); end
+  def rakefile_location(backtrace = T.unsafe(nil)); end
   def raw_load_rakefile; end
-  def run; end
+  def run(argv = T.unsafe(nil)); end
   def run_with_threads; end
+  def set_default_options; end
   def standard_exception_handling; end
   def standard_rake_options; end
   def system_dir; end
   def terminal_columns; end
-  def terminal_columns=(_); end
+  def terminal_columns=(_arg0); end
   def terminal_width; end
   def thread_pool; end
   def top_level; end
@@ -112,7 +102,7 @@ class Rake::Application
   def trace(*strings); end
   def truncate(string, width); end
   def truncate_output?; end
-  def tty_output=(tty_output_state); end
+  def tty_output=(_arg0); end
   def tty_output?; end
   def unix?; end
   def windows?; end
@@ -129,44 +119,39 @@ end
 
 Rake::Application::DEFAULT_RAKEFILES = T.let(T.unsafe(nil), Array)
 
-Rake::Application::FIXNUM_MAX = T.let(T.unsafe(nil), Integer)
-
 module Rake::Backtrace
-  def self.collapse(backtrace); end
+  class << self
+    def collapse(backtrace); end
+  end
 end
 
 Rake::Backtrace::SUPPRESSED_PATHS = T.let(T.unsafe(nil), Array)
-
 Rake::Backtrace::SUPPRESSED_PATHS_RE = T.let(T.unsafe(nil), String)
-
 Rake::Backtrace::SUPPRESS_PATTERN = T.let(T.unsafe(nil), Regexp)
-
 Rake::Backtrace::SYS_KEYS = T.let(T.unsafe(nil), Array)
-
 Rake::Backtrace::SYS_PATHS = T.let(T.unsafe(nil), Array)
 
 module Rake::Cloneable
-
   private
 
   def initialize_copy(source); end
 end
 
-class Rake::CommandLineOptionError < ::StandardError
-end
+class Rake::CommandLineOptionError < ::StandardError; end
 
 class Rake::CpuCounter
   def count; end
-  def count_with_default(default = _); end
+  def count_with_default(default = T.unsafe(nil)); end
 
-  def self.count; end
+  class << self
+    def count; end
+  end
 end
 
 module Rake::DSL
-  include(::FileUtils::StreamUtils_)
-  include(::FileUtils)
-  include(::Rake::FileUtilsExt)
-
+  include ::FileUtils::StreamUtils_
+  include ::FileUtils
+  include ::Rake::FileUtilsExt
 
   private
 
@@ -176,7 +161,7 @@ module Rake::DSL
   def file_create(*args, &block); end
   def import(*fns); end
   def multitask(*args, &block); end
-  def namespace(name = _, &block); end
+  def namespace(name = T.unsafe(nil), &block); end
   def rule(*args, &block); end
   def task(*args, &block); end
 end
@@ -186,18 +171,15 @@ class Rake::DefaultLoader
 end
 
 Rake::EARLY = T.let(T.unsafe(nil), Rake::EarlyTime)
-
 Rake::EMPTY_TASK_ARGS = T.let(T.unsafe(nil), Rake::TaskArguments)
 
 class Rake::EarlyTime
-  include(::Comparable)
-  include(::Singleton)
-  extend(::Singleton::SingletonClassMethods)
+  include ::Comparable
+  include ::Singleton
+  extend ::Singleton::SingletonClassMethods
 
   def <=>(other); end
   def to_s; end
-
-  def self.instance; end
 end
 
 class Rake::FileCreationTask < ::Rake::FileTask
@@ -206,7 +188,7 @@ class Rake::FileCreationTask < ::Rake::FileTask
 end
 
 class Rake::FileList
-  include(::Rake::Cloneable)
+  include ::Rake::Cloneable
 
   def initialize(*patterns); end
 
@@ -241,6 +223,7 @@ class Rake::FileList
   def concat(*args, &block); end
   def count(*args, &block); end
   def cycle(*args, &block); end
+  def deconstruct(*args, &block); end
   def delete(*args, &block); end
   def delete_at(*args, &block); end
   def delete_if(*args, &block); end
@@ -263,11 +246,12 @@ class Rake::FileList
   def excluded_from_list?(fn); end
   def existing; end
   def existing!; end
-  def ext(newext = _); end
+  def ext(newext = T.unsafe(nil)); end
   def fetch(*args, &block); end
   def fill(*args, &block); end
   def filter(*args, &block); end
   def filter!(*args, &block); end
+  def filter_map(*args, &block); end
   def find(*args, &block); end
   def find_all(*args, &block); end
   def find_index(*args, &block); end
@@ -287,6 +271,7 @@ class Rake::FileList
   def inject(*args, &block); end
   def insert(*args, &block); end
   def inspect(*args, &block); end
+  def intersection(*args, &block); end
   def is_a?(klass); end
   def join(*args, &block); end
   def keep_if(*args, &block); end
@@ -307,8 +292,9 @@ class Rake::FileList
   def one?(*args, &block); end
   def pack(*args, &block); end
   def partition(&block); end
-  def pathmap(spec = _); end
+  def pathmap(spec = T.unsafe(nil), &block); end
   def permutation(*args, &block); end
+  def place(*args, &block); end
   def pop(*args, &block); end
   def prepend(*args, &block); end
   def product(*args, &block); end
@@ -349,6 +335,7 @@ class Rake::FileList
   def sum(*args, &block); end
   def take(*args, &block); end
   def take_while(*args, &block); end
+  def tally(*args, &block); end
   def to_a; end
   def to_ary; end
   def to_h(*args, &block); end
@@ -369,22 +356,19 @@ class Rake::FileList
   def resolve_add(fn); end
   def resolve_exclude; end
 
-  def self.[](*args); end
-  def self.glob(pattern, *args); end
+  class << self
+    def [](*args); end
+    def glob(pattern, *args); end
+  end
 end
 
 Rake::FileList::ARRAY_METHODS = T.let(T.unsafe(nil), Array)
-
 Rake::FileList::DEFAULT_IGNORE_PATTERNS = T.let(T.unsafe(nil), Array)
-
 Rake::FileList::DEFAULT_IGNORE_PROCS = T.let(T.unsafe(nil), Array)
-
 Rake::FileList::DELEGATING_METHODS = T.let(T.unsafe(nil), Array)
-
+Rake::FileList::GLOB_PATTERN = T.let(T.unsafe(nil), Regexp)
 Rake::FileList::MUST_DEFINE = T.let(T.unsafe(nil), Array)
-
 Rake::FileList::MUST_NOT_DEFINE = T.let(T.unsafe(nil), Array)
-
 Rake::FileList::SPECIAL_RETURN = T.let(T.unsafe(nil), Array)
 
 class Rake::FileTask < ::Rake::Task
@@ -395,60 +379,61 @@ class Rake::FileTask < ::Rake::Task
 
   def out_of_date?(stamp); end
 
-  def self.scope_name(scope, task_name); end
+  class << self
+    def scope_name(scope, task_name); end
+  end
 end
 
 module Rake::FileUtilsExt
-  include(::FileUtils::StreamUtils_)
-  include(::FileUtils)
-  extend(::FileUtils::StreamUtils_)
-  extend(::FileUtils)
-  extend(::Rake::FileUtilsExt)
-
-  def cd(*args, &block); end
-  def chdir(*args, &block); end
-  def chmod(*args, &block); end
-  def chmod_R(*args, &block); end
-  def chown(*args, &block); end
-  def chown_R(*args, &block); end
-  def copy(*args, &block); end
-  def cp(*args, &block); end
-  def cp_lr(*args, &block); end
-  def cp_r(*args, &block); end
-  def install(*args, &block); end
-  def link(*args, &block); end
-  def ln(*args, &block); end
-  def ln_s(*args, &block); end
-  def ln_sf(*args, &block); end
-  def makedirs(*args, &block); end
-  def mkdir(*args, &block); end
-  def mkdir_p(*args, &block); end
-  def mkpath(*args, &block); end
-  def move(*args, &block); end
-  def mv(*args, &block); end
-  def nowrite(value = _); end
+  include ::FileUtils::StreamUtils_
+  include ::FileUtils
+  extend ::FileUtils::StreamUtils_
+  extend ::FileUtils
+  extend ::Rake::FileUtilsExt
+
+  def cd(*args, **options, &block); end
+  def chdir(*args, **options, &block); end
+  def chmod(*args, **options, &block); end
+  def chmod_R(*args, **options, &block); end
+  def chown(*args, **options, &block); end
+  def chown_R(*args, **options, &block); end
+  def copy(*args, **options, &block); end
+  def cp(*args, **options, &block); end
+  def cp_lr(*args, **options, &block); end
+  def cp_r(*args, **options, &block); end
+  def install(*args, **options, &block); end
+  def link(*args, **options, &block); end
+  def ln(*args, **options, &block); end
+  def ln_s(*args, **options, &block); end
+  def ln_sf(*args, **options, &block); end
+  def makedirs(*args, **options, &block); end
+  def mkdir(*args, **options, &block); end
+  def mkdir_p(*args, **options, &block); end
+  def mkpath(*args, **options, &block); end
+  def move(*args, **options, &block); end
+  def mv(*args, **options, &block); end
+  def nowrite(value = T.unsafe(nil)); end
   def rake_check_options(options, *optdecl); end
-  def rake_merge_option(args, defaults); end
   def rake_output_message(message); end
-  def remove(*args, &block); end
-  def rm(*args, &block); end
-  def rm_f(*args, &block); end
-  def rm_r(*args, &block); end
-  def rm_rf(*args, &block); end
-  def rmdir(*args, &block); end
-  def rmtree(*args, &block); end
-  def ruby(*args, &block); end
-  def safe_unlink(*args, &block); end
-  def sh(*args, &block); end
-  def symlink(*args, &block); end
-  def touch(*args, &block); end
-  def verbose(value = _); end
-  def when_writing(msg = _); end
-
-  def self.nowrite_flag; end
-  def self.nowrite_flag=(_); end
-  def self.verbose_flag; end
-  def self.verbose_flag=(_); end
+  def remove(*args, **options, &block); end
+  def rm(*args, **options, &block); end
+  def rm_f(*args, **options, &block); end
+  def rm_r(*args, **options, &block); end
+  def rm_rf(*args, **options, &block); end
+  def rmdir(*args, **options, &block); end
+  def rmtree(*args, **options, &block); end
+  def safe_unlink(*args, **options, &block); end
+  def symlink(*args, **options, &block); end
+  def touch(*args, **options, &block); end
+  def verbose(value = T.unsafe(nil)); end
+  def when_writing(msg = T.unsafe(nil)); end
+
+  class << self
+    def nowrite_flag; end
+    def nowrite_flag=(_arg0); end
+    def verbose_flag; end
+    def verbose_flag=(_arg0); end
+  end
 end
 
 Rake::FileUtilsExt::DEFAULT = T.let(T.unsafe(nil), Object)
@@ -462,7 +447,9 @@ class Rake::InvocationChain < ::Rake::LinkedList
 
   def prefix; end
 
-  def self.append(invocation, chain); end
+  class << self
+    def append(invocation, chain); end
+  end
 end
 
 Rake::InvocationChain::EMPTY = T.let(T.unsafe(nil), Rake::InvocationChain::EmptyInvocationChain)
@@ -481,20 +468,18 @@ end
 Rake::LATE = T.let(T.unsafe(nil), Rake::LateTime)
 
 class Rake::LateTime
-  include(::Comparable)
-  include(::Singleton)
-  extend(::Singleton::SingletonClassMethods)
+  include ::Comparable
+  include ::Singleton
+  extend ::Singleton::SingletonClassMethods
 
   def <=>(other); end
   def to_s; end
-
-  def self.instance; end
 end
 
 class Rake::LinkedList
-  include(::Enumerable)
+  include ::Enumerable
 
-  def initialize(head, tail = _); end
+  def initialize(head, tail = T.unsafe(nil)); end
 
   def ==(other); end
   def conj(item); end
@@ -505,9 +490,11 @@ class Rake::LinkedList
   def tail; end
   def to_s; end
 
-  def self.cons(head, tail); end
-  def self.empty; end
-  def self.make(*args); end
+  class << self
+    def cons(head, tail); end
+    def empty; end
+    def make(*args); end
+  end
 end
 
 Rake::LinkedList::EMPTY = T.let(T.unsafe(nil), Rake::LinkedList::EmptyLinkedList)
@@ -517,11 +504,12 @@ class Rake::LinkedList::EmptyLinkedList < ::Rake::LinkedList
 
   def empty?; end
 
-  def self.cons(head, tail); end
+  class << self
+    def cons(head, tail); end
+  end
 end
 
 class Rake::MultiTask < ::Rake::Task
-
   private
 
   def invoke_prerequisites(task_args, invocation_chain); end
@@ -536,9 +524,11 @@ class Rake::NameSpace
 end
 
 module Rake::PrivateReader
-  mixes_in_class_methods(::Rake::PrivateReader::ClassMethods)
+  mixes_in_class_methods ::Rake::PrivateReader::ClassMethods
 
-  def self.included(base); end
+  class << self
+    def included(base); end
+  end
 end
 
 module Rake::PrivateReader::ClassMethods
@@ -549,7 +539,7 @@ class Rake::Promise
   def initialize(args, &block); end
 
   def recorder; end
-  def recorder=(_); end
+  def recorder=(_arg0); end
   def value; end
   def work; end
 
@@ -566,7 +556,7 @@ end
 Rake::Promise::NOT_SET = T.let(T.unsafe(nil), Object)
 
 class Rake::PseudoStatus
-  def initialize(code = _); end
+  def initialize(code = T.unsafe(nil)); end
 
   def >>(n); end
   def exited?; end
@@ -601,18 +591,20 @@ class Rake::Task
   def actions; end
   def add_description(description); end
   def all_prerequisite_tasks; end
+  def already_invoked; end
   def application; end
-  def application=(_); end
+  def application=(_arg0); end
   def arg_description; end
   def arg_names; end
   def clear; end
   def clear_actions; end
+  def clear_args; end
   def clear_comments; end
   def clear_prerequisites; end
   def comment; end
   def comment=(comment); end
-  def enhance(deps = _, &block); end
-  def execute(args = _); end
+  def enhance(deps = T.unsafe(nil), &block); end
+  def execute(args = T.unsafe(nil)); end
   def full_comment; end
   def inspect; end
   def investigation; end
@@ -623,6 +615,8 @@ class Rake::Task
   def name; end
   def name_with_args; end
   def needed?; end
+  def order_only_prerequisites; end
+  def prereqs; end
   def prerequisite_tasks; end
   def prerequisites; end
   def reenable; end
@@ -630,9 +624,10 @@ class Rake::Task
   def set_arg_names(args); end
   def source; end
   def sources; end
-  def sources=(_); end
+  def sources=(_arg0); end
   def timestamp; end
   def to_s; end
+  def |(deps); end
 
   protected
 
@@ -648,28 +643,32 @@ class Rake::Task
   def lookup_prerequisite(prerequisite_name); end
   def transform_comments(separator, &block); end
 
-  def self.[](task_name); end
-  def self.clear; end
-  def self.create_rule(*args, &block); end
-  def self.define_task(*args, &block); end
-  def self.scope_name(scope, task_name); end
-  def self.task_defined?(task_name); end
-  def self.tasks; end
+  class << self
+    def [](task_name); end
+    def clear; end
+    def create_rule(*args, &block); end
+    def define_task(*args, &block); end
+    def format_deps(deps); end
+    def scope_name(scope, task_name); end
+    def task_defined?(task_name); end
+    def tasks; end
+  end
 end
 
-class Rake::TaskArgumentError < ::ArgumentError
-end
+class Rake::TaskArgumentError < ::ArgumentError; end
 
 class Rake::TaskArguments
-  include(::Enumerable)
+  include ::Enumerable
 
-  def initialize(names, values, parent = _); end
+  def initialize(names, values, parent = T.unsafe(nil)); end
 
   def [](index); end
   def each(&block); end
   def extras; end
+  def fetch(*args, &block); end
   def has_key?(key); end
   def inspect; end
+  def key?(key); end
   def method_missing(sym, *args); end
   def names; end
   def new_scope(names); end
@@ -684,21 +683,30 @@ class Rake::TaskArguments
   def lookup(name); end
 end
 
+class Rake::TaskLib
+  include ::Rake::Cloneable
+  include ::FileUtils::StreamUtils_
+  include ::FileUtils
+  include ::Rake::FileUtilsExt
+  include ::Rake::DSL
+end
+
 module Rake::TaskManager
   def initialize; end
 
-  def [](task_name, scopes = _); end
+  def [](task_name, scopes = T.unsafe(nil)); end
   def clear; end
   def create_rule(*args, &block); end
   def current_scope; end
   def define_task(task_class, *args, &block); end
-  def enhance_with_matching_rule(task_name, level = _); end
+  def enhance_with_matching_rule(task_name, level = T.unsafe(nil)); end
+  def generate_did_you_mean_suggestions(task_name); end
+  def generate_message_for_undefined_task(task_name); end
   def in_namespace(name); end
   def intern(task_class, task_name); end
-  def last_comment; end
   def last_description; end
-  def last_description=(_); end
-  def lookup(task_name, initial_scope = _); end
+  def last_description=(_arg0); end
+  def lookup(task_name, initial_scope = T.unsafe(nil)); end
   def resolve_args(args); end
   def synthesize_file_task(task_name); end
   def tasks; end
@@ -707,23 +715,25 @@ module Rake::TaskManager
   private
 
   def add_location(task); end
-  def attempt_rule(task_name, args, extensions, block, level); end
+  def attempt_rule(task_name, task_pattern, args, extensions, block, level); end
   def find_location; end
   def generate_name; end
   def get_description(task); end
   def lookup_in_scope(name, scope); end
-  def make_sources(task_name, extensions); end
+  def make_sources(task_name, task_pattern, extensions); end
   def resolve_args_with_dependencies(args, hash); end
   def resolve_args_without_dependencies(args); end
   def trace_rule(level, message); end
 
-  def self.record_task_metadata; end
-  def self.record_task_metadata=(_); end
+  class << self
+    def record_task_metadata; end
+    def record_task_metadata=(_arg0); end
+  end
 end
 
 class Rake::ThreadHistoryDisplay
-  include(::Rake::PrivateReader)
-  extend(::Rake::PrivateReader::ClassMethods)
+  include ::Rake::PrivateReader
+  extend ::Rake::PrivateReader::ClassMethods
 
   def initialize(stats); end
 
@@ -752,7 +762,7 @@ class Rake::ThreadPool
   def process_queue_item; end
   def safe_thread_count; end
   def start_thread; end
-  def stat(event, data = _); end
+  def stat(event, data = T.unsafe(nil)); end
 end
 
 module Rake::TraceOutput
@@ -760,39 +770,31 @@ module Rake::TraceOutput
 end
 
 Rake::VERSION = T.let(T.unsafe(nil), String)
-
-module Rake::Version
-end
-
+module Rake::Version; end
 Rake::Version::BUILD = T.let(T.unsafe(nil), String)
-
 Rake::Version::MAJOR = T.let(T.unsafe(nil), String)
-
 Rake::Version::MINOR = T.let(T.unsafe(nil), String)
-
 Rake::Version::NUMBERS = T.let(T.unsafe(nil), Array)
-
 Rake::Version::OTHER = T.let(T.unsafe(nil), Array)
 
 module Rake::Win32
-  def self.normalize(path); end
-  def self.rake_system(*cmd); end
-  def self.win32_system_dir; end
-  def self.windows?; end
-end
-
-class Rake::Win32::Win32HomeError < ::RuntimeError
+  class << self
+    def normalize(path); end
+    def win32_system_dir; end
+    def windows?; end
+  end
 end
 
+class Rake::Win32::Win32HomeError < ::RuntimeError; end
 RakeFileUtils = Rake::FileUtilsExt
 
 class String
-  include(::Comparable)
-  include(::JSON::Ext::Generator::GeneratorMethods::String)
-  extend(::JSON::Ext::Generator::GeneratorMethods::String::Extend)
+  include ::Comparable
+  include ::JSON::Ext::Generator::GeneratorMethods::String
+  extend ::JSON::Ext::Generator::GeneratorMethods::String::Extend
 
-  def ext(newext = _); end
-  def pathmap(spec = _, &block); end
+  def ext(newext = T.unsafe(nil)); end
+  def pathmap(spec = T.unsafe(nil), &block); end
 
   protected
 
diff --git a/sorbet/rbi/gems/rbi@0.0.6.rbi b/sorbet/rbi/gems/rbi@0.0.6.rbi
new file mode 100644
index 00000000..3b6ac885
--- /dev/null
+++ b/sorbet/rbi/gems/rbi@0.0.6.rbi
@@ -0,0 +1,1420 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rbi` gem.
+# Please instead update this file by running `bin/tapioca gem rbi`.
+
+module RBI; end
+
+class RBI::ASTVisitor
+  abstract!
+
+  def initialize(*args, &blk); end
+
+  sig { abstract.params(node: T.nilable(AST::Node)).void }
+  def visit(node); end
+
+  sig { params(nodes: T::Array[AST::Node]).void }
+  def visit_all(nodes); end
+
+  private
+
+  sig { params(node: AST::Node).returns(String) }
+  def parse_expr(node); end
+
+  sig { params(node: AST::Node).returns(String) }
+  def parse_name(node); end
+end
+
+class RBI::Attr < ::RBI::NodeWithComments
+  include ::RBI::Indexable
+
+  abstract!
+
+  sig { params(name: Symbol, names: T::Array[Symbol], visibility: RBI::Visibility, sigs: T::Array[RBI::Sig], loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment]).void }
+  def initialize(name, names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil)); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { override.params(other: RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  sig { abstract.returns(T::Array[String]) }
+  def fully_qualified_names; end
+
+  sig { override.returns(T::Array[String]) }
+  def index_ids; end
+
+  sig { override.params(other: RBI::Node).void }
+  def merge_with(other); end
+
+  sig { returns(T::Array[Symbol]) }
+  def names; end
+
+  def names=(_arg0); end
+
+  sig { override.returns(T::Boolean) }
+  def oneline?; end
+
+  sig { returns(T::Array[RBI::Sig]) }
+  def sigs; end
+
+  sig { returns(RBI::Visibility) }
+  def visibility; end
+
+  def visibility=(_arg0); end
+end
+
+class RBI::AttrAccessor < ::RBI::Attr
+  sig { params(name: Symbol, names: Symbol, visibility: RBI::Visibility, sigs: T::Array[RBI::Sig], loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::AttrAccessor).void)).void }
+  def initialize(name, *names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { override.params(other: RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  sig { override.returns(T::Array[String]) }
+  def fully_qualified_names; end
+
+  sig { override.returns(String) }
+  def to_s; end
+end
+
+class RBI::AttrReader < ::RBI::Attr
+  sig { params(name: Symbol, names: Symbol, visibility: RBI::Visibility, sigs: T::Array[RBI::Sig], loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::AttrReader).void)).void }
+  def initialize(name, *names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { override.params(other: RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  sig { override.returns(T::Array[String]) }
+  def fully_qualified_names; end
+
+  sig { override.returns(String) }
+  def to_s; end
+end
+
+class RBI::AttrWriter < ::RBI::Attr
+  sig { params(name: Symbol, names: Symbol, visibility: RBI::Visibility, sigs: T::Array[RBI::Sig], loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::AttrWriter).void)).void }
+  def initialize(name, *names, visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { override.params(other: RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  sig { override.returns(T::Array[String]) }
+  def fully_qualified_names; end
+
+  sig { override.returns(String) }
+  def to_s; end
+end
+
+class RBI::BlockParam < ::RBI::Param
+  sig { params(name: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::BlockParam).void)).void }
+  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { params(other: T.nilable(Object)).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { override.params(v: RBI::Printer, last: T::Boolean).void }
+  def print_comment_leading_space(v, last:); end
+
+  sig { override.returns(String) }
+  def to_s; end
+end
+
+class RBI::Class < ::RBI::Scope
+  sig { params(name: String, superclass_name: T.nilable(String), loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Class).void)).void }
+  def initialize(name, superclass_name: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { override.params(other: RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  sig { override.returns(String) }
+  def fully_qualified_name; end
+
+  sig { returns(String) }
+  def name; end
+
+  def name=(_arg0); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def print_header(v); end
+
+  sig { returns(T.nilable(String)) }
+  def superclass_name; end
+
+  def superclass_name=(_arg0); end
+end
+
+class RBI::Comment < ::RBI::Node
+  sig { params(text: String, loc: T.nilable(RBI::Loc)).void }
+  def initialize(text, loc: T.unsafe(nil)); end
+
+  sig { params(other: Object).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(String) }
+  def text; end
+
+  def text=(_arg0); end
+end
+
+class RBI::ConflictTree < ::RBI::Tree
+  sig { params(left_name: String, right_name: String).void }
+  def initialize(left_name: T.unsafe(nil), right_name: T.unsafe(nil)); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(RBI::Tree) }
+  def left; end
+
+  def right; end
+end
+
+class RBI::Const < ::RBI::NodeWithComments
+  include ::RBI::Indexable
+
+  sig { params(name: String, value: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Const).void)).void }
+  def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { override.params(other: RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  sig { returns(String) }
+  def fully_qualified_name; end
+
+  sig { override.returns(T::Array[String]) }
+  def index_ids; end
+
+  sig { returns(String) }
+  def name; end
+
+  sig { override.returns(String) }
+  def to_s; end
+
+  def value; end
+end
+
+class RBI::ConstBuilder < ::RBI::ASTVisitor
+  sig { void }
+  def initialize; end
+
+  sig { returns(T::Array[String]) }
+  def names; end
+
+  def names=(_arg0); end
+
+  sig { override.params(node: T.nilable(AST::Node)).void }
+  def visit(node); end
+
+  class << self
+    sig { params(node: T.nilable(AST::Node)).returns(T.nilable(String)) }
+    def visit(node); end
+  end
+end
+
+class RBI::EmptyComment < ::RBI::Comment
+  sig { params(loc: T.nilable(RBI::Loc)).void }
+  def initialize(loc: T.unsafe(nil)); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+end
+
+class RBI::Error < ::StandardError; end
+
+class RBI::Extend < ::RBI::Mixin
+  include ::RBI::Indexable
+
+  sig { params(name: String, names: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Extend).void)).void }
+  def initialize(name, *names, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { override.params(other: RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  sig { override.returns(T::Array[String]) }
+  def index_ids; end
+
+  sig { override.returns(String) }
+  def to_s; end
+end
+
+class RBI::File
+  sig { params(strictness: T.nilable(String), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(file: RBI::File).void)).void }
+  def initialize(strictness: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { params(node: RBI::Node).void }
+  def <<(node); end
+
+  sig { params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(T::Array[RBI::Comment]) }
+  def comments; end
+
+  def comments=(_arg0); end
+
+  sig { returns(T::Boolean) }
+  def empty?; end
+
+  sig { params(out: T.any(IO, StringIO), indent: Integer, print_locs: T::Boolean).void }
+  def print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil)); end
+
+  sig { returns(RBI::Tree) }
+  def root; end
+
+  sig { void }
+  def set_empty_body_content; end
+
+  sig { params(command: String, reason: T.nilable(String), display_heading: T::Boolean).void }
+  def set_file_header(command, reason: T.unsafe(nil), display_heading: T.unsafe(nil)); end
+
+  sig { returns(T.nilable(String)) }
+  def strictness; end
+
+  sig { params(indent: Integer, print_locs: T::Boolean).returns(String) }
+  def string(indent: T.unsafe(nil), print_locs: T.unsafe(nil)); end
+
+  sig { void }
+  def transform_rbi!; end
+
+  sig { returns(String) }
+  def transformed_string; end
+end
+
+class RBI::Group < ::RBI::Tree
+  sig { params(kind: RBI::Group::Kind).void }
+  def initialize(kind); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(RBI::Group::Kind) }
+  def kind; end
+end
+
+class RBI::Group::Kind < ::T::Enum
+  enums do
+    Mixins = new
+    Helpers = new
+    TypeMembers = new
+    MixesInClassMethods = new
+    TStructFields = new
+    TEnums = new
+    Inits = new
+    Methods = new
+    Consts = new
+  end
+end
+
+class RBI::Helper < ::RBI::NodeWithComments
+  include ::RBI::Indexable
+
+  sig { params(name: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Helper).void)).void }
+  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { override.params(other: RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  sig { override.returns(T::Array[String]) }
+  def index_ids; end
+
+  sig { returns(String) }
+  def name; end
+
+  sig { override.returns(String) }
+  def to_s; end
+end
+
+class RBI::Include < ::RBI::Mixin
+  include ::RBI::Indexable
+
+  sig { params(name: String, names: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Include).void)).void }
+  def initialize(name, *names, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { override.params(other: RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  sig { override.returns(T::Array[String]) }
+  def index_ids; end
+
+  sig { override.returns(String) }
+  def to_s; end
+end
+
+class RBI::Index < ::RBI::Visitor
+  sig { void }
+  def initialize; end
+
+  sig { params(id: String).returns(T::Array[RBI::Node]) }
+  def [](id); end
+
+  sig { params(node: T.all(RBI::Indexable, RBI::Node)).void }
+  def index(node); end
+
+  sig { returns(T::Array[String]) }
+  def keys; end
+
+  sig { override.params(node: T.nilable(RBI::Node)).void }
+  def visit(node); end
+
+  class << self
+    sig { params(node: RBI::Node).returns(RBI::Index) }
+    def index(*node); end
+  end
+end
+
+module RBI::Indexable
+  interface!
+
+  sig { abstract.returns(T::Array[String]) }
+  def index_ids; end
+end
+
+class RBI::KwOptParam < ::RBI::Param
+  sig { params(name: String, value: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::KwOptParam).void)).void }
+  def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { params(other: T.nilable(Object)).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { override.params(v: RBI::Printer, last: T::Boolean).void }
+  def print_comment_leading_space(v, last:); end
+
+  sig { override.returns(String) }
+  def to_s; end
+
+  sig { returns(String) }
+  def value; end
+end
+
+class RBI::KwParam < ::RBI::Param
+  sig { params(name: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::KwParam).void)).void }
+  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { params(other: T.nilable(Object)).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { override.params(v: RBI::Printer, last: T::Boolean).void }
+  def print_comment_leading_space(v, last:); end
+
+  sig { override.returns(String) }
+  def to_s; end
+end
+
+class RBI::KwRestParam < ::RBI::Param
+  sig { params(name: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::KwRestParam).void)).void }
+  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { params(other: T.nilable(Object)).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { override.params(v: RBI::Printer, last: T::Boolean).void }
+  def print_comment_leading_space(v, last:); end
+
+  sig { override.returns(String) }
+  def to_s; end
+end
+
+class RBI::Loc
+  sig { params(file: T.nilable(String), begin_line: T.nilable(Integer), end_line: T.nilable(Integer), begin_column: T.nilable(Integer), end_column: T.nilable(Integer)).void }
+  def initialize(file: T.unsafe(nil), begin_line: T.unsafe(nil), end_line: T.unsafe(nil), begin_column: T.unsafe(nil), end_column: T.unsafe(nil)); end
+
+  def begin_column; end
+
+  sig { returns(T.nilable(Integer)) }
+  def begin_line; end
+
+  def end_column; end
+  def end_line; end
+
+  sig { returns(T.nilable(String)) }
+  def file; end
+
+  sig { returns(String) }
+  def to_s; end
+
+  class << self
+    sig { params(file: String, ast_loc: T.any(Parser::Source::Map, Parser::Source::Range)).returns(RBI::Loc) }
+    def from_ast_loc(file, ast_loc); end
+  end
+end
+
+class RBI::Method < ::RBI::NodeWithComments
+  include ::RBI::Indexable
+
+  sig { params(name: String, params: T::Array[RBI::Param], is_singleton: T::Boolean, visibility: RBI::Visibility, sigs: T::Array[RBI::Sig], loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Method).void)).void }
+  def initialize(name, params: T.unsafe(nil), is_singleton: T.unsafe(nil), visibility: T.unsafe(nil), sigs: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { params(param: RBI::Param).void }
+  def <<(param); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { override.params(other: RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  sig { returns(String) }
+  def fully_qualified_name; end
+
+  sig { override.returns(T::Array[String]) }
+  def index_ids; end
+
+  sig { returns(T::Boolean) }
+  def inline_params?; end
+
+  sig { returns(T::Boolean) }
+  def is_singleton; end
+
+  def is_singleton=(_arg0); end
+
+  sig { override.params(other: RBI::Node).void }
+  def merge_with(other); end
+
+  sig { returns(String) }
+  def name; end
+
+  def name=(_arg0); end
+
+  sig { override.returns(T::Boolean) }
+  def oneline?; end
+
+  sig { returns(T::Array[RBI::Param]) }
+  def params; end
+
+  sig { returns(T::Array[RBI::Sig]) }
+  def sigs; end
+
+  def sigs=(_arg0); end
+
+  sig { override.returns(String) }
+  def to_s; end
+
+  sig { returns(RBI::Visibility) }
+  def visibility; end
+
+  def visibility=(_arg0); end
+end
+
+class RBI::MixesInClassMethods < ::RBI::Mixin
+  include ::RBI::Indexable
+
+  sig { params(name: String, names: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::MixesInClassMethods).void)).void }
+  def initialize(name, *names, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { override.params(other: RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  sig { override.returns(T::Array[String]) }
+  def index_ids; end
+
+  sig { override.returns(String) }
+  def to_s; end
+end
+
+class RBI::Mixin < ::RBI::NodeWithComments
+  abstract!
+
+  sig { params(name: String, names: T::Array[String], loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment]).void }
+  def initialize(name, names, loc: T.unsafe(nil), comments: T.unsafe(nil)); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { override.params(other: RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  sig { returns(T::Array[String]) }
+  def names; end
+
+  def names=(_arg0); end
+end
+
+class RBI::Module < ::RBI::Scope
+  sig { params(name: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Module).void)).void }
+  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { override.params(other: RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  sig { override.returns(String) }
+  def fully_qualified_name; end
+
+  sig { returns(String) }
+  def name; end
+
+  def name=(_arg0); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def print_header(v); end
+end
+
+class RBI::Node
+  abstract!
+
+  sig { params(loc: T.nilable(RBI::Loc)).void }
+  def initialize(loc: T.unsafe(nil)); end
+
+  sig { abstract.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { params(_other: RBI::Node).returns(T::Boolean) }
+  def compatible_with?(_other); end
+
+  sig { void }
+  def detach; end
+
+  sig { returns(RBI::Group::Kind) }
+  def group_kind; end
+
+  sig { returns(T.nilable(RBI::Loc)) }
+  def loc; end
+
+  def loc=(_arg0); end
+
+  sig { params(other: RBI::Node).void }
+  def merge_with(other); end
+
+  sig { returns(T::Boolean) }
+  def oneline?; end
+
+  sig { returns(T.nilable(RBI::ConflictTree)) }
+  def parent_conflict_tree; end
+
+  sig { returns(T.nilable(RBI::Scope)) }
+  def parent_scope; end
+
+  sig { returns(T.nilable(RBI::Tree)) }
+  def parent_tree; end
+
+  def parent_tree=(_arg0); end
+
+  sig { params(out: T.any(IO, StringIO), indent: Integer, print_locs: T::Boolean).void }
+  def print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil)); end
+
+  sig { params(node: RBI::Node).void }
+  def replace(node); end
+
+  sig { params(indent: Integer, print_locs: T::Boolean).returns(String) }
+  def string(indent: T.unsafe(nil), print_locs: T.unsafe(nil)); end
+end
+
+class RBI::NodeWithComments < ::RBI::Node
+  abstract!
+
+  sig { params(loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment]).void }
+  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil)); end
+
+  sig { returns(T::Array[RBI::Comment]) }
+  def comments; end
+
+  def comments=(_arg0); end
+
+  sig { override.params(other: RBI::Node).void }
+  def merge_with(other); end
+
+  sig { override.returns(T::Boolean) }
+  def oneline?; end
+end
+
+class RBI::OptParam < ::RBI::Param
+  sig { params(name: String, value: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::OptParam).void)).void }
+  def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { params(other: T.nilable(Object)).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { override.params(v: RBI::Printer, last: T::Boolean).void }
+  def print_comment_leading_space(v, last:); end
+
+  sig { returns(String) }
+  def value; end
+end
+
+class RBI::Param < ::RBI::NodeWithComments
+  abstract!
+
+  sig { params(name: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment]).void }
+  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil)); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(T::Array[String]) }
+  def comments_lines; end
+
+  sig { returns(String) }
+  def name; end
+
+  sig { params(v: RBI::Printer, last: T::Boolean).void }
+  def print_comment_leading_space(v, last:); end
+
+  sig { override.returns(String) }
+  def to_s; end
+end
+
+class RBI::ParseError < ::StandardError
+  sig { params(message: String, location: RBI::Loc).void }
+  def initialize(message, location); end
+
+  sig { returns(RBI::Loc) }
+  def location; end
+end
+
+class RBI::Parser
+  sig { void }
+  def initialize; end
+
+  sig { params(path: String).returns(RBI::Tree) }
+  def parse_file(path); end
+
+  sig { params(string: String).returns(RBI::Tree) }
+  def parse_string(string); end
+
+  private
+
+  sig { params(content: String, file: String).returns(RBI::Tree) }
+  def parse(content, file:); end
+
+  class << self
+    sig { params(path: String).returns(RBI::Tree) }
+    def parse_file(path); end
+
+    sig { params(string: String).returns(RBI::Tree) }
+    def parse_string(string); end
+  end
+end
+
+class RBI::Printer < ::RBI::Visitor
+  sig { params(out: T.any(IO, StringIO), indent: Integer, print_locs: T::Boolean).void }
+  def initialize(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil)); end
+
+  sig { void }
+  def dedent; end
+
+  def in_visibility_group; end
+  def in_visibility_group=(_arg0); end
+
+  sig { void }
+  def indent; end
+
+  sig { returns(T.nilable(RBI::Node)) }
+  def previous_node; end
+
+  sig { params(string: String).void }
+  def print(string); end
+
+  sig { returns(T::Boolean) }
+  def print_locs; end
+
+  def print_locs=(_arg0); end
+
+  sig { params(string: String).void }
+  def printl(string); end
+
+  sig { params(string: T.nilable(String)).void }
+  def printn(string = T.unsafe(nil)); end
+
+  sig { params(string: T.nilable(String)).void }
+  def printt(string = T.unsafe(nil)); end
+
+  sig { override.params(node: T.nilable(RBI::Node)).void }
+  def visit(node); end
+
+  sig { override.params(nodes: T::Array[RBI::Node]).void }
+  def visit_all(nodes); end
+
+  sig { params(file: RBI::File).void }
+  def visit_file(file); end
+end
+
+class RBI::Private < ::RBI::Visibility
+  sig { params(loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Private).void)).void }
+  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+end
+
+class RBI::Protected < ::RBI::Visibility
+  sig { params(loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Protected).void)).void }
+  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+end
+
+class RBI::Public < ::RBI::Visibility
+  sig { params(loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Public).void)).void }
+  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+end
+
+class RBI::ReqParam < ::RBI::Param
+  sig { params(name: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::ReqParam).void)).void }
+  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { params(other: T.nilable(Object)).returns(T::Boolean) }
+  def ==(other); end
+end
+
+class RBI::RestParam < ::RBI::Param
+  sig { params(name: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::RestParam).void)).void }
+  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { params(other: T.nilable(Object)).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { override.params(v: RBI::Printer, last: T::Boolean).void }
+  def print_comment_leading_space(v, last:); end
+
+  sig { override.returns(String) }
+  def to_s; end
+end
+
+module RBI::Rewriters; end
+
+class RBI::Rewriters::AddSigTemplates < ::RBI::Visitor
+  sig { params(with_todo_comment: T::Boolean).void }
+  def initialize(with_todo_comment: T.unsafe(nil)); end
+
+  sig { override.params(node: T.nilable(RBI::Node)).void }
+  def visit(node); end
+
+  private
+
+  sig { params(attr: RBI::Attr).void }
+  def add_attr_sig(attr); end
+
+  sig { params(method: RBI::Method).void }
+  def add_method_sig(method); end
+
+  sig { params(node: RBI::NodeWithComments).void }
+  def add_todo_comment(node); end
+end
+
+class RBI::Rewriters::GroupNodes < ::RBI::Visitor
+  sig { override.params(node: T.nilable(RBI::Node)).void }
+  def visit(node); end
+end
+
+class RBI::Rewriters::Merge
+  sig { params(left_name: String, right_name: String, keep: RBI::Rewriters::Merge::Keep).void }
+  def initialize(left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
+
+  sig { params(tree: RBI::Tree).returns(T::Array[RBI::Rewriters::Merge::Conflict]) }
+  def merge(tree); end
+
+  sig { returns(RBI::Tree) }
+  def tree; end
+
+  class << self
+    sig { params(left: RBI::Tree, right: RBI::Tree, left_name: String, right_name: String, keep: RBI::Rewriters::Merge::Keep).returns(RBI::Tree) }
+    def merge_trees(left, right, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
+  end
+end
+
+class RBI::Rewriters::Merge::Conflict < ::T::Struct
+  const :left, RBI::Node
+  const :left_name, String
+  const :right, RBI::Node
+  const :right_name, String
+
+  sig { returns(String) }
+  def to_s; end
+
+  class << self
+    def inherited(s); end
+  end
+end
+
+class RBI::Rewriters::Merge::ConflictTreeMerger < ::RBI::Visitor
+  sig { override.params(node: T.nilable(RBI::Node)).void }
+  def visit(node); end
+
+  sig { override.params(nodes: T::Array[RBI::Node]).void }
+  def visit_all(nodes); end
+
+  private
+
+  sig { params(left: RBI::Tree, right: RBI::Tree).void }
+  def merge_conflict_trees(left, right); end
+end
+
+class RBI::Rewriters::Merge::Keep < ::T::Enum
+  enums do
+    NONE = new
+    LEFT = new
+    RIGHT = new
+  end
+end
+
+class RBI::Rewriters::Merge::TreeMerger < ::RBI::Visitor
+  sig { params(output: RBI::Tree, left_name: String, right_name: String, keep: RBI::Rewriters::Merge::Keep).void }
+  def initialize(output, left_name: T.unsafe(nil), right_name: T.unsafe(nil), keep: T.unsafe(nil)); end
+
+  sig { returns(T::Array[RBI::Rewriters::Merge::Conflict]) }
+  def conflicts; end
+
+  sig { override.params(node: T.nilable(RBI::Node)).void }
+  def visit(node); end
+
+  private
+
+  sig { returns(RBI::Tree) }
+  def current_scope; end
+
+  sig { params(left: RBI::Scope, right: RBI::Scope).void }
+  def make_conflict_scope(left, right); end
+
+  sig { params(left: RBI::Node, right: RBI::Node).void }
+  def make_conflict_tree(left, right); end
+
+  sig { params(node: RBI::Node).returns(T.nilable(RBI::Node)) }
+  def previous_definition(node); end
+
+  sig { params(left: RBI::Scope, right: RBI::Scope).returns(RBI::Scope) }
+  def replace_scope_header(left, right); end
+end
+
+class RBI::Rewriters::NestNonPublicMethods < ::RBI::Visitor
+  sig { override.params(node: T.nilable(RBI::Node)).void }
+  def visit(node); end
+end
+
+class RBI::Rewriters::NestSingletonMethods < ::RBI::Visitor
+  sig { override.params(node: T.nilable(RBI::Node)).void }
+  def visit(node); end
+end
+
+class RBI::Rewriters::SortNodes < ::RBI::Visitor
+  sig { override.params(node: T.nilable(RBI::Node)).void }
+  def visit(node); end
+
+  private
+
+  sig { params(kind: RBI::Group::Kind).returns(Integer) }
+  def group_rank(kind); end
+
+  sig { params(node: RBI::Node).returns(T.nilable(String)) }
+  def node_name(node); end
+
+  sig { params(node: RBI::Node).returns(Integer) }
+  def node_rank(node); end
+end
+
+class RBI::Scope < ::RBI::Tree
+  include ::RBI::Indexable
+
+  abstract!
+
+  def initialize(*args, &blk); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(T.self_type) }
+  def dup_empty; end
+
+  sig { abstract.returns(String) }
+  def fully_qualified_name; end
+
+  sig { override.returns(T::Array[String]) }
+  def index_ids; end
+
+  sig { params(v: RBI::Printer).void }
+  def print_body(v); end
+
+  sig { abstract.params(v: RBI::Printer).void }
+  def print_header(v); end
+
+  sig { override.returns(String) }
+  def to_s; end
+end
+
+class RBI::ScopeConflict < ::RBI::Tree
+  sig { params(left: RBI::Scope, right: RBI::Scope, left_name: String, right_name: String).void }
+  def initialize(left:, right:, left_name: T.unsafe(nil), right_name: T.unsafe(nil)); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(RBI::Scope) }
+  def left; end
+
+  sig { override.returns(T::Boolean) }
+  def oneline?; end
+
+  def right; end
+end
+
+class RBI::Sig < ::RBI::Node
+  sig { params(params: T::Array[RBI::SigParam], return_type: T.nilable(String), is_abstract: T::Boolean, is_override: T::Boolean, is_overridable: T::Boolean, type_params: T::Array[String], checked: T.nilable(Symbol), loc: T.nilable(RBI::Loc), block: T.nilable(T.proc.params(node: RBI::Sig).void)).void }
+  def initialize(params: T.unsafe(nil), return_type: T.unsafe(nil), is_abstract: T.unsafe(nil), is_override: T.unsafe(nil), is_overridable: T.unsafe(nil), type_params: T.unsafe(nil), checked: T.unsafe(nil), loc: T.unsafe(nil), &block); end
+
+  sig { params(param: RBI::SigParam).void }
+  def <<(param); end
+
+  sig { params(other: Object).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(T.nilable(Symbol)) }
+  def checked; end
+
+  def checked=(_arg0); end
+
+  sig { returns(T::Boolean) }
+  def inline_params?; end
+
+  sig { returns(T::Boolean) }
+  def is_abstract; end
+
+  def is_abstract=(_arg0); end
+  def is_overridable; end
+  def is_overridable=(_arg0); end
+  def is_override; end
+  def is_override=(_arg0); end
+
+  sig { override.returns(T::Boolean) }
+  def oneline?; end
+
+  sig { returns(T::Array[RBI::SigParam]) }
+  def params; end
+
+  sig { returns(T.nilable(String)) }
+  def return_type; end
+
+  def return_type=(_arg0); end
+
+  sig { returns(T::Array[String]) }
+  def type_params; end
+end
+
+class RBI::SigBuilder < ::RBI::ASTVisitor
+  sig { void }
+  def initialize; end
+
+  sig { returns(RBI::Sig) }
+  def current; end
+
+  def current=(_arg0); end
+
+  sig { override.params(node: T.nilable(AST::Node)).void }
+  def visit(node); end
+
+  sig { params(node: AST::Node).void }
+  def visit_send(node); end
+
+  class << self
+    sig { params(node: AST::Node).returns(RBI::Sig) }
+    def build(node); end
+  end
+end
+
+class RBI::SigParam < ::RBI::NodeWithComments
+  sig { params(name: String, type: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::SigParam).void)).void }
+  def initialize(name, type, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { params(other: Object).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(T::Array[String]) }
+  def comments_lines; end
+
+  sig { returns(String) }
+  def name; end
+
+  sig { params(v: RBI::Printer, last: T::Boolean).void }
+  def print_comment_leading_space(v, last:); end
+
+  def type; end
+end
+
+class RBI::SingletonClass < ::RBI::Scope
+  sig { params(loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::SingletonClass).void)).void }
+  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { override.returns(String) }
+  def fully_qualified_name; end
+
+  sig { override.params(v: RBI::Printer).void }
+  def print_header(v); end
+end
+
+class RBI::Struct < ::RBI::Scope
+  sig { params(name: String, members: T::Array[Symbol], keyword_init: T::Boolean, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(struct: RBI::Struct).void)).void }
+  def initialize(name, members: T.unsafe(nil), keyword_init: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { override.params(other: RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  sig { override.returns(String) }
+  def fully_qualified_name; end
+
+  sig { returns(T::Boolean) }
+  def keyword_init; end
+
+  def keyword_init=(_arg0); end
+
+  sig { returns(T::Array[Symbol]) }
+  def members; end
+
+  def members=(_arg0); end
+
+  sig { returns(String) }
+  def name; end
+
+  def name=(_arg0); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def print_header(v); end
+end
+
+class RBI::TEnum < ::RBI::Class
+  sig { params(name: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(klass: RBI::TEnum).void)).void }
+  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+end
+
+class RBI::TEnumBlock < ::RBI::NodeWithComments
+  include ::RBI::Indexable
+
+  sig { params(names: T::Array[String], loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::TEnumBlock).void)).void }
+  def initialize(names = T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { params(name: String).void }
+  def <<(name); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(T::Boolean) }
+  def empty?; end
+
+  sig { override.returns(T::Array[String]) }
+  def index_ids; end
+
+  sig { override.params(other: RBI::Node).void }
+  def merge_with(other); end
+
+  sig { returns(T::Array[String]) }
+  def names; end
+
+  sig { override.returns(String) }
+  def to_s; end
+end
+
+class RBI::TStruct < ::RBI::Class
+  sig { params(name: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(klass: RBI::TStruct).void)).void }
+  def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+end
+
+class RBI::TStructConst < ::RBI::TStructField
+  include ::RBI::Indexable
+
+  sig { params(name: String, type: String, default: T.nilable(String), loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::TStructConst).void)).void }
+  def initialize(name, type, default: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { override.params(other: RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  sig { override.returns(T::Array[String]) }
+  def fully_qualified_names; end
+
+  sig { override.returns(T::Array[String]) }
+  def index_ids; end
+
+  sig { override.returns(String) }
+  def to_s; end
+end
+
+class RBI::TStructField < ::RBI::NodeWithComments
+  abstract!
+
+  sig { params(name: String, type: String, default: T.nilable(String), loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment]).void }
+  def initialize(name, type, default: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil)); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { override.params(other: RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  sig { returns(T.nilable(String)) }
+  def default; end
+
+  def default=(_arg0); end
+
+  sig { abstract.returns(T::Array[String]) }
+  def fully_qualified_names; end
+
+  sig { returns(String) }
+  def name; end
+
+  def name=(_arg0); end
+  def type; end
+  def type=(_arg0); end
+end
+
+class RBI::TStructProp < ::RBI::TStructField
+  include ::RBI::Indexable
+
+  sig { params(name: String, type: String, default: T.nilable(String), loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::TStructProp).void)).void }
+  def initialize(name, type, default: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { override.params(other: RBI::Node).returns(T::Boolean) }
+  def compatible_with?(other); end
+
+  sig { override.returns(T::Array[String]) }
+  def fully_qualified_names; end
+
+  sig { override.returns(T::Array[String]) }
+  def index_ids; end
+
+  sig { override.returns(String) }
+  def to_s; end
+end
+
+class RBI::Tree < ::RBI::NodeWithComments
+  sig { params(loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Tree).void)).void }
+  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { params(node: RBI::Node).void }
+  def <<(node); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { params(with_todo_comment: T::Boolean).void }
+  def add_sig_templates!(with_todo_comment: T.unsafe(nil)); end
+
+  sig { params(name: String, superclass_name: T.nilable(String), block: T.nilable(T.proc.params(scope: RBI::Scope).void)).void }
+  def create_class(name, superclass_name: T.unsafe(nil), &block); end
+
+  sig { params(name: String, value: String).void }
+  def create_constant(name, value:); end
+
+  sig { params(name: String).void }
+  def create_extend(name); end
+
+  sig { params(name: String).void }
+  def create_include(name); end
+
+  sig { params(name: String, parameters: T::Array[RBI::TypedParam], return_type: String, class_method: T::Boolean).void }
+  def create_method(name, parameters: T.unsafe(nil), return_type: T.unsafe(nil), class_method: T.unsafe(nil)); end
+
+  sig { params(name: String).void }
+  def create_mixes_in_class_methods(name); end
+
+  sig { params(name: String, block: T.nilable(T.proc.params(scope: RBI::Scope).void)).void }
+  def create_module(name, &block); end
+
+  sig { params(constant: Module, block: T.nilable(T.proc.params(scope: RBI::Scope).void)).void }
+  def create_path(constant, &block); end
+
+  sig { params(name: String, value: String).void }
+  def create_type_member(name, value: T.unsafe(nil)); end
+
+  sig { returns(T::Boolean) }
+  def empty?; end
+
+  sig { void }
+  def group_nodes!; end
+
+  sig { returns(RBI::Index) }
+  def index; end
+
+  sig { params(other: RBI::Tree).returns(RBI::Tree) }
+  def merge(other); end
+
+  sig { void }
+  def nest_non_public_methods!; end
+
+  sig { void }
+  def nest_singleton_methods!; end
+
+  sig { returns(T::Array[RBI::Node]) }
+  def nodes; end
+
+  sig { override.returns(T::Boolean) }
+  def oneline?; end
+
+  sig { void }
+  def sort_nodes!; end
+
+  private
+
+  sig { params(node: RBI::Node).returns(RBI::Node) }
+  def create_node(node); end
+
+  sig { returns(T::Hash[String, RBI::Node]) }
+  def nodes_cache; end
+
+  sig { params(name: String).returns(T::Boolean) }
+  def valid_method_name?(name); end
+end
+
+RBI::Tree::SPECIAL_METHOD_NAMES = T.let(T.unsafe(nil), Array)
+
+class RBI::TreeBuilder < ::RBI::ASTVisitor
+  sig { params(file: String, comments: T::Hash[Parser::Source::Map, T::Array[Parser::Source::Comment]]).void }
+  def initialize(file:, comments: T.unsafe(nil)); end
+
+  sig { params(comments: T::Array[Parser::Source::Comment]).void }
+  def assoc_dangling_comments(comments); end
+
+  sig { void }
+  def separate_header_comments; end
+
+  sig { returns(RBI::Tree) }
+  def tree; end
+
+  sig { override.params(node: T.nilable(Object)).void }
+  def visit(node); end
+
+  private
+
+  sig { returns(RBI::Tree) }
+  def current_scope; end
+
+  sig { returns(T::Array[RBI::Sig]) }
+  def current_sigs; end
+
+  sig { params(node: AST::Node).returns(T::Array[RBI::Comment]) }
+  def node_comments(node); end
+
+  sig { params(node: AST::Node).returns(RBI::Loc) }
+  def node_loc(node); end
+
+  sig { params(node: AST::Node).returns(T.nilable(RBI::Node)) }
+  def parse_block(node); end
+
+  sig { params(node: AST::Node).returns(RBI::Node) }
+  def parse_const_assign(node); end
+
+  sig { params(node: AST::Node).returns(RBI::Method) }
+  def parse_def(node); end
+
+  sig { params(node: AST::Node).returns(RBI::TEnumBlock) }
+  def parse_enum(node); end
+
+  sig { params(node: AST::Node).returns(RBI::Param) }
+  def parse_param(node); end
+
+  sig { params(node: AST::Node).returns(RBI::Scope) }
+  def parse_scope(node); end
+
+  sig { params(node: AST::Node).returns(T.nilable(RBI::Node)) }
+  def parse_send(node); end
+
+  sig { params(node: AST::Node).returns(RBI::Sig) }
+  def parse_sig(node); end
+
+  sig { params(node: AST::Node).returns(RBI::Struct) }
+  def parse_struct(node); end
+
+  sig { params(node: AST::Node).returns([String, String, T.nilable(String)]) }
+  def parse_tstruct_prop(node); end
+
+  sig { params(node: AST::Node).returns(T::Boolean) }
+  def struct_definition?(node); end
+end
+
+class RBI::TypeMember < ::RBI::NodeWithComments
+  sig { params(name: String, value: String, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::TypeMember).void)).void }
+  def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(String) }
+  def fully_qualified_name; end
+
+  sig { returns(String) }
+  def name; end
+
+  sig { override.returns(String) }
+  def to_s; end
+
+  def value; end
+end
+
+RBI::VERSION = T.let(T.unsafe(nil), String)
+
+class RBI::Visibility < ::RBI::NodeWithComments
+  abstract!
+
+  sig { params(visibility: Symbol, loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment]).void }
+  def initialize(visibility, loc: T.unsafe(nil), comments: T.unsafe(nil)); end
+
+  sig { params(other: RBI::Visibility).returns(T::Boolean) }
+  def ==(other); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(T::Boolean) }
+  def private?; end
+
+  sig { returns(T::Boolean) }
+  def protected?; end
+
+  sig { returns(T::Boolean) }
+  def public?; end
+
+  sig { returns(Symbol) }
+  def visibility; end
+end
+
+class RBI::VisibilityGroup < ::RBI::Tree
+  sig { params(visibility: RBI::Visibility).void }
+  def initialize(visibility); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { override.returns(T::Boolean) }
+  def oneline?; end
+
+  sig { returns(RBI::Visibility) }
+  def visibility; end
+end
+
+class RBI::Visitor
+  abstract!
+
+  def initialize(*args, &blk); end
+
+  sig { abstract.params(node: T.nilable(RBI::Node)).void }
+  def visit(node); end
+
+  sig { params(nodes: T::Array[RBI::Node]).void }
+  def visit_all(nodes); end
+end
diff --git a/sorbet/rbi/gems/rexml@3.2.4.rbi b/sorbet/rbi/gems/rexml@3.2.4.rbi
deleted file mode 100644
index 5534cd94..00000000
--- a/sorbet/rbi/gems/rexml@3.2.4.rbi
+++ /dev/null
@@ -1,6 +0,0 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca generate
-
-# typed: true
-
-
diff --git a/sorbet/rbi/gems/rexml@3.2.5.rbi b/sorbet/rbi/gems/rexml@3.2.5.rbi
new file mode 100644
index 00000000..6b9fa0c8
--- /dev/null
+++ b/sorbet/rbi/gems/rexml@3.2.5.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rexml` gem.
+# Please instead update this file by running `bin/tapioca gem rexml`.
+
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires
diff --git a/sorbet/rbi/gems/rubocop-sorbet@0.4.0.rbi b/sorbet/rbi/gems/rubocop-sorbet@0.4.0.rbi
new file mode 100644
index 00000000..79b6c0e3
--- /dev/null
+++ b/sorbet/rbi/gems/rubocop-sorbet@0.4.0.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rubocop-sorbet` gem.
+# Please instead update this file by running `bin/tapioca gem rubocop-sorbet`.
+
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires
diff --git a/sorbet/rbi/gems/tapioca@0.5.4.rbi b/sorbet/rbi/gems/tapioca@0.5.4.rbi
new file mode 100644
index 00000000..b37f1569
--- /dev/null
+++ b/sorbet/rbi/gems/tapioca@0.5.4.rbi
@@ -0,0 +1,1112 @@
+# 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 ActiveRecordColumnTypeHelper
+  def initialize(*args, &blk); end
+
+  sig { params(column_name: String).returns([String, String]) }
+  def type_for(column_name); end
+
+  private
+
+  sig { params(constant: Module).returns(T::Boolean) }
+  def do_not_generate_strong_types?(constant); end
+
+  sig { params(column_type: Object).returns(String) }
+  def handle_unknown_type(column_type); end
+
+  def lookup_arg_type_of_method(*args, &blk); end
+  def lookup_return_type_of_method(*args, &blk); end
+end
+
+class DynamicMixinCompiler
+  include ::Tapioca::Reflection
+
+  sig { params(constant: Module).void }
+  def initialize(constant); end
+
+  def class_attribute_predicates; end
+
+  sig { returns(T::Array[Symbol]) }
+  def class_attribute_readers; end
+
+  def class_attribute_writers; end
+
+  sig { params(tree: RBI::Tree).void }
+  def compile_class_attributes(tree); end
+
+  sig { params(tree: RBI::Tree).returns([T::Array[Module], T::Array[Module]]) }
+  def compile_mixes_in_class_methods(tree); end
+
+  sig { returns(T::Array[Module]) }
+  def dynamic_extends; end
+
+  def dynamic_includes; end
+
+  sig { returns(T::Boolean) }
+  def empty_attributes?; end
+
+  def instance_attribute_predicates; end
+
+  sig { returns(T::Array[Symbol]) }
+  def instance_attribute_readers; end
+
+  def instance_attribute_writers; end
+end
+
+module RBI; end
+
+class RBI::File
+  sig { params(strictness: T.nilable(String), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(file: RBI::File).void)).void }
+  def initialize(strictness: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { params(node: RBI::Node).void }
+  def <<(node); end
+
+  sig { params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { returns(T::Array[RBI::Comment]) }
+  def comments; end
+
+  def comments=(_arg0); end
+
+  sig { returns(T::Boolean) }
+  def empty?; end
+
+  sig { params(out: T.any(IO, StringIO), indent: Integer, print_locs: T::Boolean).void }
+  def print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil)); end
+
+  sig { returns(RBI::Tree) }
+  def root; end
+
+  sig { void }
+  def set_empty_body_content; end
+
+  sig { params(command: String, reason: T.nilable(String), display_heading: T::Boolean).void }
+  def set_file_header(command, reason: T.unsafe(nil), display_heading: T.unsafe(nil)); end
+
+  sig { returns(T.nilable(String)) }
+  def strictness; end
+
+  sig { params(indent: Integer, print_locs: T::Boolean).returns(String) }
+  def string(indent: T.unsafe(nil), print_locs: T.unsafe(nil)); end
+
+  sig { void }
+  def transform_rbi!; end
+
+  sig { returns(String) }
+  def transformed_string; end
+end
+
+class RBI::Tree < ::RBI::NodeWithComments
+  sig { params(loc: T.nilable(RBI::Loc), comments: T::Array[RBI::Comment], block: T.nilable(T.proc.params(node: RBI::Tree).void)).void }
+  def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end
+
+  sig { params(node: RBI::Node).void }
+  def <<(node); end
+
+  sig { override.params(v: RBI::Printer).void }
+  def accept_printer(v); end
+
+  sig { params(with_todo_comment: T::Boolean).void }
+  def add_sig_templates!(with_todo_comment: T.unsafe(nil)); end
+
+  sig { params(name: String, superclass_name: T.nilable(String), block: T.nilable(T.proc.params(scope: RBI::Scope).void)).void }
+  def create_class(name, superclass_name: T.unsafe(nil), &block); end
+
+  sig { params(name: String, value: String).void }
+  def create_constant(name, value:); end
+
+  sig { params(name: String).void }
+  def create_extend(name); end
+
+  sig { params(name: String).void }
+  def create_include(name); end
+
+  sig { params(name: String, parameters: T::Array[RBI::TypedParam], return_type: String, class_method: T::Boolean).void }
+  def create_method(name, parameters: T.unsafe(nil), return_type: T.unsafe(nil), class_method: T.unsafe(nil)); end
+
+  sig { params(name: String).void }
+  def create_mixes_in_class_methods(name); end
+
+  sig { params(name: String, block: T.nilable(T.proc.params(scope: RBI::Scope).void)).void }
+  def create_module(name, &block); end
+
+  sig { params(constant: Module, block: T.nilable(T.proc.params(scope: RBI::Scope).void)).void }
+  def create_path(constant, &block); end
+
+  sig { params(name: String, value: String).void }
+  def create_type_member(name, value: T.unsafe(nil)); end
+
+  sig { returns(T::Boolean) }
+  def empty?; end
+
+  sig { void }
+  def group_nodes!; end
+
+  sig { returns(RBI::Index) }
+  def index; end
+
+  sig { params(other: RBI::Tree).returns(RBI::Tree) }
+  def merge(other); end
+
+  sig { void }
+  def nest_non_public_methods!; end
+
+  sig { void }
+  def nest_singleton_methods!; end
+
+  sig { returns(T::Array[RBI::Node]) }
+  def nodes; end
+
+  sig { override.returns(T::Boolean) }
+  def oneline?; end
+
+  sig { void }
+  def sort_nodes!; end
+
+  private
+
+  sig { params(node: RBI::Node).returns(RBI::Node) }
+  def create_node(node); end
+
+  sig { returns(T::Hash[String, RBI::Node]) }
+  def nodes_cache; end
+
+  sig { params(name: String).returns(T::Boolean) }
+  def valid_method_name?(name); end
+end
+
+RBI::Tree::SPECIAL_METHOD_NAMES = T.let(T.unsafe(nil), Array)
+
+class RBI::TypedParam < ::T::Struct
+  const :param, RBI::Param
+  const :type, String
+
+  class << self
+    def inherited(s); end
+  end
+end
+
+RBI::VERSION = T.let(T.unsafe(nil), String)
+
+module T::Generic::TypeStoragePatch
+  def [](*types); end
+  def type_member(variance = T.unsafe(nil), fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: T.unsafe(nil)); end
+  def type_template(variance = T.unsafe(nil), fixed: T.unsafe(nil), lower: T.unsafe(nil), upper: T.unsafe(nil)); end
+end
+
+module T::Types::Simple::GenericNamePatch
+  def name; end
+end
+
+module T::Types::Simple::NamePatch
+  def name; end
+end
+
+module Tapioca
+  class << self
+    def silence_warnings(&blk); end
+  end
+end
+
+class Tapioca::Cli < ::Thor
+  def __print_version; end
+  def dsl(*constants); end
+  def gem(*gems); end
+  def init; end
+  def require; end
+  def todo; end
+
+  class << self
+    def exit_on_failure?; end
+  end
+end
+
+module Tapioca::Compilers; end
+module Tapioca::Compilers::Dsl; end
+
+class Tapioca::Compilers::Dsl::Base
+  include ::Tapioca::Reflection
+
+  abstract!
+
+  sig { void }
+  def initialize; end
+
+  sig { params(error: String).void }
+  def add_error(error); end
+
+  sig { abstract.type_parameters(:T).params(tree: RBI::Tree, constant: T.type_parameter(:T)).void }
+  def decorate(tree, constant); end
+
+  sig { returns(T::Array[String]) }
+  def errors; end
+
+  sig { abstract.returns(T::Enumerable[Module]) }
+  def gather_constants; end
+
+  sig { params(constant: Module).returns(T::Boolean) }
+  def handles?(constant); end
+
+  sig { returns(T::Set[Module]) }
+  def processable_constants; end
+
+  private
+
+  sig { returns(T::Enumerable[Class]) }
+  def all_classes; end
+
+  sig { returns(T::Enumerable[Module]) }
+  def all_modules; end
+
+  sig { params(method_def: T.any(Method, UnboundMethod)).returns(T::Array[RBI::TypedParam]) }
+  def compile_method_parameters_to_rbi(method_def); end
+
+  sig { params(method_def: T.any(Method, UnboundMethod)).returns(String) }
+  def compile_method_return_type_to_rbi(method_def); end
+
+  sig { params(name: String, type: String).returns(RBI::TypedParam) }
+  def create_block_param(name, type:); end
+
+  sig { params(name: String, type: String, default: String).returns(RBI::TypedParam) }
+  def create_kw_opt_param(name, type:, default:); end
+
+  sig { params(name: String, type: String).returns(RBI::TypedParam) }
+  def create_kw_param(name, type:); end
+
+  sig { params(name: String, type: String).returns(RBI::TypedParam) }
+  def create_kw_rest_param(name, type:); end
+
+  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
+
+  sig { params(name: String, type: String, default: String).returns(RBI::TypedParam) }
+  def create_opt_param(name, type:, default:); end
+
+  sig { params(name: String, type: String).returns(RBI::TypedParam) }
+  def create_param(name, type:); end
+
+  sig { params(name: String, type: String).returns(RBI::TypedParam) }
+  def create_rest_param(name, type:); end
+
+  sig { params(param: RBI::Param, type: String).returns(RBI::TypedParam) }
+  def create_typed_param(param, type); end
+
+  sig { params(method_def: T.any(Method, UnboundMethod), signature: T.untyped).returns(T::Array[String]) }
+  def parameters_types_from_signature(method_def, signature); end
+end
+
+Tapioca::Compilers::Dsl::COMPILERS_PATH = T.let(T.unsafe(nil), String)
+
+class Tapioca::Compilers::DslCompiler
+  sig { params(requested_constants: T::Array[Module], requested_generators: T::Array[T.class_of(Tapioca::Compilers::Dsl::Base)], excluded_generators: T::Array[T.class_of(Tapioca::Compilers::Dsl::Base)], error_handler: T.nilable(T.proc.params(error: String).void)).void }
+  def initialize(requested_constants:, requested_generators: T.unsafe(nil), excluded_generators: T.unsafe(nil), error_handler: T.unsafe(nil)); end
+
+  sig { returns(T.proc.params(error: String).void) }
+  def error_handler; end
+
+  sig { returns(T::Enumerable[Tapioca::Compilers::Dsl::Base]) }
+  def generators; end
+
+  sig { returns(T::Array[Module]) }
+  def requested_constants; end
+
+  sig { params(blk: T.proc.params(constant: Module, rbi: RBI::File).void).void }
+  def run(&blk); end
+
+  private
+
+  sig { params(requested_constants: T::Array[Module]).returns(T::Set[Module]) }
+  def gather_constants(requested_constants); end
+
+  sig { params(requested_generators: T::Array[T.class_of(Tapioca::Compilers::Dsl::Base)], excluded_generators: T::Array[T.class_of(Tapioca::Compilers::Dsl::Base)]).returns(T::Enumerable[Tapioca::Compilers::Dsl::Base]) }
+  def gather_generators(requested_generators, excluded_generators); end
+
+  sig { params(constant: Module).returns(T.nilable(RBI::File)) }
+  def rbi_for_constant(constant); end
+
+  sig { params(error: String).returns(T.noreturn) }
+  def report_error(error); end
+end
+
+class Tapioca::Compilers::RequiresCompiler
+  sig { params(sorbet_path: String).void }
+  def initialize(sorbet_path); end
+
+  sig { returns(String) }
+  def compile; end
+
+  private
+
+  sig { params(config: Spoom::Sorbet::Config).returns(T::Array[String]) }
+  def collect_files(config); end
+
+  sig { params(file_path: String).returns(T::Enumerable[String]) }
+  def collect_requires(file_path); end
+
+  sig { params(config: Spoom::Sorbet::Config, file_path: Pathname).returns(T::Boolean) }
+  def file_ignored_by_sorbet?(config, file_path); end
+
+  sig { params(files: T::Enumerable[String], name: String).returns(T::Boolean) }
+  def name_in_project?(files, name); end
+
+  sig { params(path: Pathname).returns(T::Array[String]) }
+  def path_parts(path); end
+end
+
+module Tapioca::Compilers::Sorbet
+  class << self
+    sig { params(args: String).returns(String) }
+    def run(*args); end
+
+    sig { returns(String) }
+    def sorbet_path; end
+
+    sig { params(feature: Symbol, version: T.nilable(Gem::Version)).returns(T::Boolean) }
+    def supports?(feature, version: T.unsafe(nil)); end
+  end
+end
+
+Tapioca::Compilers::Sorbet::EXE_PATH_ENV_VAR = T.let(T.unsafe(nil), String)
+Tapioca::Compilers::Sorbet::FEATURE_REQUIREMENTS = T.let(T.unsafe(nil), Hash)
+Tapioca::Compilers::Sorbet::SORBET = T.let(T.unsafe(nil), Pathname)
+Tapioca::Compilers::Sorbet::SORBET_GEM_SPEC = T.let(T.unsafe(nil), Gem::Specification)
+module Tapioca::Compilers::SymbolTable; end
+
+class Tapioca::Compilers::SymbolTable::SymbolGenerator
+  include ::Tapioca::Reflection
+
+  sig { params(gem: Tapioca::Gemfile::GemSpec, indent: Integer, include_doc: T::Boolean).void }
+  def initialize(gem, indent = T.unsafe(nil), include_doc = T.unsafe(nil)); end
+
+  sig { returns(Tapioca::Gemfile::GemSpec) }
+  def gem; end
+
+  sig { params(rbi: RBI::File).void }
+  def generate(rbi); end
+
+  sig { returns(Integer) }
+  def indent; end
+
+  private
+
+  sig { params(name: String).void }
+  def add_to_alias_namespace(name); end
+
+  sig { params(name: T.nilable(String)).void }
+  def add_to_symbol_queue(name); end
+
+  sig { params(name: String).returns(T::Boolean) }
+  def alias_namespaced?(name); end
+
+  sig { params(tree: RBI::Tree, name: T.nilable(String), constant: BasicObject).void }
+  def compile(tree, name, constant); end
+
+  sig { params(tree: RBI::Tree, name: String, constant: Module).void }
+  def compile_alias(tree, name, constant); end
+
+  sig { params(tree: RBI::Tree, name: String, constant: Module).void }
+  def compile_body(tree, name, constant); end
+
+  sig { params(tree: RBI::Tree, name: String, constant: BasicObject).void }
+  def compile_constant(tree, name, constant); end
+
+  sig { params(tree: RBI::Tree, module_name: String, mod: Module, for_visibility: T::Array[Symbol]).void }
+  def compile_directly_owned_methods(tree, module_name, mod, for_visibility = T.unsafe(nil)); end
+
+  sig { params(tree: RBI::Tree, constant: Module).void }
+  def compile_dynamic_mixins(tree, constant); end
+
+  sig { params(tree: RBI::Tree, constant: Module).void }
+  def compile_enums(tree, constant); end
+
+  sig { params(tree: RBI::Tree, symbol_name: String, constant: Module, method: T.nilable(UnboundMethod), visibility: RBI::Visibility).void }
+  def compile_method(tree, symbol_name, constant, method, visibility = T.unsafe(nil)); end
+
+  sig { params(tree: RBI::Tree, name: String, constant: Module).void }
+  def compile_methods(tree, name, constant); end
+
+  sig { params(tree: RBI::Tree, constant: Module).void }
+  def compile_mixins(tree, constant); end
+
+  sig { params(tree: RBI::Tree, name: String, constant: Module).void }
+  def compile_module(tree, name, constant); end
+
+  sig { params(tree: RBI::Tree, constant: Module).void }
+  def compile_module_helpers(tree, constant); end
+
+  sig { params(tree: RBI::Tree, name: String, value: BasicObject).void }
+  def compile_object(tree, name, value); end
+
+  sig { params(tree: RBI::Tree, constant: Module).void }
+  def compile_props(tree, constant); end
+
+  sig { params(signature: T.untyped, parameters: T::Array[[Symbol, String]]).returns(RBI::Sig) }
+  def compile_signature(signature, parameters); end
+
+  sig { params(tree: RBI::Tree, name: String, constant: Module).void }
+  def compile_subconstants(tree, name, constant); end
+
+  sig { params(constant: Class).returns(T.nilable(String)) }
+  def compile_superclass(constant); end
+
+  sig { params(tree: RBI::Tree, constant: Module).void }
+  def compile_type_variable_declarations(tree, constant); end
+
+  sig { params(tree: RBI::Tree, constant: Module).void }
+  def compile_type_variables(tree, constant); end
+
+  sig { params(constant: Module, strict: T::Boolean).returns(T::Boolean) }
+  def defined_in_gem?(constant, strict: T.unsafe(nil)); end
+
+  sig { params(name: String).returns(T::Array[RBI::Comment]) }
+  def documentation_comments(name); end
+
+  sig { params(symbols: T::Set[String]).returns(T::Set[String]) }
+  def engine_symbols(symbols); end
+
+  sig { params(tree: RBI::Tree, symbol: String).void }
+  def generate_from_symbol(tree, symbol); end
+
+  sig { params(constant: T.all(Module, T::Generic)).returns(String) }
+  def generic_name_of(constant); end
+
+  sig { params(constant: Module).returns(T::Array[String]) }
+  def get_file_candidates(constant); end
+
+  sig { params(constant: Module).returns(T.nilable(UnboundMethod)) }
+  def initialize_method_for(constant); end
+
+  sig { params(constant: Module).returns(T::Array[Module]) }
+  def interesting_ancestors_of(constant); end
+
+  sig { params(name: String).void }
+  def mark_seen(name); end
+
+  sig { params(method: UnboundMethod).returns(T::Boolean) }
+  def method_in_gem?(method); end
+
+  sig { params(mod: Module).returns(T::Hash[Symbol, T::Array[Symbol]]) }
+  def method_names_by_visibility(mod); end
+
+  sig { params(constant: Module).returns(T.nilable(String)) }
+  def name_of(constant); end
+
+  sig { params(constant: Module, class_name: T.nilable(String)).returns(T.nilable(String)) }
+  def name_of_proxy_target(constant, class_name); end
+
+  sig { params(symbol: String, inherit: T::Boolean, namespace: Module).returns(BasicObject) }
+  def resolve_constant(symbol, inherit: T.unsafe(nil), namespace: T.unsafe(nil)); end
+
+  sig { params(sig_string: String).returns(String) }
+  def sanitize_signature_types(sig_string); end
+
+  sig { params(name: String).returns(T::Boolean) }
+  def seen?(name); end
+
+  sig { params(constant: Module, method_name: String).returns(T::Boolean) }
+  def struct_method?(constant, method_name); end
+
+  sig { params(symbol_name: String).returns(T::Boolean) }
+  def symbol_ignored?(symbol_name); end
+
+  sig { returns(T::Set[String]) }
+  def symbols; end
+
+  sig { params(name: String).returns(T::Boolean) }
+  def valid_method_name?(name); end
+end
+
+Tapioca::Compilers::SymbolTable::SymbolGenerator::IGNORED_COMMENTS = T.let(T.unsafe(nil), Array)
+Tapioca::Compilers::SymbolTable::SymbolGenerator::IGNORED_SYMBOLS = T.let(T.unsafe(nil), Array)
+Tapioca::Compilers::SymbolTable::SymbolGenerator::SPECIAL_METHOD_NAMES = T.let(T.unsafe(nil), Array)
+Tapioca::Compilers::SymbolTable::SymbolGenerator::TYPE_PARAMETER_MATCHER = T.let(T.unsafe(nil), Regexp)
+
+module Tapioca::Compilers::SymbolTable::SymbolLoader
+  class << self
+    def ignore_symbol?(symbol); end
+
+    sig { params(paths: T::Array[Pathname]).returns(T::Set[String]) }
+    def list_from_paths(paths); end
+
+    private
+
+    def ignored_symbols; end
+
+    sig { params(paths: T::Array[String]).returns(T::Set[String]) }
+    def load_symbols(paths); end
+
+    def symbol_table_json_from(input, table_type: T.unsafe(nil)); end
+  end
+end
+
+class Tapioca::Compilers::SymbolTable::SymbolLoader::SymbolTableParser
+  class << self
+    def parse(object, parents = T.unsafe(nil)); end
+  end
+end
+
+class Tapioca::Compilers::SymbolTableCompiler
+  sig { params(gem: Tapioca::Gemfile::GemSpec, rbi: RBI::File, indent: Integer, include_docs: T::Boolean).void }
+  def compile(gem, rbi, indent = T.unsafe(nil), include_docs = T.unsafe(nil)); end
+end
+
+class Tapioca::Compilers::TodosCompiler
+  sig { returns(String) }
+  def compile; end
+
+  private
+
+  sig { returns(String) }
+  def list_todos; end
+end
+
+class Tapioca::Config < ::T::Struct
+  const :doc, T::Boolean, default: T.unsafe(nil)
+  const :exclude, T::Array[String]
+  const :exclude_generators, T::Array[String]
+  const :file_header, T::Boolean, default: T.unsafe(nil)
+  const :generators, T::Array[String]
+  const :outdir, String
+  const :postrequire, String
+  const :prerequire, T.nilable(String)
+  const :todos_path, String
+  const :typed_overrides, T::Hash[String, String]
+
+  sig { returns(Pathname) }
+  def outpath; end
+
+  class << self
+    def inherited(s); end
+  end
+end
+
+Tapioca::Config::DEFAULT_COMMAND = T.let(T.unsafe(nil), String)
+Tapioca::Config::DEFAULT_DSLDIR = T.let(T.unsafe(nil), String)
+Tapioca::Config::DEFAULT_GEMDIR = T.let(T.unsafe(nil), String)
+Tapioca::Config::DEFAULT_OVERRIDES = T.let(T.unsafe(nil), Hash)
+Tapioca::Config::DEFAULT_POSTREQUIRE = T.let(T.unsafe(nil), String)
+Tapioca::Config::DEFAULT_RBIDIR = T.let(T.unsafe(nil), String)
+Tapioca::Config::DEFAULT_TODOSPATH = T.let(T.unsafe(nil), String)
+Tapioca::Config::SORBET_CONFIG = T.let(T.unsafe(nil), String)
+Tapioca::Config::SORBET_PATH = T.let(T.unsafe(nil), String)
+Tapioca::Config::TAPIOCA_CONFIG = T.let(T.unsafe(nil), String)
+Tapioca::Config::TAPIOCA_PATH = T.let(T.unsafe(nil), String)
+
+class Tapioca::ConfigBuilder
+  class << self
+    sig { params(command: Symbol, options: T::Hash[String, T.untyped]).returns(Tapioca::Config) }
+    def from_options(command, options); end
+
+    private
+
+    sig { returns(T::Hash[String, T.untyped]) }
+    def config_options; end
+
+    sig { params(command: Symbol).returns(T::Hash[String, T.untyped]) }
+    def default_options(command); end
+
+    sig { params(options: T::Hash[String, T.untyped]).returns(T::Hash[String, T.untyped]) }
+    def merge_options(*options); end
+  end
+end
+
+Tapioca::ConfigBuilder::DEFAULT_OPTIONS = T.let(T.unsafe(nil), Hash)
+
+module Tapioca::ConstantLocator
+  extend ::Tapioca::Reflection
+
+  class << self
+    def files_for(klass); end
+  end
+end
+
+class Tapioca::Error < ::StandardError; end
+
+class Tapioca::Gemfile
+  sig { void }
+  def initialize; end
+
+  sig { returns(Bundler::Definition) }
+  def definition; end
+
+  sig { returns(T::Array[Tapioca::Gemfile::GemSpec]) }
+  def dependencies; end
+
+  sig { params(gem_name: String).returns(T.nilable(Tapioca::Gemfile::GemSpec)) }
+  def gem(gem_name); end
+
+  sig { returns(T::Array[String]) }
+  def missing_specs; end
+
+  sig { void }
+  def require_bundle; end
+
+  private
+
+  sig { returns(String) }
+  def dir; end
+
+  sig { returns(File) }
+  def gemfile; end
+
+  sig { returns(T::Array[Symbol]) }
+  def groups; end
+
+  sig { returns([T::Array[Tapioca::Gemfile::GemSpec], T::Array[String]]) }
+  def load_dependencies; end
+
+  def lockfile; end
+
+  sig { returns([T::Enumerable[T.any(Bundler::StubSpecification, Gem::Specification)], T::Array[String]]) }
+  def materialize_deps; end
+
+  sig { returns(Bundler::Runtime) }
+  def runtime; end
+end
+
+class Tapioca::Gemfile::GemSpec
+  sig { params(spec: T.any(Bundler::StubSpecification, Gem::Specification)).void }
+  def initialize(spec); end
+
+  sig { params(path: String).returns(T::Boolean) }
+  def contains_path?(path); end
+
+  sig { returns(T::Array[Pathname]) }
+  def files; end
+
+  sig { returns(String) }
+  def full_gem_path; end
+
+  sig { params(gemfile_dir: String).returns(T::Boolean) }
+  def ignore?(gemfile_dir); end
+
+  sig { returns(String) }
+  def name; end
+
+  sig { void }
+  def parse_yard_docs; end
+
+  sig { returns(String) }
+  def rbi_file_name; end
+
+  def version; end
+
+  private
+
+  sig { returns(T::Boolean) }
+  def default_gem?; end
+
+  sig { returns(T::Boolean) }
+  def gem_ignored?; end
+
+  sig { params(gemfile_dir: String).returns(T::Boolean) }
+  def gem_in_app_dir?(gemfile_dir); end
+
+  sig { returns(T::Boolean) }
+  def gem_in_bundle_path?; end
+
+  sig { params(path: String).returns(T::Boolean) }
+  def has_parent_gemspec?(path); end
+
+  sig { returns(Pathname) }
+  def ruby_lib_dir; end
+
+  sig { params(path: T.any(Pathname, String)).returns(String) }
+  def to_realpath(path); end
+
+  sig { returns(String) }
+  def version_string; end
+end
+
+Tapioca::Gemfile::GemSpec::IGNORED_GEMS = T.let(T.unsafe(nil), Array)
+Tapioca::Gemfile::Spec = T.type_alias { T.any(Bundler::StubSpecification, Gem::Specification) }
+module Tapioca::Generators; end
+
+class Tapioca::Generators::Base
+  include ::Thor::Base
+  include ::Thor::Invocation
+  include ::Thor::Shell
+  extend ::Thor::Base::ClassMethods
+  extend ::Thor::Invocation::ClassMethods
+
+  abstract!
+
+  sig { params(default_command: String, file_writer: Thor::Actions).void }
+  def initialize(default_command:, file_writer: T.unsafe(nil)); end
+
+  sig { abstract.void }
+  def generate; end
+
+  private
+
+  sig { params(path: T.any(Pathname, String), content: String, force: T::Boolean, skip: T::Boolean, verbose: T::Boolean).void }
+  def create_file(path, content, force: T.unsafe(nil), skip: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  sig { params(message: String, color: T.any(Symbol, T::Array[Symbol])).void }
+  def say_error(message = T.unsafe(nil), *color); end
+end
+
+class Tapioca::Generators::Base::FileWriter < ::Thor
+  include ::Thor::Actions
+  extend ::Thor::Actions::ClassMethods
+end
+
+class Tapioca::Generators::Dsl < ::Tapioca::Generators::Base
+  sig { params(requested_constants: T::Array[String], outpath: Pathname, generators: T::Array[String], exclude_generators: T::Array[String], file_header: T::Boolean, compiler_path: String, tapioca_path: String, default_command: String, file_writer: Thor::Actions, should_verify: T::Boolean, quiet: T::Boolean, verbose: T::Boolean).void }
+  def initialize(requested_constants:, outpath:, generators:, exclude_generators:, file_header:, compiler_path:, tapioca_path:, default_command:, file_writer: T.unsafe(nil), should_verify: T.unsafe(nil), quiet: T.unsafe(nil), verbose: T.unsafe(nil)); end
+
+  sig { override.void }
+  def generate; end
+
+  private
+
+  sig { void }
+  def abort_if_pending_migrations!; end
+
+  sig { params(cause: Symbol, files: T::Array[String]).returns(String) }
+  def build_error_for_files(cause, files); end
+
+  sig { params(constant_name: String, rbi: RBI::File, outpath: Pathname, quiet: T::Boolean).returns(T.nilable(Pathname)) }
+  def compile_dsl_rbi(constant_name, rbi, outpath: T.unsafe(nil), quiet: T.unsafe(nil)); end
+
+  sig { params(constant_names: T::Array[String]).returns(T::Array[Module]) }
+  def constantize(constant_names); end
+
+  sig { params(generator_names: T::Array[String]).returns(T::Array[T.class_of(Tapioca::Compilers::Dsl::Base)]) }
+  def constantize_generators(generator_names); end
+
+  sig { params(constant_name: String).returns(Pathname) }
+  def dsl_rbi_filename(constant_name); end
+
+  sig { params(requested_constants: T::Array[String], path: Pathname).returns(T::Set[Pathname]) }
+  def existing_rbi_filenames(requested_constants, path: T.unsafe(nil)); end
+
+  sig { params(constant: String).returns(String) }
+  def generate_command_for(constant); end
+
+  sig { params(eager_load: T::Boolean).void }
+  def load_application(eager_load:); end
+
+  sig { void }
+  def load_dsl_generators; end
+
+  sig { returns(Tapioca::Loader) }
+  def loader; end
+
+  sig { params(dir: Pathname).void }
+  def perform_dsl_verification(dir); end
+
+  sig { params(files: T::Set[Pathname]).void }
+  def purge_stale_dsl_rbi_files(files); end
+
+  sig { params(constant: String).returns(String) }
+  def rbi_filename_for(constant); end
+
+  sig { params(path: Pathname).returns(T::Array[Pathname]) }
+  def rbi_files_in(path); end
+
+  sig { params(filename: Pathname).void }
+  def remove(filename); end
+
+  sig { params(diff: T::Hash[String, Symbol], command: String).void }
+  def report_diff_and_exit_if_out_of_date(diff, command); end
+
+  sig { params(class_name: String).returns(String) }
+  def underscore(class_name); end
+
+  sig { params(tmp_dir: Pathname).returns(T::Hash[String, Symbol]) }
+  def verify_dsl_rbi(tmp_dir:); end
+end
+
+class Tapioca::Generators::Gem < ::Tapioca::Generators::Base
+  sig { params(gem_names: T::Array[String], gem_excludes: T::Array[String], prerequire: T.nilable(String), postrequire: String, typed_overrides: T::Hash[String, String], default_command: String, outpath: Pathname, file_header: T::Boolean, doc: T::Boolean, file_writer: Thor::Actions).void }
+  def initialize(gem_names:, gem_excludes:, prerequire:, postrequire:, typed_overrides:, default_command:, outpath:, file_header:, doc:, file_writer: T.unsafe(nil)); end
+
+  sig { override.void }
+  def generate; end
+
+  sig { params(should_verify: T::Boolean).void }
+  def sync(should_verify: T.unsafe(nil)); end
+
+  private
+
+  sig { returns(T::Array[String]) }
+  def added_rbis; end
+
+  sig { params(cause: Symbol, files: T::Array[String]).returns(String) }
+  def build_error_for_files(cause, files); end
+
+  sig { returns(Tapioca::Gemfile) }
+  def bundle; end
+
+  sig { params(gem: Tapioca::Gemfile::GemSpec).void }
+  def compile_gem_rbi(gem); end
+
+  sig { params(gem_name: String).returns(Pathname) }
+  def existing_rbi(gem_name); end
+
+  sig { returns(T::Hash[String, String]) }
+  def existing_rbis; end
+
+  sig { params(gem_name: String).returns(Pathname) }
+  def expected_rbi(gem_name); end
+
+  sig { returns(T::Hash[String, String]) }
+  def expected_rbis; end
+
+  sig { params(file: String, error: LoadError).void }
+  def explain_failed_require(file, error); end
+
+  sig { params(gem_name: String).returns(T::Boolean) }
+  def gem_rbi_exists?(gem_name); end
+
+  sig { params(gem_name: String, version: String).returns(Pathname) }
+  def gem_rbi_filename(gem_name, version); end
+
+  sig { params(gem_names: T::Array[String]).returns(T::Array[Tapioca::Gemfile::GemSpec]) }
+  def gems_to_generate(gem_names); end
+
+  sig { returns(Tapioca::Loader) }
+  def loader; end
+
+  sig { params(old_filename: Pathname, new_filename: Pathname).void }
+  def move(old_filename, new_filename); end
+
+  sig { void }
+  def perform_additions; end
+
+  sig { void }
+  def perform_removals; end
+
+  sig { void }
+  def perform_sync_verification; end
+
+  sig { params(filename: Pathname).void }
+  def remove(filename); end
+
+  sig { returns(T::Array[String]) }
+  def removed_rbis; end
+
+  sig { params(diff: T::Hash[String, Symbol], command: String).void }
+  def report_diff_and_exit_if_out_of_date(diff, command); end
+
+  sig { void }
+  def require_gem_file; end
+end
+
+class Tapioca::Generators::Init < ::Tapioca::Generators::Base
+  sig { params(sorbet_config: String, default_postrequire: String, default_command: String, file_writer: Thor::Actions).void }
+  def initialize(sorbet_config:, default_postrequire:, default_command:, file_writer: T.unsafe(nil)); end
+
+  sig { override.void }
+  def generate; end
+
+  private
+
+  sig { void }
+  def create_config; end
+
+  sig { void }
+  def create_post_require; end
+
+  sig { void }
+  def generate_binstub; end
+
+  sig { void }
+  def generate_binstub!; end
+
+  sig { returns(Bundler::Installer) }
+  def installer; end
+
+  sig { returns(Bundler::StubSpecification) }
+  def spec; end
+end
+
+class Tapioca::Generators::Require < ::Tapioca::Generators::Base
+  sig { params(requires_path: String, sorbet_config_path: String, default_command: String, file_writer: Thor::Actions).void }
+  def initialize(requires_path:, sorbet_config_path:, default_command:, file_writer: T.unsafe(nil)); end
+
+  sig { override.void }
+  def generate; end
+end
+
+class Tapioca::Generators::Todo < ::Tapioca::Generators::Base
+  sig { params(todos_path: String, file_header: T::Boolean, default_command: String, file_writer: Thor::Actions).void }
+  def initialize(todos_path:, file_header:, default_command:, file_writer: T.unsafe(nil)); end
+
+  sig { override.void }
+  def generate; end
+
+  sig { params(command: String, reason: T.nilable(String), strictness: T.nilable(String)).returns(String) }
+  def rbi_header(command, reason: T.unsafe(nil), strictness: T.unsafe(nil)); end
+end
+
+module Tapioca::GenericTypeRegistry
+  class << self
+    sig { params(constant: Module).returns(T.nilable(T::Hash[T.any(Tapioca::TypeMember, Tapioca::TypeTemplate), String])) }
+    def lookup_type_variables(constant); end
+
+    sig { params(constant: T.untyped, types: T.untyped).returns(Module) }
+    def register_type(constant, types); end
+
+    sig { params(constant: T.untyped, type_variable: T.any(Tapioca::TypeMember, Tapioca::TypeTemplate)).void }
+    def register_type_variable(constant, type_variable); end
+
+    private
+
+    sig { params(constant: Module, name: String).returns(Module) }
+    def create_generic_type(constant, name); end
+
+    sig { params(constant: Class).returns(Class) }
+    def create_safe_subclass(constant); end
+
+    sig { params(constant: Module).returns(T::Hash[T.any(Tapioca::TypeMember, Tapioca::TypeTemplate), String]) }
+    def lookup_or_initialize_type_variables(constant); end
+  end
+end
+
+Tapioca::GenericTypeRegistry::TypeVariable = T.type_alias { T.any(Tapioca::TypeMember, Tapioca::TypeTemplate) }
+
+class Tapioca::Loader
+  sig { params(gemfile: Tapioca::Gemfile, initialize_file: T.nilable(String), require_file: T.nilable(String)).void }
+  def load_bundle(gemfile, initialize_file, require_file); end
+
+  sig { params(environment_load: T::Boolean, eager_load: T::Boolean).void }
+  def load_rails_application(environment_load: T.unsafe(nil), eager_load: T.unsafe(nil)); end
+
+  private
+
+  sig { void }
+  def eager_load_rails_app; end
+
+  sig { void }
+  def load_rails_engines; end
+
+  sig { returns(T::Array[T.untyped]) }
+  def rails_engines; end
+
+  sig { params(file: T.nilable(String)).void }
+  def require_helper(file); end
+
+  sig { params(path: String).void }
+  def safe_require(path); end
+
+  sig { void }
+  def silence_deprecations; end
+end
+
+module Tapioca::Reflection
+  extend ::Tapioca::Reflection
+
+  sig { params(constant: Module).returns(T::Array[Module]) }
+  def ancestors_of(constant); end
+
+  sig { params(object: BasicObject, other: BasicObject).returns(T::Boolean) }
+  def are_equal?(object, other); end
+
+  sig { params(object: BasicObject).returns(Class) }
+  def class_of(object); end
+
+  sig { params(constant: Module).returns(T::Array[Symbol]) }
+  def constants_of(constant); end
+
+  sig { type_parameters(:U).params(klass: T.type_parameter(:U)).returns(T::Array[T.type_parameter(:U)]) }
+  def descendants_of(klass); end
+
+  sig { params(constant: Module).returns(T::Array[Module]) }
+  def inherited_ancestors_of(constant); end
+
+  sig { params(constant: Module, method: Symbol).returns(Method) }
+  def method_of(constant, method); end
+
+  sig { params(constant: Module).returns(T.nilable(String)) }
+  def name_of(constant); end
+
+  sig { params(type: T::Types::Base).returns(String) }
+  def name_of_type(type); end
+
+  sig { params(object: BasicObject).returns(Integer) }
+  def object_id_of(object); end
+
+  sig { params(constant: Module).returns(T::Array[Symbol]) }
+  def private_instance_methods_of(constant); end
+
+  sig { params(constant: Module).returns(T::Array[Symbol]) }
+  def protected_instance_methods_of(constant); end
+
+  sig { params(constant: Module).returns(T::Array[Symbol]) }
+  def public_instance_methods_of(constant); end
+
+  sig { params(constant: Module).returns(T.nilable(String)) }
+  def qualified_name_of(constant); end
+
+  sig { params(method: T.any(Method, UnboundMethod)).returns(T.untyped) }
+  def signature_of(method); end
+
+  sig { params(constant: Module).returns(Class) }
+  def singleton_class_of(constant); end
+
+  sig { params(constant: Class).returns(T.nilable(Class)) }
+  def superclass_of(constant); end
+end
+
+Tapioca::Reflection::ANCESTORS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+Tapioca::Reflection::CLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+Tapioca::Reflection::CONSTANTS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+Tapioca::Reflection::EQUAL_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+Tapioca::Reflection::METHOD_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+Tapioca::Reflection::NAME_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+Tapioca::Reflection::OBJECT_ID_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+Tapioca::Reflection::PRIVATE_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+Tapioca::Reflection::PROTECTED_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+Tapioca::Reflection::PUBLIC_INSTANCE_METHODS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+Tapioca::Reflection::SINGLETON_CLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+Tapioca::Reflection::SUPERCLASS_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+class Tapioca::TypeMember < ::T::Types::TypeMember
+  sig { params(variance: Symbol, fixed: T.untyped, lower: T.untyped, upper: T.untyped).void }
+  def initialize(variance, fixed, lower, upper); end
+
+  sig { returns(T.untyped) }
+  def fixed; end
+
+  def lower; end
+
+  sig { returns(T.nilable(String)) }
+  def name; end
+
+  def name=(_arg0); end
+
+  sig { returns(String) }
+  def serialize; end
+
+  def upper; end
+end
+
+class Tapioca::TypeTemplate < ::T::Types::TypeTemplate
+  sig { params(variance: Symbol, fixed: T.untyped, lower: T.untyped, upper: T.untyped).void }
+  def initialize(variance, fixed, lower, upper); end
+
+  sig { returns(T.untyped) }
+  def fixed; end
+
+  def lower; end
+
+  sig { returns(T.nilable(String)) }
+  def name; end
+
+  def name=(_arg0); end
+
+  sig { returns(String) }
+  def serialize; end
+
+  def upper; end
+end
+
+Tapioca::VERSION = T.let(T.unsafe(nil), String)
diff --git a/sorbet/rbi/gems/thor@1.0.1.rbi b/sorbet/rbi/gems/thor@1.1.0.rbi
similarity index 60%
rename from sorbet/rbi/gems/thor@1.0.1.rbi
rename to sorbet/rbi/gems/thor@1.1.0.rbi
index 56471ab1..e5f5ab44 100644
--- a/sorbet/rbi/gems/thor@1.0.1.rbi
+++ b/sorbet/rbi/gems/thor@1.1.0.rbi
@@ -1,61 +1,84 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   tapioca generate
-
 # typed: true
 
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `thor` gem.
+# Please instead update this file by running `bin/tapioca gem thor`.
+
 class Thor
-  include(::Thor::Base)
-  include(::Thor::Invocation)
-  include(::Thor::Shell)
-  extend(::Thor::Base::ClassMethods)
-  extend(::Thor::Invocation::ClassMethods)
-
-  def help(command = _, subcommand = _); end
-
-  def self.check_unknown_options!(options = _); end
-  def self.check_unknown_options?(config); end
-  def self.command_help(shell, command_name); end
-  def self.default_command(meth = _); end
-  def self.default_task(meth = _); end
-  def self.deprecation_warning(message); end
-  def self.desc(usage, description, options = _); end
-  def self.disable_required_check!(*command_names); end
-  def self.disable_required_check?(command); end
-  def self.help(shell, subcommand = _); end
-  def self.long_desc(long_description, options = _); end
-  def self.map(mappings = _, **kw); end
-  def self.method_option(name, options = _); end
-  def self.method_options(options = _); end
-  def self.option(name, options = _); end
-  def self.options(options = _); end
-  def self.package_name(name, _ = T.unsafe(nil)); end
-  def self.printable_commands(all = _, subcommand = _); end
-  def self.printable_tasks(all = _, subcommand = _); end
-  def self.register(klass, subcommand_name, usage, description, options = _); end
-  def self.stop_on_unknown_option!(*command_names); end
-  def self.stop_on_unknown_option?(command); end
-  def self.subcommand(subcommand, subcommand_class); end
-  def self.subcommand_classes; end
-  def self.subcommands; end
-  def self.subtask(subcommand, subcommand_class); end
-  def self.subtasks; end
-  def self.task_help(shell, command_name); end
+  include ::Thor::Base
+  include ::Thor::Invocation
+  include ::Thor::Shell
+  extend ::Thor::Base::ClassMethods
+  extend ::Thor::Invocation::ClassMethods
+
+  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+
+  class << self
+    def check_unknown_options!(options = T.unsafe(nil)); end
+    def check_unknown_options?(config); end
+    def command_help(shell, command_name); end
+    def default_command(meth = T.unsafe(nil)); end
+    def default_task(meth = T.unsafe(nil)); end
+    def deprecation_warning(message); end
+    def desc(usage, description, options = T.unsafe(nil)); end
+    def disable_required_check!(*command_names); end
+    def disable_required_check?(command); end
+    def help(shell, subcommand = T.unsafe(nil)); end
+    def long_desc(long_description, options = T.unsafe(nil)); end
+    def map(mappings = T.unsafe(nil), **kw); end
+    def method_option(name, options = T.unsafe(nil)); end
+    def method_options(options = T.unsafe(nil)); end
+    def option(name, options = T.unsafe(nil)); end
+    def options(options = T.unsafe(nil)); end
+    def package_name(name, _ = T.unsafe(nil)); end
+    def printable_commands(all = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+    def printable_tasks(all = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+    def register(klass, subcommand_name, usage, description, options = T.unsafe(nil)); end
+    def stop_on_unknown_option!(*command_names); end
+    def stop_on_unknown_option?(command); end
+    def subcommand(subcommand, subcommand_class); end
+    def subcommand_classes; end
+    def subcommands; end
+    def subtask(subcommand, subcommand_class); end
+    def subtasks; end
+    def task_help(shell, command_name); end
+
+    protected
+
+    def banner(command, namespace = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+    def baseclass; end
+    def create_command(meth); end
+    def create_task(meth); end
+    def disable_required_check; end
+    def dispatch(meth, given_args, given_opts, config); end
+    def dynamic_command_class; end
+    def find_command_possibilities(meth); end
+    def find_task_possibilities(meth); end
+    def initialize_added; end
+    def normalize_command_name(meth); end
+    def normalize_task_name(meth); end
+    def retrieve_command_name(args); end
+    def retrieve_task_name(args); end
+    def stop_on_unknown_option; end
+    def subcommand_help(cmd); end
+    def subtask_help(cmd); end
+  end
 end
 
 module Thor::Actions
-  mixes_in_class_methods(::Thor::Actions::ClassMethods)
+  mixes_in_class_methods ::Thor::Actions::ClassMethods
 
-  def initialize(args = _, options = _, config = _); end
+  def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil)); end
 
   def action(instance); end
   def add_file(destination, *args, &block); end
   def add_link(destination, *args); end
   def append_file(path, *args, &block); end
   def append_to_file(path, *args, &block); end
-  def apply(path, config = _); end
+  def apply(path, config = T.unsafe(nil)); end
   def behavior; end
-  def behavior=(_); end
-  def chmod(path, mode, config = _); end
+  def behavior=(_arg0); end
+  def chmod(path, mode, config = T.unsafe(nil)); end
   def comment_lines(path, flag, *args); end
   def copy_file(source, *args, &block); end
   def create_file(destination, *args, &block); end
@@ -63,7 +86,7 @@ module Thor::Actions
   def destination_root; end
   def destination_root=(root); end
   def directory(source, *args, &block); end
-  def empty_directory(destination, config = _); end
+  def empty_directory(destination, config = T.unsafe(nil)); end
   def find_in_source_paths(file); end
   def get(source, *args, &block); end
   def gsub_file(path, flag, *args, &block); end
@@ -72,15 +95,15 @@ module Thor::Actions
   def inject_into_file(destination, *args, &block); end
   def inject_into_module(path, module_name, *args, &block); end
   def insert_into_file(destination, *args, &block); end
-  def inside(dir = _, config = _, &block); end
+  def inside(dir = T.unsafe(nil), config = T.unsafe(nil), &block); end
   def link_file(source, *args); end
   def prepend_file(path, *args, &block); end
   def prepend_to_file(path, *args, &block); end
-  def relative_to_original_destination_root(path, remove_dot = _); end
-  def remove_dir(path, config = _); end
-  def remove_file(path, config = _); end
-  def run(command, config = _); end
-  def run_ruby_script(command, config = _); end
+  def relative_to_original_destination_root(path, remove_dot = T.unsafe(nil)); end
+  def remove_dir(path, config = T.unsafe(nil)); end
+  def remove_file(path, config = T.unsafe(nil)); end
+  def run(command, config = T.unsafe(nil)); end
+  def run_ruby_script(command, config = T.unsafe(nil)); end
   def source_paths; end
   def template(source, *args, &block); end
   def thor(command, *args); end
@@ -96,25 +119,27 @@ module Thor::Actions
   def capture(*args); end
   def concat(string); end
   def output_buffer; end
-  def output_buffer=(_); end
-  def with_output_buffer(buf = _); end
+  def output_buffer=(_arg0); end
+  def with_output_buffer(buf = T.unsafe(nil)); end
 
-  def self.included(base); end
+  class << self
+    def included(base); end
+  end
 end
 
 class Thor::Actions::CapturableERB < ::ERB
-  def set_eoutvar(compiler, eoutvar = _); end
+  def set_eoutvar(compiler, eoutvar = T.unsafe(nil)); end
 end
 
 module Thor::Actions::ClassMethods
   def add_runtime_options!; end
   def source_paths; end
   def source_paths_for_search; end
-  def source_root(path = _); end
+  def source_root(path = T.unsafe(nil)); end
 end
 
 class Thor::Actions::CreateFile < ::Thor::Actions::EmptyDirectory
-  def initialize(base, destination, data, config = _); end
+  def initialize(base, destination, data, config = T.unsafe(nil)); end
 
   def data; end
   def identical?; end
@@ -136,7 +161,7 @@ class Thor::Actions::CreateLink < ::Thor::Actions::CreateFile
 end
 
 class Thor::Actions::Directory < ::Thor::Actions::EmptyDirectory
-  def initialize(base, source, destination = _, config = _, &block); end
+  def initialize(base, source, destination = T.unsafe(nil), config = T.unsafe(nil), &block); end
 
   def invoke!; end
   def revoke!; end
@@ -150,7 +175,7 @@ class Thor::Actions::Directory < ::Thor::Actions::EmptyDirectory
 end
 
 class Thor::Actions::EmptyDirectory
-  def initialize(base, destination, config = _); end
+  def initialize(base, destination, config = T.unsafe(nil)); end
 
   def base; end
   def config; end
@@ -184,18 +209,15 @@ class Thor::Actions::InjectIntoFile < ::Thor::Actions::EmptyDirectory
   protected
 
   def replace!(regexp, string, force); end
-  def say_status(behavior, warning: _, color: _); end
+  def say_status(behavior, warning: T.unsafe(nil), color: T.unsafe(nil)); end
 end
 
 Thor::Actions::WARNINGS = T.let(T.unsafe(nil), Hash)
-
-class Thor::AmbiguousCommandError < ::Thor::Error
-end
-
+class Thor::AmbiguousCommandError < ::Thor::Error; end
 Thor::AmbiguousTaskError = Thor::AmbiguousCommandError
 
 class Thor::Argument
-  def initialize(name, options = _); end
+  def initialize(name, options = T.unsafe(nil)); end
 
   def banner; end
   def default; end
@@ -219,7 +241,7 @@ end
 Thor::Argument::VALID_TYPES = T.let(T.unsafe(nil), Array)
 
 class Thor::Arguments
-  def initialize(arguments = _); end
+  def initialize(arguments = T.unsafe(nil)); end
 
   def parse(args); end
   def remaining; end
@@ -238,59 +260,64 @@ class Thor::Arguments
   def shift; end
   def unshift(arg); end
 
-  def self.parse(*args); end
-  def self.split(args); end
+  class << self
+    def parse(*args); end
+    def split(args); end
+  end
 end
 
 Thor::Arguments::NUMERIC = T.let(T.unsafe(nil), Regexp)
 
 module Thor::Base
-  include(::Thor::Invocation)
-  include(::Thor::Shell)
+  include ::Thor::Invocation
+  include ::Thor::Shell
 
-  mixes_in_class_methods(::Thor::Base::ClassMethods)
+  mixes_in_class_methods ::Thor::Base::ClassMethods
+  mixes_in_class_methods ::Thor::Invocation::ClassMethods
 
-  def initialize(args = _, local_options = _, config = _); end
+  def initialize(args = T.unsafe(nil), local_options = T.unsafe(nil), config = T.unsafe(nil)); end
 
   def args; end
-  def args=(_); end
+  def args=(_arg0); end
   def options; end
-  def options=(_); end
+  def options=(_arg0); end
   def parent_options; end
-  def parent_options=(_); end
+  def parent_options=(_arg0); end
 
-  def self.included(base); end
-  def self.register_klass_file(klass); end
-  def self.shell; end
-  def self.shell=(_); end
-  def self.subclass_files; end
-  def self.subclasses; end
+  class << self
+    def included(base); end
+    def register_klass_file(klass); end
+    def shell; end
+    def shell=(_arg0); end
+    def subclass_files; end
+    def subclasses; end
+  end
 end
 
 module Thor::Base::ClassMethods
   def all_commands; end
   def all_tasks; end
   def allow_incompatible_default_type!; end
-  def argument(name, options = _); end
+  def argument(name, options = T.unsafe(nil)); end
   def arguments; end
-  def attr_accessor(*_); end
-  def attr_reader(*_); end
-  def attr_writer(*_); end
+  def attr_accessor(*_arg0); end
+  def attr_reader(*_arg0); end
+  def attr_writer(*_arg0); end
   def check_default_type; end
   def check_default_type!; end
   def check_unknown_options; end
   def check_unknown_options!; end
   def check_unknown_options?(config); end
-  def class_option(name, options = _); end
-  def class_options(options = _); end
+  def class_option(name, options = T.unsafe(nil)); end
+  def class_options(options = T.unsafe(nil)); end
   def commands; end
   def disable_required_check?(command_name); end
   def exit_on_failure?; end
-  def group(name = _); end
+  def group(name = T.unsafe(nil)); end
   def handle_argument_error(command, error, args, arity); end
-  def handle_no_command_error(command, has_namespace = _); end
-  def handle_no_task_error(command, has_namespace = _); end
-  def namespace(name = _); end
+  def handle_no_command_error(command, has_namespace = T.unsafe(nil)); end
+  def handle_no_task_error(command, has_namespace = T.unsafe(nil)); end
+  def namespace(name = T.unsafe(nil)); end
   def no_commands(&block); end
   def no_commands?; end
   def no_commands_context; end
@@ -301,7 +328,7 @@ module Thor::Base::ClassMethods
   def remove_class_option(*names); end
   def remove_command(*names); end
   def remove_task(*names); end
-  def start(given_args = _, config = _); end
+  def start(given_args = T.unsafe(nil), config = T.unsafe(nil)); end
   def stop_on_unknown_option?(command_name); end
   def strict_args_position; end
   def strict_args_position!; end
@@ -314,26 +341,26 @@ module Thor::Base::ClassMethods
   def basename; end
   def build_option(name, options, scope); end
   def build_options(options, scope); end
-  def class_options_help(shell, groups = _); end
+  def class_options_help(shell, groups = T.unsafe(nil)); end
   def create_command(meth); end
   def create_task(meth); end
   def dispatch(command, given_args, given_opts, config); end
   def find_and_refresh_command(name); end
   def find_and_refresh_task(name); end
-  def from_superclass(method, default = _); end
+  def from_superclass(method, default = T.unsafe(nil)); end
   def inherited(klass); end
   def initialize_added; end
   def is_thor_reserved_word?(word, type); end
   def method_added(meth); end
-  def print_options(shell, options, group_name = _); end
+  def print_options(shell, options, group_name = T.unsafe(nil)); end
 end
 
 class Thor::Command < ::Struct
-  def initialize(name, description, long_description, usage, options = _); end
+  def initialize(name, description, long_description, usage, options = T.unsafe(nil)); end
 
-  def formatted_usage(klass, namespace = _, subcommand = _); end
+  def formatted_usage(klass, namespace = T.unsafe(nil), subcommand = T.unsafe(nil)); end
   def hidden?; end
-  def run(instance, args = _); end
+  def run(instance, args = T.unsafe(nil)); end
 
   protected
 
@@ -353,12 +380,10 @@ class Thor::Command < ::Struct
 end
 
 Thor::Command::FILE_REGEXP = T.let(T.unsafe(nil), Regexp)
-
-module Thor::CoreExt
-end
+module Thor::CoreExt; end
 
 class Thor::CoreExt::HashWithIndifferentAccess < ::Hash
-  def initialize(hash = _); end
+  def initialize(hash = T.unsafe(nil)); end
 
   def [](key); end
   def []=(key, value); end
@@ -382,40 +407,49 @@ end
 Thor::Correctable = DidYouMean::Correctable
 
 class Thor::DynamicCommand < ::Thor::Command
-  def initialize(name, options = _); end
+  def initialize(name, options = T.unsafe(nil)); end
 
-  def run(instance, args = _); end
+  def run(instance, args = T.unsafe(nil)); end
 end
 
 Thor::DynamicTask = Thor::DynamicCommand
-
-class Thor::Error < ::StandardError
-end
+class Thor::Error < ::StandardError; end
 
 class Thor::Group
-  include(::Thor::Base)
-  include(::Thor::Invocation)
-  include(::Thor::Shell)
-  extend(::Thor::Base::ClassMethods)
-  extend(::Thor::Invocation::ClassMethods)
-
+  include ::Thor::Base
+  include ::Thor::Invocation
+  include ::Thor::Shell
+  extend ::Thor::Base::ClassMethods
+  extend ::Thor::Invocation::ClassMethods
 
   protected
 
-  def _invoke_for_class_method(klass, command = _, *args, &block); end
-
-  def self.class_options_help(shell, groups = _); end
-  def self.desc(description = _); end
-  def self.get_options_from_invocations(group_options, base_options); end
-  def self.handle_argument_error(command, error, _args, arity); end
-  def self.help(shell); end
-  def self.invocation_blocks; end
-  def self.invocations; end
-  def self.invoke(*names, &block); end
-  def self.invoke_from_option(*names, &block); end
-  def self.printable_commands(*_); end
-  def self.printable_tasks(*_); end
-  def self.remove_invocation(*names); end
+  def _invoke_for_class_method(klass, command = T.unsafe(nil), *args, &block); end
+
+  class << self
+    def class_options_help(shell, groups = T.unsafe(nil)); end
+    def desc(description = T.unsafe(nil)); end
+    def get_options_from_invocations(group_options, base_options); end
+    def handle_argument_error(command, error, _args, arity); end
+    def help(shell); end
+    def invocation_blocks; end
+    def invocations; end
+    def invoke(*names, &block); end
+    def invoke_from_option(*names, &block); end
+    def printable_commands(*_arg0); end
+    def printable_tasks(*_arg0); end
+    def remove_invocation(*names); end
+
+    protected
+
+    def banner; end
+    def baseclass; end
+    def create_command(meth); end
+    def create_task(meth); end
+    def dispatch(command, given_args, given_opts, config); end
+    def self_command; end
+    def self_task; end
+  end
 end
 
 Thor::HELP_MAPPINGS = T.let(T.unsafe(nil), Array)
@@ -427,12 +461,12 @@ end
 Thor::HiddenTask = Thor::HiddenCommand
 
 module Thor::Invocation
-  mixes_in_class_methods(::Thor::Invocation::ClassMethods)
+  mixes_in_class_methods ::Thor::Invocation::ClassMethods
 
-  def initialize(args = _, options = _, config = _, &block); end
+  def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil), &block); end
 
   def current_command_chain; end
-  def invoke(name = _, *args); end
+  def invoke(name = T.unsafe(nil), *args); end
   def invoke_all; end
   def invoke_command(command, *args); end
   def invoke_task(command, *args); end
@@ -441,23 +475,26 @@ module Thor::Invocation
   protected
 
   def _parse_initialization_options(args, opts, config); end
-  def _retrieve_class_and_command(name, sent_command = _); end
-  def _retrieve_class_and_task(name, sent_command = _); end
+  def _retrieve_class_and_command(name, sent_command = T.unsafe(nil)); end
+  def _retrieve_class_and_task(name, sent_command = T.unsafe(nil)); end
   def _shared_configuration; end
 
-  def self.included(base); end
+  class << self
+    def included(base); end
+  end
 end
 
 module Thor::Invocation::ClassMethods
   def prepare_for_invocation(key, name); end
 end
 
-class Thor::InvocationError < ::Thor::Error
-end
+class Thor::InvocationError < ::Thor::Error; end
 
 module Thor::LineEditor
-  def self.best_available; end
-  def self.readline(prompt, options = _); end
+  class << self
+    def best_available; end
+    def readline(prompt, options = T.unsafe(nil)); end
+  end
 end
 
 class Thor::LineEditor::Basic
@@ -472,7 +509,9 @@ class Thor::LineEditor::Basic
   def echo?; end
   def get_input; end
 
-  def self.available?; end
+  class << self
+    def available?; end
+  end
 end
 
 class Thor::LineEditor::Readline < ::Thor::LineEditor::Basic
@@ -485,7 +524,9 @@ class Thor::LineEditor::Readline < ::Thor::LineEditor::Basic
   def completion_proc; end
   def use_path_completion?; end
 
-  def self.available?; end
+  class << self
+    def available?; end
+  end
 end
 
 class Thor::LineEditor::Readline::PathCompletion
@@ -502,8 +543,7 @@ class Thor::LineEditor::Readline::PathCompletion
   def text; end
 end
 
-class Thor::MalformattedArgumentError < ::Thor::InvocationError
-end
+class Thor::MalformattedArgumentError < ::Thor::InvocationError; end
 
 class Thor::NestedContext
   def initialize; end
@@ -522,7 +562,7 @@ class Thor::NoKwargSpellChecker < ::DidYouMean::SpellChecker
 end
 
 class Thor::Option < ::Thor::Argument
-  def initialize(name, options = _); end
+  def initialize(name, options = T.unsafe(nil)); end
 
   def aliases; end
   def array?; end
@@ -536,7 +576,7 @@ class Thor::Option < ::Thor::Argument
   def repeatable; end
   def string?; end
   def switch_name; end
-  def usage(padding = _); end
+  def usage(padding = T.unsafe(nil)); end
 
   protected
 
@@ -546,13 +586,15 @@ class Thor::Option < ::Thor::Argument
   def validate!; end
   def validate_default_type!; end
 
-  def self.parse(key, value); end
+  class << self
+    def parse(key, value); end
+  end
 end
 
 Thor::Option::VALID_TYPES = T.let(T.unsafe(nil), Array)
 
 class Thor::Options < ::Thor::Arguments
-  def initialize(hash_options = _, defaults = _, stop_on_unknown = _, disable_required_check = _); end
+  def initialize(hash_options = T.unsafe(nil), defaults = T.unsafe(nil), stop_on_unknown = T.unsafe(nil), disable_required_check = T.unsafe(nil)); end
 
   def check_unknown!; end
   def parse(args); end
@@ -572,39 +614,35 @@ class Thor::Options < ::Thor::Arguments
   def switch?(arg); end
   def switch_option(arg); end
 
-  def self.to_switches(options); end
+  class << self
+    def to_switches(options); end
+  end
 end
 
 Thor::Options::EQ_RE = T.let(T.unsafe(nil), Regexp)
-
 Thor::Options::LONG_RE = T.let(T.unsafe(nil), Regexp)
-
 Thor::Options::OPTS_END = T.let(T.unsafe(nil), String)
-
 Thor::Options::SHORT_NUM = T.let(T.unsafe(nil), Regexp)
-
 Thor::Options::SHORT_RE = T.let(T.unsafe(nil), Regexp)
-
 Thor::Options::SHORT_SQ_RE = T.let(T.unsafe(nil), Regexp)
 
 module Thor::RakeCompat
-  include(::FileUtils::StreamUtils_)
-  include(::FileUtils)
-  include(::Rake::FileUtilsExt)
-  include(::Rake::DSL)
+  include ::FileUtils::StreamUtils_
+  include ::FileUtils
+  include ::Rake::FileUtilsExt
+  include ::Rake::DSL
 
-  def self.included(base); end
-  def self.rake_classes; end
+  class << self
+    def included(base); end
+    def rake_classes; end
+  end
 end
 
-class Thor::RequiredArgumentMissingError < ::Thor::InvocationError
-end
-
-module Thor::Sandbox
-end
+class Thor::RequiredArgumentMissingError < ::Thor::InvocationError; end
+module Thor::Sandbox; end
 
 module Thor::Shell
-  def initialize(args = _, options = _, config = _); end
+  def initialize(args = T.unsafe(nil), options = T.unsafe(nil), config = T.unsafe(nil)); end
 
   def ask(*args, &block); end
   def error(*args, &block); end
@@ -617,7 +655,7 @@ module Thor::Shell
   def say_status(*args, &block); end
   def set_color(*args, &block); end
   def shell; end
-  def shell=(_); end
+  def shell=(_arg0); end
   def terminal_width(*args, &block); end
   def with_padding; end
   def yes?(*args, &block); end
@@ -632,23 +670,23 @@ class Thor::Shell::Basic
 
   def ask(statement, *args); end
   def base; end
-  def base=(_); end
+  def base=(_arg0); end
   def error(statement); end
   def file_collision(destination); end
-  def indent(count = _); end
+  def indent(count = T.unsafe(nil)); end
   def mute; end
   def mute?; end
-  def no?(statement, color = _); end
+  def no?(statement, color = T.unsafe(nil)); end
   def padding; end
   def padding=(value); end
   def print_in_columns(array); end
-  def print_table(array, options = _); end
-  def print_wrapped(message, options = _); end
-  def say(message = _, color = _, force_new_line = _); end
-  def say_status(status, message, log_status = _); end
-  def set_color(string, *_); end
+  def print_table(array, options = T.unsafe(nil)); end
+  def print_wrapped(message, options = T.unsafe(nil)); end
+  def say(message = T.unsafe(nil), color = T.unsafe(nil), force_new_line = T.unsafe(nil)); end
+  def say_status(status, message, log_status = T.unsafe(nil)); end
+  def set_color(string, *_arg1); end
   def terminal_width; end
-  def yes?(statement, color = _); end
+  def yes?(statement, color = T.unsafe(nil)); end
 
   protected
 
@@ -683,6 +721,7 @@ class Thor::Shell::Color < ::Thor::Shell::Basic
   protected
 
   def are_colors_disabled?; end
+  def are_colors_supported?; end
   def can_display_colors?; end
   def diff_lcs_loaded?; end
   def output_diff_line(diff); end
@@ -690,43 +729,26 @@ class Thor::Shell::Color < ::Thor::Shell::Basic
 end
 
 Thor::Shell::Color::BLACK = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::BLUE = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::BOLD = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::CLEAR = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::CYAN = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::GREEN = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::MAGENTA = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::ON_BLACK = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::ON_BLUE = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::ON_CYAN = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::ON_GREEN = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::ON_MAGENTA = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::ON_RED = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::ON_WHITE = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::ON_YELLOW = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::RED = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::WHITE = T.let(T.unsafe(nil), String)
-
 Thor::Shell::Color::YELLOW = T.let(T.unsafe(nil), String)
 
 class Thor::Shell::HTML < ::Thor::Shell::Basic
-  def ask(statement, color = _); end
+  def ask(statement, color = T.unsafe(nil)); end
   def set_color(string, *colors); end
 
   protected
@@ -738,49 +760,29 @@ class Thor::Shell::HTML < ::Thor::Shell::Basic
 end
 
 Thor::Shell::HTML::BLACK = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::BLUE = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::BOLD = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::CYAN = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::GREEN = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::MAGENTA = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::ON_BLACK = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::ON_BLUE = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::ON_CYAN = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::ON_GREEN = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::ON_MAGENTA = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::ON_RED = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::ON_WHITE = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::ON_YELLOW = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::RED = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::WHITE = T.let(T.unsafe(nil), String)
-
 Thor::Shell::HTML::YELLOW = T.let(T.unsafe(nil), String)
-
 Thor::Shell::SHELL_DELEGATED_METHODS = T.let(T.unsafe(nil), Array)
-
 Thor::TEMPLATE_EXTNAME = T.let(T.unsafe(nil), String)
-
 Thor::THOR_RESERVED_WORDS = T.let(T.unsafe(nil), Array)
-
 Thor::Task = Thor::Command
 
 class Thor::UndefinedCommandError < ::Thor::Error
-  include(::DidYouMean::Correctable)
+  include ::DidYouMean::Correctable
 
   def initialize(command, all_commands, namespace); end
 
@@ -799,7 +801,7 @@ end
 Thor::UndefinedTaskError = Thor::UndefinedCommandError
 
 class Thor::UnknownArgumentError < ::Thor::Error
-  include(::DidYouMean::Correctable)
+  include ::DidYouMean::Correctable
 
   def initialize(switches, unknown); end
 
@@ -816,20 +818,22 @@ class Thor::UnknownArgumentError::SpellChecker
 end
 
 module Thor::Util
-  def self.camel_case(str); end
-  def self.escape_globs(path); end
-  def self.escape_html(string); end
-  def self.find_by_namespace(namespace); end
-  def self.find_class_and_command_by_namespace(namespace, fallback = _); end
-  def self.find_class_and_task_by_namespace(namespace, fallback = _); end
-  def self.globs_for(path); end
-  def self.load_thorfile(path, content = _, debug = _); end
-  def self.namespace_from_thor_class(constant); end
-  def self.namespaces_in_content(contents, file = _); end
-  def self.ruby_command; end
-  def self.snake_case(str); end
-  def self.thor_classes_in(klass); end
-  def self.thor_root; end
-  def self.thor_root_glob; end
-  def self.user_home; end
+  class << self
+    def camel_case(str); end
+    def escape_globs(path); end
+    def escape_html(string); end
+    def find_by_namespace(namespace); end
+    def find_class_and_command_by_namespace(namespace, fallback = T.unsafe(nil)); end
+    def find_class_and_task_by_namespace(namespace, fallback = T.unsafe(nil)); end
+    def globs_for(path); end
+    def load_thorfile(path, content = T.unsafe(nil), debug = T.unsafe(nil)); end
+    def namespace_from_thor_class(constant); end
+    def namespaces_in_content(contents, file = T.unsafe(nil)); end
+    def ruby_command; end
+    def snake_case(str); end
+    def thor_classes_in(klass); end
+    def thor_root; end
+    def thor_root_glob; end
+    def user_home; end
+  end
 end
diff --git a/sorbet/rbi/gems/thread_safe@0.3.6.rbi b/sorbet/rbi/gems/thread_safe@0.3.6.rbi
new file mode 100644
index 00000000..200f0fa7
--- /dev/null
+++ b/sorbet/rbi/gems/thread_safe@0.3.6.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `thread_safe` gem.
+# Please instead update this file by running `bin/tapioca gem thread_safe`.
+
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires
diff --git a/sorbet/rbi/gems/unparser@0.5.5.rbi b/sorbet/rbi/gems/unparser@0.5.5.rbi
new file mode 100644
index 00000000..54aa8003
--- /dev/null
+++ b/sorbet/rbi/gems/unparser@0.5.5.rbi
@@ -0,0 +1,8 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `unparser` gem.
+# Please instead update this file by running `bin/tapioca gem unparser`.
+
+# THIS IS AN EMPTY RBI FILE.
+# see https://github.com/Shopify/tapioca/wiki/Manual-Gem-Requires
diff --git a/sorbet/rbi/gems/yard-sorbet@0.6.1.rbi b/sorbet/rbi/gems/yard-sorbet@0.6.1.rbi
new file mode 100644
index 00000000..21e2d580
--- /dev/null
+++ b/sorbet/rbi/gems/yard-sorbet@0.6.1.rbi
@@ -0,0 +1,199 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `yard-sorbet` gem.
+# Please instead update this file by running `bin/tapioca gem yard-sorbet`.
+
+module YARDSorbet; end
+
+module YARDSorbet::Directives
+  class << self
+    sig { params(docstring: String, directives: T::Array[String]).void }
+    def add_directives(docstring, directives); end
+
+    sig { params(docstring: T.nilable(String)).returns([YARD::Docstring, T::Array[String]]) }
+    def extract_directives(docstring); end
+  end
+end
+
+module YARDSorbet::Handlers; end
+
+class YARDSorbet::Handlers::AbstractDSLHandler < ::YARD::Handlers::Ruby::Base
+  sig { void }
+  def process; end
+end
+
+YARDSorbet::Handlers::AbstractDSLHandler::CLASS_TAG_TEXT = T.let(T.unsafe(nil), String)
+YARDSorbet::Handlers::AbstractDSLHandler::TAG_TEXT = T.let(T.unsafe(nil), String)
+
+class YARDSorbet::Handlers::EnumsHandler < ::YARD::Handlers::Ruby::Base
+  sig { void }
+  def process; end
+
+  private
+
+  sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Boolean) }
+  def const_assign_node?(node); end
+end
+
+class YARDSorbet::Handlers::IncludeHandler < ::YARD::Handlers::Ruby::Base
+  sig { void }
+  def process; end
+
+  private
+
+  sig { returns(YARD::CodeObjects::NamespaceObject) }
+  def included_in; end
+end
+
+class YARDSorbet::Handlers::MixesInClassMethodsHandler < ::YARD::Handlers::Ruby::Base
+  sig { void }
+  def process; end
+
+  class << self
+    sig { params(code_obj: String).returns(T.nilable(String)) }
+    def mixed_in_class_methods(code_obj); end
+  end
+end
+
+class YARDSorbet::Handlers::SigHandler < ::YARD::Handlers::Ruby::Base
+  sig { void }
+  def process; end
+
+  private
+
+  sig { params(method_node: YARD::Parser::Ruby::AstNode, node: YARD::Parser::Ruby::AstNode, docstring: YARD::Docstring).void }
+  def parse_params(method_node, node, docstring); end
+
+  sig { params(node: YARD::Parser::Ruby::AstNode, docstring: YARD::Docstring).void }
+  def parse_return(node, docstring); end
+
+  sig { params(method_node: YARD::Parser::Ruby::AstNode, docstring: YARD::Docstring).void }
+  def parse_sig(method_node, docstring); end
+end
+
+YARDSorbet::Handlers::SigHandler::ATTR_NODE_TYPES = T.let(T.unsafe(nil), Array)
+
+module YARDSorbet::Handlers::StructClassHandler
+  sig { void }
+  def process; end
+
+  private
+
+  sig { params(object: YARD::CodeObjects::MethodObject, props: T::Array[YARDSorbet::TStructProp], docstring: YARD::Docstring, directives: T::Array[String]).void }
+  def decorate_t_struct_init(object, props, docstring, directives); end
+
+  sig { params(props: T::Array[YARDSorbet::TStructProp], class_ns: YARD::CodeObjects::ClassObject).void }
+  def process_t_struct_props(props, class_ns); end
+
+  sig { params(props: T::Array[YARDSorbet::TStructProp]).returns(T::Array[[String, T.nilable(String)]]) }
+  def to_object_parameters(props); end
+end
+
+class YARDSorbet::Handlers::StructPropHandler < ::YARD::Handlers::Ruby::Base
+  sig { void }
+  def process; end
+
+  private
+
+  sig { params(object: YARD::CodeObjects::MethodObject, prop: YARDSorbet::TStructProp).void }
+  def decorate_object(object, prop); end
+
+  sig { returns(T.nilable(String)) }
+  def default_value; end
+
+  sig { params(name: String).returns(YARDSorbet::TStructProp) }
+  def make_prop(name); end
+
+  sig { params(object: YARD::CodeObjects::MethodObject, name: String).void }
+  def register_attrs(object, name); end
+
+  sig { params(prop: YARDSorbet::TStructProp).void }
+  def update_state(prop); end
+end
+
+module YARDSorbet::NodeUtils
+  class << self
+    sig { params(node: YARD::Parser::Ruby::AstNode, _blk: T.proc.params(n: YARD::Parser::Ruby::AstNode).void).void }
+    def bfs_traverse(node, &_blk); end
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T.any(YARD::Parser::Ruby::MethodCallNode, YARD::Parser::Ruby::MethodDefinitionNode)) }
+    def get_method_node(node); end
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(YARD::Parser::Ruby::AstNode) }
+    def sibling_node(node); end
+  end
+end
+
+YARDSorbet::NodeUtils::ATTRIBUTE_METHODS = T.let(T.unsafe(nil), Array)
+YARDSorbet::NodeUtils::SIGABLE_NODE = T.type_alias { T.any(YARD::Parser::Ruby::MethodCallNode, YARD::Parser::Ruby::MethodDefinitionNode) }
+YARDSorbet::NodeUtils::SKIP_METHOD_CONTENTS = T.let(T.unsafe(nil), Array)
+
+module YARDSorbet::SigToYARD
+  class << self
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    def convert(node); end
+
+    private
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(String) }
+    def build_generic_type(node); end
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    def convert_aref(node); end
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    def convert_array(node); end
+
+    sig { params(node: YARD::Parser::Ruby::MethodCallNode).returns(T::Array[String]) }
+    def convert_call(node); end
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    def convert_collection(node); end
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    def convert_hash(node); end
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    def convert_list(node); end
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    def convert_node(node); end
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    def convert_node_type(node); end
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    def convert_ref(node); end
+
+    sig { params(node: YARD::Parser::Ruby::MethodCallNode).returns(T::Array[String]) }
+    def convert_t_method(node); end
+
+    sig { params(node: YARD::Parser::Ruby::AstNode).returns(T::Array[String]) }
+    def convert_unknown(node); end
+  end
+end
+
+class YARDSorbet::TStructProp < ::T::Struct
+  const :default, T.nilable(String)
+  const :doc, String
+  const :prop_name, String
+  const :source, String
+  const :types, T::Array[String]
+
+  class << self
+    def inherited(s); end
+  end
+end
+
+module YARDSorbet::TagUtils
+  class << self
+    sig { params(docstring: YARD::Docstring, tag_name: String, name: T.nilable(String)).returns(T.nilable(YARD::Tags::Tag)) }
+    def find_tag(docstring, tag_name, name); end
+
+    sig { params(docstring: YARD::Docstring, tag_name: String, types: T.nilable(T::Array[String]), name: T.nilable(String), text: String).void }
+    def upsert_tag(docstring, tag_name, types = T.unsafe(nil), name = T.unsafe(nil), text = T.unsafe(nil)); end
+  end
+end
+
+YARDSorbet::VERSION = T.let(T.unsafe(nil), String)
diff --git a/sorbet/rbi/gems/yard@0.9.26.rbi b/sorbet/rbi/gems/yard@0.9.26.rbi
new file mode 100644
index 00000000..6d9be414
--- /dev/null
+++ b/sorbet/rbi/gems/yard@0.9.26.rbi
@@ -0,0 +1,3876 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `yard` gem.
+# Please instead update this file by running `bin/tapioca gem yard`.
+
+class Array
+  include ::Enumerable
+  include ::JSON::Ext::Generator::GeneratorMethods::Array
+
+  def place(*values); end
+end
+
+class File < ::IO
+  class << self
+    def cleanpath(path, rel_root = T.unsafe(nil)); end
+    def open!(file, *args, &block); end
+    def read_binary(file); end
+    def relative_path(from, to); end
+  end
+end
+
+File::RELATIVE_PARENTDIR = T.let(T.unsafe(nil), String)
+File::RELATIVE_SAMEDIR = T.let(T.unsafe(nil), String)
+
+module Gem
+  class << self
+    def source_index; end
+  end
+end
+
+Gem::Cache = Gem::SourceIndex
+Gem::ConfigMap = T.let(T.unsafe(nil), Hash)
+Gem::RbConfigPriorities = T.let(T.unsafe(nil), Array)
+Gem::RubyGemsVersion = T.let(T.unsafe(nil), String)
+
+class Gem::SourceIndex
+  include ::Enumerable
+
+  def initialize(specifications = T.unsafe(nil)); end
+
+  def ==(other); end
+  def add_spec(gem_spec, name = T.unsafe(nil)); end
+  def add_specs(*gem_specs); end
+  def all_gems; end
+  def dump; end
+  def each(&block); end
+  def find_name(gem_name, requirement = T.unsafe(nil)); end
+  def gem_signature(gem_full_name); end
+  def gems; end
+  def index_signature; end
+  def latest_specs(include_prerelease = T.unsafe(nil)); end
+  def length; end
+  def load_gems_in(*spec_dirs); end
+  def outdated; end
+  def prerelease_gems; end
+  def prerelease_specs; end
+  def refresh!; end
+  def released_gems; end
+  def released_specs; end
+  def remove_spec(full_name); end
+  def search(gem_pattern, platform_only = T.unsafe(nil)); end
+  def size; end
+  def spec_dirs; end
+  def spec_dirs=(_arg0); end
+  def specification(full_name); end
+
+  class << self
+    def from_gems_in(*spec_dirs); end
+    def from_installed_gems(*deprecated); end
+    def installed_spec_directories; end
+    def load_specification(file_name); end
+  end
+end
+
+Gem::UNTAINT = T.let(T.unsafe(nil), Proc)
+Gem::UnsatisfiableDepedencyError = Gem::UnsatisfiableDependencyError
+
+class Insertion
+  def initialize(list, value); end
+
+  def after(val, recursive = T.unsafe(nil)); end
+  def after_any(val); end
+  def before(val, recursive = T.unsafe(nil)); end
+  def before_any(val); end
+
+  private
+
+  def insertion(val, rel, recursive = T.unsafe(nil), list = T.unsafe(nil)); end
+end
+
+class Module
+  def class_name; end
+end
+
+RUBY19 = T.let(T.unsafe(nil), TrueClass)
+
+class String
+  include ::Comparable
+  include ::JSON::Ext::Generator::GeneratorMethods::String
+  extend ::JSON::Ext::Generator::GeneratorMethods::String::Extend
+
+  def shell_split; end
+end
+
+class SymbolHash < ::Hash
+  def initialize(symbolize_value = T.unsafe(nil)); end
+
+  def [](key); end
+  def []=(key, value); end
+  def delete(key); end
+  def has_key?(key); end
+  def key?(key); end
+  def merge(hash); end
+  def merge!(hash); end
+  def update(hash); end
+
+  class << self
+    def [](*hsh); end
+  end
+end
+
+module YARD
+  class << self
+    def load_plugins; end
+    def parse(*args); end
+    def parse_string(*args); end
+    def ruby18?; end
+    def ruby19?; end
+    def ruby2?; end
+    def windows?; end
+  end
+end
+
+module YARD::CLI; end
+
+class YARD::CLI::Command
+  def description; end
+
+  protected
+
+  def common_options(opts); end
+  def load_script(file); end
+  def parse_options(opts, args); end
+  def unrecognized_option(err); end
+
+  class << self
+    def run(*args); end
+  end
+end
+
+class YARD::CLI::CommandParser
+  def initialize; end
+
+  def run(*args); end
+
+  private
+
+  def commands; end
+  def list_commands; end
+
+  class << self
+    def commands; end
+    def commands=(_arg0); end
+    def default_command; end
+    def default_command=(_arg0); end
+    def run(*args); end
+  end
+end
+
+class YARD::CLI::Config < ::YARD::CLI::Command
+  def initialize; end
+
+  def append; end
+  def append=(_arg0); end
+  def as_list; end
+  def as_list=(_arg0); end
+  def description; end
+  def gem_install_cmd; end
+  def gem_install_cmd=(_arg0); end
+  def key; end
+  def key=(_arg0); end
+  def reset; end
+  def reset=(_arg0); end
+  def run(*args); end
+  def values; end
+  def values=(_arg0); end
+
+  private
+
+  def configure_gemrc; end
+  def encode_value(value); end
+  def encode_values; end
+  def list_configuration; end
+  def modify_item; end
+  def optparse(*args); end
+  def view_item; end
+end
+
+class YARD::CLI::Diff < ::YARD::CLI::Command
+  def initialize; end
+
+  def description; end
+  def run(*args); end
+
+  private
+
+  def added_objects(registry1, registry2); end
+  def all_objects; end
+  def cleanup(gemfile); end
+  def expand_and_parse(gemfile, io); end
+  def expand_gem(gemfile, io); end
+  def generate_yardoc(dir); end
+  def load_gem_data(gemfile); end
+  def load_git_commit(commit); end
+  def modified_objects(registry1, registry2); end
+  def optparse(*args); end
+  def removed_objects(registry1, registry2); end
+  def require_rubygems; end
+end
+
+class YARD::CLI::Display < ::YARD::CLI::Yardoc
+  def initialize(*args); end
+
+  def description; end
+  def format_objects; end
+  def output_options(opts); end
+  def parse_arguments(*args); end
+  def run(*args); end
+  def wrap_layout(contents); end
+end
+
+class YARD::CLI::Gems < ::YARD::CLI::Command
+  def initialize; end
+
+  def description; end
+  def run(*args); end
+
+  private
+
+  def add_gems(gems); end
+  def build_gems; end
+  def optparse(*args); end
+end
+
+class YARD::CLI::Graph < ::YARD::CLI::YardoptsCommand
+  def initialize; end
+
+  def description; end
+  def objects; end
+  def options; end
+  def run(*args); end
+
+  private
+
+  def optparse(*args); end
+  def unrecognized_option(err); end
+end
+
+class YARD::CLI::GraphOptions < ::YARD::Templates::TemplateOptions
+  def contents; end
+  def contents=(_arg0); end
+  def dependencies; end
+  def dependencies=(_arg0); end
+  def format; end
+  def format=(_arg0); end
+  def full; end
+  def full=(_arg0); end
+end
+
+class YARD::CLI::Help < ::YARD::CLI::Command
+  def description; end
+  def run(*args); end
+end
+
+class YARD::CLI::I18n < ::YARD::CLI::Yardoc
+  def initialize; end
+
+  def description; end
+  def run(*args); end
+
+  private
+
+  def general_options(opts); end
+  def generate_pot(relative_base_path); end
+end
+
+class YARD::CLI::List < ::YARD::CLI::Command
+  def description; end
+  def run(*args); end
+end
+
+class YARD::CLI::MarkupTypes < ::YARD::CLI::Command
+  def description; end
+  def run(*args); end
+end
+
+class YARD::CLI::Server < ::YARD::CLI::Command
+  def initialize; end
+
+  def adapter; end
+  def adapter=(_arg0); end
+  def description; end
+  def libraries; end
+  def libraries=(_arg0); end
+  def options; end
+  def options=(_arg0); end
+  def run(*args); end
+  def scripts; end
+  def scripts=(_arg0); end
+  def server_options; end
+  def server_options=(_arg0); end
+  def template_paths; end
+  def template_paths=(_arg0); end
+
+  private
+
+  def add_gems; end
+  def add_gems_from_gemfile(gemfile = T.unsafe(nil)); end
+  def add_libraries(args); end
+  def create_library_version_if_yardopts_exist(library, dir); end
+  def extract_db_from_options_file(options_file); end
+  def generate_doc_for_first_time(libver); end
+  def load_scripts; end
+  def load_template_paths; end
+  def optparse(*args); end
+  def select_adapter; end
+end
+
+class YARD::CLI::Stats < ::YARD::CLI::Yardoc
+  include ::YARD::Templates::Helpers::BaseHelper
+
+  def initialize(parse = T.unsafe(nil)); end
+
+  def all_objects; end
+  def description; end
+  def output(name, data, undoc = T.unsafe(nil)); end
+  def parse; end
+  def parse=(_arg0); end
+  def print_statistics; end
+  def print_undocumented_objects; end
+  def run(*args); end
+  def stats_for_attributes; end
+  def stats_for_classes; end
+  def stats_for_constants; end
+  def stats_for_files; end
+  def stats_for_methods; end
+  def stats_for_modules; end
+
+  private
+
+  def general_options(opts); end
+  def optparse(*args); end
+  def type_statistics(type); end
+end
+
+YARD::CLI::Stats::STATS_ORDER = T.let(T.unsafe(nil), Array)
+
+class YARD::CLI::YRI < ::YARD::CLI::Command
+  def initialize; end
+
+  def description; end
+  def run(*args); end
+
+  protected
+
+  def cache_object(name, path); end
+  def find_object(name); end
+  def print_object(object); end
+  def print_usage; end
+
+  private
+
+  def add_default_paths; end
+  def add_gem_paths; end
+  def load_cache; end
+  def optparse(*args); end
+  def try_load_object(name, cache_path); end
+
+  class << self
+    def run(*args); end
+  end
+end
+
+YARD::CLI::YRI::CACHE_FILE = T.let(T.unsafe(nil), String)
+YARD::CLI::YRI::DEFAULT_SEARCH_PATHS = T.let(T.unsafe(nil), Array)
+YARD::CLI::YRI::SEARCH_PATHS_FILE = T.let(T.unsafe(nil), String)
+
+class YARD::CLI::Yardoc < ::YARD::CLI::YardoptsCommand
+  def initialize; end
+
+  def all_objects; end
+  def apis; end
+  def apis=(_arg0); end
+  def assets; end
+  def assets=(_arg0); end
+  def description; end
+  def excluded; end
+  def excluded=(_arg0); end
+  def fail_on_warning; end
+  def fail_on_warning=(_arg0); end
+  def files; end
+  def files=(_arg0); end
+  def generate; end
+  def generate=(_arg0); end
+  def has_markup; end
+  def has_markup=(_arg0); end
+  def hidden_apis; end
+  def hidden_apis=(_arg0); end
+  def hidden_tags; end
+  def hidden_tags=(_arg0); end
+  def list; end
+  def list=(_arg0); end
+  def options; end
+  def parse_arguments(*args); end
+  def run(*args); end
+  def save_yardoc; end
+  def save_yardoc=(_arg0); end
+  def statistics; end
+  def statistics=(_arg0); end
+  def use_cache; end
+  def use_cache=(_arg0); end
+  def visibilities; end
+  def visibilities=(_arg0); end
+
+  private
+
+  def add_api_verifier; end
+  def add_extra_files(*files); end
+  def add_tag(tag_data, factory_method = T.unsafe(nil)); end
+  def add_visibility_verifier; end
+  def apply_locale; end
+  def copy_assets; end
+  def extra_file_valid?(file, check_exists = T.unsafe(nil)); end
+  def general_options(opts); end
+  def optparse(*args); end
+  def output_options(opts); end
+  def parse_files(*files); end
+  def print_list; end
+  def run_generate(checksums); end
+  def run_verifier(list); end
+  def tag_options(opts); end
+  def verify_markup_options; end
+end
+
+class YARD::CLI::YardocOptions < ::YARD::Templates::TemplateOptions
+  def file; end
+  def file=(_arg0); end
+  def files; end
+  def files=(_arg0); end
+  def format; end
+  def format=(_arg0); end
+  def index; end
+  def index=(_arg0); end
+  def item; end
+  def item=(_arg0); end
+  def locale; end
+  def locale=(_arg0); end
+  def objects; end
+  def objects=(_arg0); end
+  def onefile; end
+  def onefile=(_arg0); end
+  def readme; end
+  def readme=(_arg0); end
+  def serializer; end
+  def serializer=(_arg0); end
+  def title; end
+  def title=(_arg0); end
+  def verifier; end
+  def verifier=(_arg0); end
+end
+
+class YARD::CLI::YardoptsCommand < ::YARD::CLI::Command
+  def initialize; end
+
+  def options_file; end
+  def options_file=(_arg0); end
+  def parse_arguments(*args); end
+  def use_document_file; end
+  def use_document_file=(_arg0); end
+  def use_yardopts_file; end
+  def use_yardopts_file=(_arg0); end
+
+  protected
+
+  def yardopts_options(opts); end
+
+  private
+
+  def parse_rdoc_document_file(file = T.unsafe(nil)); end
+  def parse_yardopts(file = T.unsafe(nil)); end
+  def parse_yardopts_options(*args); end
+  def support_rdoc_document_file!(file = T.unsafe(nil)); end
+  def yardopts(file = T.unsafe(nil)); end
+end
+
+YARD::CLI::YardoptsCommand::DEFAULT_YARDOPTS_FILE = T.let(T.unsafe(nil), String)
+YARD::CONFIG_DIR = T.let(T.unsafe(nil), String)
+module YARD::CodeObjects; end
+YARD::CodeObjects::BUILTIN_ALL = T.let(T.unsafe(nil), Array)
+YARD::CodeObjects::BUILTIN_CLASSES = T.let(T.unsafe(nil), Array)
+YARD::CodeObjects::BUILTIN_EXCEPTIONS = T.let(T.unsafe(nil), Array)
+YARD::CodeObjects::BUILTIN_EXCEPTIONS_HASH = T.let(T.unsafe(nil), Hash)
+YARD::CodeObjects::BUILTIN_MODULES = T.let(T.unsafe(nil), Array)
+
+class YARD::CodeObjects::Base
+  def initialize(namespace, name, *_arg2); end
+
+  def ==(other); end
+  def [](key); end
+  def []=(key, value); end
+  def add_file(file, line = T.unsafe(nil), has_comments = T.unsafe(nil)); end
+  def add_tag(*tags); end
+  def base_docstring; end
+  def copy_to(other); end
+  def docstring(locale = T.unsafe(nil)); end
+  def docstring=(comments); end
+  def dynamic; end
+  def dynamic=(_arg0); end
+  def dynamic?; end
+  def eql?(other); end
+  def equal?(other); end
+  def file; end
+  def files; end
+  def format(options = T.unsafe(nil)); end
+  def group; end
+  def group=(_arg0); end
+  def has_tag?(name); end
+  def hash; end
+  def inspect; end
+  def line; end
+  def method_missing(meth, *args, &block); end
+  def name(prefix = T.unsafe(nil)); end
+  def namespace; end
+  def namespace=(obj); end
+  def parent; end
+  def parent=(obj); end
+  def path; end
+  def relative_path(other); end
+  def root?; end
+  def sep; end
+  def signature; end
+  def signature=(_arg0); end
+  def source; end
+  def source=(statement); end
+  def source_type; end
+  def source_type=(_arg0); end
+  def tag(name); end
+  def tags(name = T.unsafe(nil)); end
+  def title; end
+  def to_ary; end
+  def to_s; end
+  def type; end
+  def visibility; end
+  def visibility=(v); end
+
+  protected
+
+  def copyable_attributes; end
+
+  private
+
+  def format_source(source); end
+  def translate_docstring(locale); end
+
+  class << self
+    def ===(other); end
+    def new(namespace, name, *args, &block); end
+  end
+end
+
+YARD::CodeObjects::CONSTANTMATCH = T.let(T.unsafe(nil), Regexp)
+YARD::CodeObjects::CONSTANTSTART = T.let(T.unsafe(nil), Regexp)
+YARD::CodeObjects::CSEP = T.let(T.unsafe(nil), String)
+YARD::CodeObjects::CSEPQ = T.let(T.unsafe(nil), String)
+
+class YARD::CodeObjects::ClassObject < ::YARD::CodeObjects::NamespaceObject
+  def initialize(namespace, name, *args, &block); end
+
+  def constants(opts = T.unsafe(nil)); end
+  def inheritance_tree(include_mods = T.unsafe(nil)); end
+  def inherited_constants; end
+  def inherited_meths(opts = T.unsafe(nil)); end
+  def is_exception?; end
+  def meths(opts = T.unsafe(nil)); end
+  def superclass; end
+  def superclass=(object); end
+end
+
+class YARD::CodeObjects::ClassVariableObject < ::YARD::CodeObjects::Base
+  def value; end
+  def value=(_arg0); end
+end
+
+class YARD::CodeObjects::CodeObjectList < ::Array
+  def initialize(owner = T.unsafe(nil)); end
+
+  def <<(value); end
+  def push(value); end
+end
+
+class YARD::CodeObjects::ConstantObject < ::YARD::CodeObjects::Base
+  def value; end
+  def value=(value); end
+end
+
+class YARD::CodeObjects::ExtendedMethodObject
+  def initialize(obj); end
+
+  def method_missing(sym, *args, &block); end
+  def scope; end
+end
+
+class YARD::CodeObjects::ExtraFileObject
+  def initialize(filename, contents = T.unsafe(nil)); end
+
+  def ==(other); end
+  def attributes; end
+  def attributes=(_arg0); end
+  def contents; end
+  def contents=(contents); end
+  def eql?(other); end
+  def equal?(other); end
+  def filename; end
+  def filename=(_arg0); end
+  def hash; end
+  def inspect; end
+  def locale; end
+  def locale=(locale); end
+  def name; end
+  def name=(_arg0); end
+  def path; end
+  def title; end
+  def to_s; end
+  def type; end
+
+  private
+
+  def ensure_parsed; end
+  def parse_contents(data); end
+  def translate(data); end
+end
+
+YARD::CodeObjects::ISEP = T.let(T.unsafe(nil), String)
+YARD::CodeObjects::ISEPQ = T.let(T.unsafe(nil), String)
+YARD::CodeObjects::METHODMATCH = T.let(T.unsafe(nil), Regexp)
+YARD::CodeObjects::METHODNAMEMATCH = T.let(T.unsafe(nil), Regexp)
+
+class YARD::CodeObjects::MacroObject < ::YARD::CodeObjects::Base
+  def attached?; end
+  def expand(call_params = T.unsafe(nil), full_source = T.unsafe(nil), block_source = T.unsafe(nil)); end
+  def macro_data; end
+  def macro_data=(_arg0); end
+  def method_object; end
+  def method_object=(_arg0); end
+  def path; end
+  def sep; end
+
+  class << self
+    def apply(docstring, call_params = T.unsafe(nil), full_source = T.unsafe(nil), block_source = T.unsafe(nil), _method_object = T.unsafe(nil)); end
+    def apply_macro(macro, docstring, call_params = T.unsafe(nil), full_source = T.unsafe(nil), block_source = T.unsafe(nil)); end
+    def create(macro_name, data, method_object = T.unsafe(nil)); end
+    def create_docstring(macro_name, data, method_object = T.unsafe(nil)); end
+    def expand(macro_data, call_params = T.unsafe(nil), full_source = T.unsafe(nil), block_source = T.unsafe(nil)); end
+    def find(macro_name); end
+    def find_or_create(macro_name, data, method_object = T.unsafe(nil)); end
+  end
+end
+
+YARD::CodeObjects::MacroObject::MACRO_MATCH = T.let(T.unsafe(nil), Regexp)
+
+class YARD::CodeObjects::MethodObject < ::YARD::CodeObjects::Base
+  def initialize(namespace, name, scope = T.unsafe(nil), &block); end
+
+  def aliases; end
+  def attr_info; end
+  def constructor?; end
+  def explicit; end
+  def explicit=(_arg0); end
+  def is_alias?; end
+  def is_attribute?; end
+  def is_explicit?; end
+  def module_function?; end
+  def name(prefix = T.unsafe(nil)); end
+  def overridden_method; end
+  def parameters; end
+  def parameters=(_arg0); end
+  def path; end
+  def reader?; end
+  def scope; end
+  def scope=(v); end
+  def sep; end
+  def writer?; end
+
+  protected
+
+  def copyable_attributes; end
+end
+
+class YARD::CodeObjects::ModuleObject < ::YARD::CodeObjects::NamespaceObject
+  def inheritance_tree(include_mods = T.unsafe(nil)); end
+end
+
+YARD::CodeObjects::NAMESPACEMATCH = T.let(T.unsafe(nil), Regexp)
+YARD::CodeObjects::NSEP = T.let(T.unsafe(nil), String)
+YARD::CodeObjects::NSEPQ = T.let(T.unsafe(nil), String)
+
+module YARD::CodeObjects::NamespaceMapper
+  def clear_separators; end
+  def default_separator(value = T.unsafe(nil)); end
+  def register_separator(sep, *valid_types); end
+  def separators; end
+  def separators_for_type(type); end
+  def separators_match; end
+  def types_for_separator(sep); end
+  def unregister_separator_by_type(type); end
+
+  class << self
+    def default_separator; end
+    def default_separator=(_arg0); end
+    def invalidate; end
+    def map; end
+    def map_match; end
+    def on_invalidate(&block); end
+    def rev_map; end
+  end
+end
+
+class YARD::CodeObjects::NamespaceObject < ::YARD::CodeObjects::Base
+  def initialize(namespace, name, *args, &block); end
+
+  def aliases; end
+  def attributes; end
+  def child(opts = T.unsafe(nil)); end
+  def children; end
+  def class_attributes; end
+  def class_mixins; end
+  def constants(opts = T.unsafe(nil)); end
+  def cvars; end
+  def groups; end
+  def groups=(_arg0); end
+  def included_constants; end
+  def included_meths(opts = T.unsafe(nil)); end
+  def instance_attributes; end
+  def instance_mixins; end
+  def meths(opts = T.unsafe(nil)); end
+  def mixins(*scopes); end
+end
+
+YARD::CodeObjects::PROXY_MATCH = T.let(T.unsafe(nil), Regexp)
+
+class YARD::CodeObjects::Proxy
+  def initialize(namespace, name, type = T.unsafe(nil)); end
+
+  def <=>(other); end
+  def ==(other); end
+  def ===(other); end
+  def class; end
+  def equal?(other); end
+  def hash; end
+  def inspect; end
+  def instance_of?(klass); end
+  def is_a?(klass); end
+  def kind_of?(klass); end
+  def method_missing(meth, *args, &block); end
+  def name(prefix = T.unsafe(nil)); end
+  def namespace; end
+  def parent; end
+  def path; end
+  def respond_to?(meth, include_private = T.unsafe(nil)); end
+  def root?; end
+  def title; end
+  def to_s; end
+  def to_str; end
+  def type; end
+  def type=(type); end
+
+  private
+
+  def proxy_path; end
+  def to_ary; end
+  def to_obj; end
+
+  class << self
+    def ===(other); end
+  end
+end
+
+class YARD::CodeObjects::ProxyMethodError < ::NoMethodError; end
+
+class YARD::CodeObjects::RootObject < ::YARD::CodeObjects::ModuleObject
+  def equal?(other); end
+  def hash; end
+  def inspect; end
+  def path; end
+  def root?; end
+  def title; end
+end
+
+class YARD::Config
+  class << self
+    def add_ignored_plugins_file; end
+    def arguments; end
+    def load; end
+    def load_autoload_plugins; end
+    def load_commandline_plugins; end
+    def load_commandline_safemode; end
+    def load_gem_plugins; end
+    def load_plugin(name); end
+    def load_plugin_failed(name, exception); end
+    def load_plugins; end
+    def options; end
+    def options=(_arg0); end
+    def read_config_file; end
+    def save; end
+    def translate_plugin_name(name); end
+    def translate_plugin_names; end
+    def with_yardopts; end
+  end
+end
+
+YARD::Config::CONFIG_DIR = T.let(T.unsafe(nil), String)
+YARD::Config::CONFIG_FILE = T.let(T.unsafe(nil), String)
+YARD::Config::DEFAULT_CONFIG_OPTIONS = T.let(T.unsafe(nil), Hash)
+YARD::Config::IGNORED_PLUGINS = T.let(T.unsafe(nil), String)
+YARD::Config::YARD_PLUGIN_PREFIX = T.let(T.unsafe(nil), Regexp)
+
+class YARD::Docstring < ::String
+  def initialize(content = T.unsafe(nil), object = T.unsafe(nil)); end
+
+  def +(other); end
+  def add_tag(*tags); end
+  def all; end
+  def all=(content, parse = T.unsafe(nil)); end
+  def blank?(only_visible_tags = T.unsafe(nil)); end
+  def delete_tag_if(&block); end
+  def delete_tags(name); end
+  def dup; end
+  def has_tag?(name); end
+  def hash_flag; end
+  def hash_flag=(v); end
+  def line; end
+  def line_range; end
+  def line_range=(_arg0); end
+  def object; end
+  def object=(_arg0); end
+  def ref_tags; end
+  def replace(content, parse = T.unsafe(nil)); end
+  def resolve_reference; end
+  def summary; end
+  def tag(name); end
+  def tags(name = T.unsafe(nil)); end
+  def to_raw; end
+  def to_s; end
+
+  private
+
+  def convert_ref_tags; end
+  def parse_comments(comments); end
+  def stable_sort_by(list); end
+
+  class << self
+    def default_parser; end
+    def default_parser=(_arg0); end
+    def new!(text, tags = T.unsafe(nil), object = T.unsafe(nil), raw_data = T.unsafe(nil), ref_object = T.unsafe(nil)); end
+    def parser(*args); end
+  end
+end
+
+YARD::Docstring::META_MATCH = T.let(T.unsafe(nil), Regexp)
+
+class YARD::DocstringParser
+  def initialize(library = T.unsafe(nil)); end
+
+  def create_directive(tag_name, tag_buf); end
+  def create_ref_tag(tag_name, name, object_name); end
+  def create_tag(tag_name, tag_buf = T.unsafe(nil)); end
+  def directives; end
+  def directives=(_arg0); end
+  def handler; end
+  def handler=(_arg0); end
+  def library; end
+  def library=(_arg0); end
+  def object; end
+  def object=(_arg0); end
+  def parse(content, object = T.unsafe(nil), handler = T.unsafe(nil)); end
+  def parse_content(content); end
+  def post_process; end
+  def raw_text; end
+  def raw_text=(_arg0); end
+  def reference; end
+  def reference=(_arg0); end
+  def state; end
+  def state=(_arg0); end
+  def tag_is_directive?(tag_name); end
+  def tags; end
+  def tags=(_arg0); end
+  def text; end
+  def text=(_arg0); end
+  def to_docstring; end
+
+  private
+
+  def call_after_parse_callbacks; end
+  def call_directives_after_parse; end
+  def detect_reference(content); end
+  def namespace; end
+
+  class << self
+    def after_parse(&block); end
+    def after_parse_callbacks; end
+  end
+end
+
+YARD::DocstringParser::META_MATCH = T.let(T.unsafe(nil), Regexp)
+
+module YARD::GemIndex
+  private
+
+  def all; end
+  def each(&block); end
+  def find_all_by_name(*args); end
+
+  class << self
+    def all; end
+    def each(&block); end
+    def find_all_by_name(*args); end
+  end
+end
+
+module YARD::Handlers; end
+
+class YARD::Handlers::Base
+  include ::YARD::CodeObjects
+  include ::YARD::Parser
+
+  def initialize(source_parser, stmt); end
+
+  def abort!; end
+  def call_params; end
+  def caller_method; end
+  def ensure_loaded!(object, max_retries = T.unsafe(nil)); end
+  def extra_state; end
+  def globals; end
+  def namespace; end
+  def namespace=(v); end
+  def owner; end
+  def owner=(v); end
+  def parse_block(*_arg0); end
+  def parser; end
+  def process; end
+  def push_state(opts = T.unsafe(nil)); end
+  def register(*objects); end
+  def register_docstring(object, docstring = T.unsafe(nil), stmt = T.unsafe(nil)); end
+  def register_dynamic(object); end
+  def register_ensure_loaded(object); end
+  def register_file_info(object, file = T.unsafe(nil), line = T.unsafe(nil), comments = T.unsafe(nil)); end
+  def register_group(object, group = T.unsafe(nil)); end
+  def register_module_function(object); end
+  def register_source(object, source = T.unsafe(nil), type = T.unsafe(nil)); end
+  def register_transitive_tags(object); end
+  def register_visibility(object, visibility = T.unsafe(nil)); end
+  def scope; end
+  def scope=(v); end
+  def statement; end
+  def visibility; end
+  def visibility=(v); end
+
+  class << self
+    def clear_subclasses; end
+    def handlers; end
+    def handles(*matches); end
+    def handles?(statement); end
+    def in_file(filename); end
+    def inherited(subclass); end
+    def matches_file?(filename); end
+    def namespace_only; end
+    def namespace_only?; end
+    def process(&block); end
+    def subclasses; end
+  end
+end
+
+module YARD::Handlers::C; end
+class YARD::Handlers::C::AliasHandler < ::YARD::Handlers::C::Base; end
+YARD::Handlers::C::AliasHandler::MATCH = T.let(T.unsafe(nil), Regexp)
+class YARD::Handlers::C::AttributeHandler < ::YARD::Handlers::C::Base; end
+YARD::Handlers::C::AttributeHandler::MATCH = T.let(T.unsafe(nil), Regexp)
+
+class YARD::Handlers::C::Base < ::YARD::Handlers::Base
+  include ::YARD::Parser::C
+  include ::YARD::Handlers::Common::MethodHandler
+  include ::YARD::Handlers::C::HandlerMethods
+
+  def ensure_variable_defined!(var, max_retries = T.unsafe(nil)); end
+  def namespace_for_variable(var); end
+  def namespaces; end
+  def override_comments; end
+  def parse_block(opts = T.unsafe(nil)); end
+  def process_file(file, object); end
+  def processed_files; end
+  def register_docstring(object, docstring = T.unsafe(nil), stmt = T.unsafe(nil)); end
+  def register_file_info(object, file = T.unsafe(nil), line = T.unsafe(nil), comments = T.unsafe(nil)); end
+  def register_source(object, source = T.unsafe(nil), type = T.unsafe(nil)); end
+  def register_visibility(object, visibility = T.unsafe(nil)); end
+  def symbols; end
+
+  private
+
+  def remove_var_prefix(var); end
+
+  class << self
+    def handles?(statement, processor); end
+    def statement_class(type = T.unsafe(nil)); end
+  end
+end
+
+YARD::Handlers::C::Base::ERROR_CLASS_NAMES = T.let(T.unsafe(nil), Hash)
+class YARD::Handlers::C::ClassHandler < ::YARD::Handlers::C::Base; end
+YARD::Handlers::C::ClassHandler::MATCH1 = T.let(T.unsafe(nil), Regexp)
+YARD::Handlers::C::ClassHandler::MATCH2 = T.let(T.unsafe(nil), Regexp)
+class YARD::Handlers::C::ConstantHandler < ::YARD::Handlers::C::Base; end
+YARD::Handlers::C::ConstantHandler::MATCH = T.let(T.unsafe(nil), Regexp)
+
+module YARD::Handlers::C::HandlerMethods
+  include ::YARD::Parser::C
+  include ::YARD::CodeObjects
+  include ::YARD::Handlers::Common::MethodHandler
+
+  def handle_alias(var_name, new_name, old_name); end
+  def handle_attribute(var_name, name, read, write); end
+  def handle_class(var_name, class_name, parent, in_module = T.unsafe(nil)); end
+  def handle_constants(type, var_name, const_name, value); end
+  def handle_method(scope, var_name, name, func_name, _source_file = T.unsafe(nil)); end
+  def handle_module(var_name, module_name, in_module = T.unsafe(nil)); end
+
+  private
+
+  def find_constant_docstring(object); end
+  def find_method_body(object, symbol); end
+  def record_parameters(object, symbol, src); end
+end
+
+class YARD::Handlers::C::InitHandler < ::YARD::Handlers::C::Base; end
+YARD::Handlers::C::InitHandler::MATCH = T.let(T.unsafe(nil), Regexp)
+class YARD::Handlers::C::MethodHandler < ::YARD::Handlers::C::Base; end
+YARD::Handlers::C::MethodHandler::MATCH1 = T.let(T.unsafe(nil), Regexp)
+YARD::Handlers::C::MethodHandler::MATCH2 = T.let(T.unsafe(nil), Regexp)
+YARD::Handlers::C::MethodHandler::MATCH3 = T.let(T.unsafe(nil), Regexp)
+class YARD::Handlers::C::MixinHandler < ::YARD::Handlers::C::Base; end
+YARD::Handlers::C::MixinHandler::MATCH = T.let(T.unsafe(nil), Regexp)
+class YARD::Handlers::C::ModuleHandler < ::YARD::Handlers::C::Base; end
+YARD::Handlers::C::ModuleHandler::MATCH1 = T.let(T.unsafe(nil), Regexp)
+YARD::Handlers::C::ModuleHandler::MATCH2 = T.let(T.unsafe(nil), Regexp)
+
+class YARD::Handlers::C::OverrideCommentHandler < ::YARD::Handlers::C::Base
+  def register_docstring(object, docstring = T.unsafe(nil), stmt = T.unsafe(nil)); end
+  def register_file_info(object, file = T.unsafe(nil), line = T.unsafe(nil), comments = T.unsafe(nil)); end
+end
+
+class YARD::Handlers::C::PathHandler < ::YARD::Handlers::C::Base; end
+YARD::Handlers::C::PathHandler::MATCH = T.let(T.unsafe(nil), Regexp)
+class YARD::Handlers::C::StructHandler < ::YARD::Handlers::C::Base; end
+YARD::Handlers::C::StructHandler::MATCH = T.let(T.unsafe(nil), Regexp)
+class YARD::Handlers::C::SymbolHandler < ::YARD::Handlers::C::Base; end
+YARD::Handlers::C::SymbolHandler::MATCH = T.let(T.unsafe(nil), Regexp)
+module YARD::Handlers::Common; end
+
+module YARD::Handlers::Common::MethodHandler
+  def add_predicate_return_tag(obj); end
+end
+
+class YARD::Handlers::HandlerAborted < ::RuntimeError; end
+
+class YARD::Handlers::NamespaceMissingError < ::YARD::Parser::UndocumentableError
+  def initialize(object); end
+
+  def object; end
+  def object=(_arg0); end
+end
+
+class YARD::Handlers::Processor
+  def initialize(parser); end
+
+  def extra_state; end
+  def extra_state=(_arg0); end
+  def file; end
+  def file=(_arg0); end
+  def find_handlers(statement); end
+  def globals; end
+  def globals=(_arg0); end
+  def namespace; end
+  def namespace=(_arg0); end
+  def owner; end
+  def owner=(_arg0); end
+  def parse_remaining_files; end
+  def parser_type; end
+  def parser_type=(_arg0); end
+  def process(statements); end
+  def scope; end
+  def scope=(_arg0); end
+  def visibility; end
+  def visibility=(_arg0); end
+
+  private
+
+  def handler_base_class; end
+  def handler_base_namespace; end
+  def handles?(handler, statement); end
+  def load_handlers; end
+
+  class << self
+    def namespace_for_handler; end
+    def register_handler_namespace(type, ns); end
+  end
+end
+
+module YARD::Handlers::Ruby; end
+class YARD::Handlers::Ruby::AliasHandler < ::YARD::Handlers::Ruby::Base; end
+
+class YARD::Handlers::Ruby::AttributeHandler < ::YARD::Handlers::Ruby::Base
+  protected
+
+  def validated_attribute_names(params); end
+end
+
+class YARD::Handlers::Ruby::Base < ::YARD::Handlers::Base
+  include ::YARD::Parser::Ruby
+  extend ::YARD::Parser::Ruby
+
+  def call_params; end
+  def caller_method; end
+  def parse_block(inner_node, opts = T.unsafe(nil)); end
+
+  class << self
+    def handles?(node); end
+    def meta_type(type); end
+    def method_call(name = T.unsafe(nil)); end
+  end
+end
+
+class YARD::Handlers::Ruby::ClassConditionHandler < ::YARD::Handlers::Ruby::Base
+  protected
+
+  def parse_condition; end
+  def parse_else_block; end
+  def parse_then_block; end
+end
+
+class YARD::Handlers::Ruby::ClassHandler < ::YARD::Handlers::Ruby::Base
+  include ::YARD::Handlers::Ruby::StructHandlerMethods
+  include ::YARDSorbet::Handlers::StructClassHandler
+
+  private
+
+  def create_struct_superclass(superclass, superclass_def); end
+  def extract_parameters(superclass); end
+  def parse_struct_superclass(klass, superclass); end
+  def parse_superclass(superclass); end
+  def struct_superclass_name(superclass); end
+end
+
+class YARD::Handlers::Ruby::ClassVariableHandler < ::YARD::Handlers::Ruby::Base; end
+class YARD::Handlers::Ruby::CommentHandler < ::YARD::Handlers::Ruby::Base; end
+
+class YARD::Handlers::Ruby::ConstantHandler < ::YARD::Handlers::Ruby::Base
+  include ::YARD::Handlers::Ruby::StructHandlerMethods
+
+  private
+
+  def extract_parameters(superclass); end
+  def process_constant(statement); end
+  def process_structclass(statement); end
+end
+
+class YARD::Handlers::Ruby::DSLHandler < ::YARD::Handlers::Ruby::Base
+  include ::YARD::Handlers::Ruby::DSLHandlerMethods
+end
+
+module YARD::Handlers::Ruby::DSLHandlerMethods
+  include ::YARD::CodeObjects
+  include ::YARD::Parser
+
+  def handle_comments; end
+  def register_docstring(object, docstring = T.unsafe(nil), stmt = T.unsafe(nil)); end
+
+  private
+
+  def find_attached_macro; end
+  def implicit_docstring?; end
+  def macro_name_matches(macro); end
+  def method_name; end
+  def method_signature; end
+end
+
+YARD::Handlers::Ruby::DSLHandlerMethods::IGNORE_METHODS = T.let(T.unsafe(nil), Hash)
+
+module YARD::Handlers::Ruby::DecoratorHandlerMethods
+  def process_decorator(*nodes, &block); end
+
+  private
+
+  def process_decorator_parameter(node, opts = T.unsafe(nil), &block); end
+end
+
+class YARD::Handlers::Ruby::ExceptionHandler < ::YARD::Handlers::Ruby::Base; end
+
+class YARD::Handlers::Ruby::ExtendHandler < ::YARD::Handlers::Ruby::MixinHandler
+  def scope; end
+
+  private
+
+  def process_mixin(mixin); end
+end
+
+class YARD::Handlers::Ruby::HandlesExtension
+  def initialize(name); end
+
+  def matches?(node); end
+
+  protected
+
+  def name; end
+end
+
+module YARD::Handlers::Ruby::Legacy; end
+class YARD::Handlers::Ruby::Legacy::AliasHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
+class YARD::Handlers::Ruby::Legacy::AttributeHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
+
+class YARD::Handlers::Ruby::Legacy::Base < ::YARD::Handlers::Base
+  include ::YARD::Parser::Ruby::Legacy::RubyToken
+
+  def call_params; end
+  def caller_method; end
+  def parse_block(opts = T.unsafe(nil)); end
+
+  private
+
+  def extract_method_details; end
+  def tokval(token, *accepted_types); end
+  def tokval_list(tokenlist, *accepted_types); end
+
+  class << self
+    def handles?(stmt); end
+  end
+end
+
+class YARD::Handlers::Ruby::Legacy::ClassConditionHandler < ::YARD::Handlers::Ruby::Legacy::Base
+  protected
+
+  def parse_condition; end
+  def parse_else_block; end
+  def parse_then_block; end
+end
+
+class YARD::Handlers::Ruby::Legacy::ClassHandler < ::YARD::Handlers::Ruby::Legacy::Base
+  include ::YARD::Handlers::Ruby::StructHandlerMethods
+
+  private
+
+  def create_struct_superclass(superclass, superclass_def); end
+  def extract_parameters(superstring); end
+  def parse_struct_subclass(klass, superclass_def); end
+  def parse_superclass(superclass); end
+  def struct_superclass_name(superclass); end
+end
+
+class YARD::Handlers::Ruby::Legacy::ClassVariableHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
+YARD::Handlers::Ruby::Legacy::ClassVariableHandler::HANDLER_MATCH = T.let(T.unsafe(nil), Regexp)
+class YARD::Handlers::Ruby::Legacy::CommentHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
+
+class YARD::Handlers::Ruby::Legacy::ConstantHandler < ::YARD::Handlers::Ruby::Legacy::Base
+  include ::YARD::Handlers::Ruby::StructHandlerMethods
+
+  private
+
+  def extract_parameters(parameters); end
+  def process_structclass(classname, parameters); end
+end
+
+YARD::Handlers::Ruby::Legacy::ConstantHandler::HANDLER_MATCH = T.let(T.unsafe(nil), Regexp)
+
+class YARD::Handlers::Ruby::Legacy::DSLHandler < ::YARD::Handlers::Ruby::Legacy::Base
+  include ::YARD::Handlers::Ruby::DSLHandlerMethods
+end
+
+class YARD::Handlers::Ruby::Legacy::ExceptionHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
+
+class YARD::Handlers::Ruby::Legacy::ExtendHandler < ::YARD::Handlers::Ruby::Legacy::MixinHandler
+  def scope; end
+
+  private
+
+  def process_mixin(mixin); end
+end
+
+class YARD::Handlers::Ruby::Legacy::MethodHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
+
+class YARD::Handlers::Ruby::Legacy::MixinHandler < ::YARD::Handlers::Ruby::Legacy::Base
+  private
+
+  def process_mixin(mixin); end
+end
+
+class YARD::Handlers::Ruby::Legacy::ModuleFunctionHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
+class YARD::Handlers::Ruby::Legacy::ModuleHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
+
+class YARD::Handlers::Ruby::Legacy::PrivateClassMethodHandler < ::YARD::Handlers::Ruby::Legacy::Base
+  private
+
+  def privatize_class_method(name); end
+end
+
+class YARD::Handlers::Ruby::Legacy::PrivateConstantHandler < ::YARD::Handlers::Ruby::Legacy::Base
+  private
+
+  def privatize_constant(name); end
+end
+
+class YARD::Handlers::Ruby::Legacy::VisibilityHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
+class YARD::Handlers::Ruby::Legacy::YieldHandler < ::YARD::Handlers::Ruby::Legacy::Base; end
+
+class YARD::Handlers::Ruby::MethodCallWrapper < ::YARD::Handlers::Ruby::HandlesExtension
+  def matches?(node); end
+end
+
+class YARD::Handlers::Ruby::MethodConditionHandler < ::YARD::Handlers::Ruby::Base; end
+
+class YARD::Handlers::Ruby::MethodHandler < ::YARD::Handlers::Ruby::Base
+  include ::YARD::Handlers::Common::MethodHandler
+
+  def format_args; end
+end
+
+class YARD::Handlers::Ruby::MixinHandler < ::YARD::Handlers::Ruby::Base
+  protected
+
+  def process_mixin(mixin); end
+  def recipient(mixin); end
+end
+
+class YARD::Handlers::Ruby::ModuleFunctionHandler < ::YARD::Handlers::Ruby::Base; end
+class YARD::Handlers::Ruby::ModuleHandler < ::YARD::Handlers::Ruby::Base; end
+
+class YARD::Handlers::Ruby::PrivateClassMethodHandler < ::YARD::Handlers::Ruby::Base
+  include ::YARD::Handlers::Ruby::DecoratorHandlerMethods
+end
+
+class YARD::Handlers::Ruby::PrivateConstantHandler < ::YARD::Handlers::Ruby::Base
+  private
+
+  def privatize_constant(node); end
+end
+
+class YARD::Handlers::Ruby::PublicClassMethodHandler < ::YARD::Handlers::Ruby::Base
+  include ::YARD::Handlers::Ruby::DecoratorHandlerMethods
+end
+
+module YARD::Handlers::Ruby::StructHandlerMethods
+  include ::YARD::CodeObjects
+
+  def add_reader_tags(klass, new_method, member); end
+  def add_writer_tags(klass, new_method, member); end
+  def create_attributes(klass, members); end
+  def create_class(classname, superclass); end
+  def create_member_method?(klass, member, type = T.unsafe(nil)); end
+  def create_reader(klass, member); end
+  def create_writer(klass, member); end
+  def member_tag_for_member(klass, member, type = T.unsafe(nil)); end
+  def members_from_tags(klass); end
+  def return_type_from_tag(member_tag); end
+end
+
+class YARD::Handlers::Ruby::TestNodeWrapper < ::YARD::Handlers::Ruby::HandlesExtension
+  def matches?(node); end
+end
+
+class YARD::Handlers::Ruby::VisibilityHandler < ::YARD::Handlers::Ruby::Base
+  include ::YARD::Handlers::Ruby::DecoratorHandlerMethods
+end
+
+class YARD::Handlers::Ruby::YieldHandler < ::YARD::Handlers::Ruby::Base; end
+module YARD::I18n; end
+
+class YARD::I18n::Locale
+  def initialize(name); end
+
+  def load(locale_directory); end
+  def name; end
+  def translate(message); end
+
+  class << self
+    def default; end
+    def default=(locale); end
+  end
+end
+
+class YARD::I18n::Message
+  def initialize(id); end
+
+  def ==(other); end
+  def add_comment(comment); end
+  def add_location(path, line); end
+  def comments; end
+  def id; end
+  def locations; end
+end
+
+class YARD::I18n::Messages
+  include ::Enumerable
+
+  def initialize; end
+
+  def ==(other); end
+  def [](id); end
+  def each(&block); end
+  def register(id); end
+
+  protected
+
+  def messages; end
+end
+
+class YARD::I18n::PotGenerator
+  def initialize(relative_base_path); end
+
+  def generate; end
+  def messages; end
+  def parse_files(files); end
+  def parse_objects(objects); end
+
+  private
+
+  def current_time; end
+  def escape_message_id(message_id); end
+  def extract_documents(object); end
+  def extract_paragraphs(file); end
+  def extract_tag_documents(tag); end
+  def extract_tag_name(tag); end
+  def extract_tag_text(tag); end
+  def generate_message(pot, message); end
+  def generate_pot_creation_date_value; end
+  def header; end
+  def register_message(id); end
+end
+
+class YARD::I18n::Text
+  def initialize(input, options = T.unsafe(nil)); end
+
+  def extract_messages; end
+  def translate(locale); end
+
+  private
+
+  def emit_attribute_event(match_data, line_no); end
+  def emit_empty_line_event(line, line_no); end
+  def emit_markup_event(line, line_no); end
+  def emit_paragraph_event(paragraph, paragraph_start_line, line_no, &block); end
+  def parse(&block); end
+end
+
+class YARD::Logger < ::Logger
+  def initialize(pipe, *args); end
+
+  def <<(msg = T.unsafe(nil)); end
+  def backtrace(exc, level_meth = T.unsafe(nil)); end
+  def capture(msg, nontty_log = T.unsafe(nil)); end
+  def clear_progress; end
+  def debug(*args); end
+  def enter_level(new_level = T.unsafe(nil)); end
+  def io; end
+  def io=(pipe); end
+  def print(msg = T.unsafe(nil)); end
+  def progress(msg, nontty_log = T.unsafe(nil)); end
+  def puts(msg = T.unsafe(nil)); end
+  def show_backtraces; end
+  def show_backtraces=(_arg0); end
+  def show_progress; end
+  def show_progress=(_arg0); end
+  def warn(*args); end
+  def warn_no_continuations; end
+  def warned; end
+  def warned=(_arg0); end
+
+  private
+
+  def add(*args); end
+  def clear_line; end
+  def format_log(sev, _time, _prog, msg); end
+  def print_no_newline(msg); end
+
+  class << self
+    def instance(pipe = T.unsafe(nil)); end
+  end
+end
+
+YARD::Logger::PROGRESS_INDICATORS = T.let(T.unsafe(nil), Array)
+
+class YARD::Options
+  def ==(other); end
+  def [](key); end
+  def []=(key, value); end
+  def delete(key); end
+  def each; end
+  def inspect; end
+  def merge(opts); end
+  def method_missing(meth, *args, &block); end
+  def reset_defaults; end
+  def to_hash; end
+  def update(opts); end
+
+  class << self
+    def default_attr(key, default); end
+  end
+end
+
+module YARD::Parser; end
+
+class YARD::Parser::Base
+  def initialize(source, filename); end
+
+  def enumerator; end
+  def parse; end
+  def tokenize; end
+
+  class << self
+    def parse(source, filename = T.unsafe(nil)); end
+  end
+end
+
+module YARD::Parser::C; end
+
+class YARD::Parser::C::BodyStatement < ::YARD::Parser::C::Statement
+  def comments; end
+  def comments=(_arg0); end
+end
+
+class YARD::Parser::C::CParser < ::YARD::Parser::Base
+  def initialize(source, file = T.unsafe(nil)); end
+
+  def enumerator; end
+  def parse; end
+  def tokenize; end
+
+  private
+
+  def advance(num = T.unsafe(nil)); end
+  def advance_loop; end
+  def attach_comment(statement); end
+  def back(num = T.unsafe(nil)); end
+  def char(num = T.unsafe(nil)); end
+  def consume_body_statements; end
+  def consume_comment(add_comment = T.unsafe(nil)); end
+  def consume_directive; end
+  def consume_quote(type = T.unsafe(nil)); end
+  def consume_toplevel_statement; end
+  def consume_until(end_char, bracket_level = T.unsafe(nil), brace_level = T.unsafe(nil), add_comment = T.unsafe(nil)); end
+  def consume_whitespace; end
+  def nextchar(num = T.unsafe(nil)); end
+  def nextline; end
+  def parse_toplevel; end
+  def prevchar(num = T.unsafe(nil)); end
+  def strip_non_statement_data; end
+  def struct; end
+end
+
+class YARD::Parser::C::Comment < ::YARD::Parser::C::Statement
+  include ::YARD::Parser::C::CommentParser
+
+  def initialize(source, file = T.unsafe(nil), line = T.unsafe(nil)); end
+
+  def comments; end
+  def overrides; end
+  def overrides=(_arg0); end
+  def statement; end
+  def statement=(_arg0); end
+  def type; end
+  def type=(_arg0); end
+end
+
+module YARD::Parser::C::CommentParser
+  protected
+
+  def parse_comments(comments); end
+
+  private
+
+  def parse_callseq(comments); end
+  def parse_overrides(comments); end
+  def parse_types(types); end
+  def remove_private_comments(comment); end
+end
+
+class YARD::Parser::C::Statement
+  def initialize(source, file = T.unsafe(nil), line = T.unsafe(nil)); end
+
+  def comments_hash_flag; end
+  def comments_hash_flag=(_arg0); end
+  def comments_range; end
+  def file; end
+  def file=(_arg0); end
+  def first_line; end
+  def group; end
+  def group=(_arg0); end
+  def line; end
+  def line=(_arg0); end
+  def line_range; end
+  def show; end
+  def signature; end
+  def source; end
+  def source=(_arg0); end
+end
+
+class YARD::Parser::C::ToplevelStatement < ::YARD::Parser::C::Statement
+  def block; end
+  def block=(_arg0); end
+  def comments; end
+  def comments=(_arg0); end
+  def declaration; end
+  def declaration=(_arg0); end
+end
+
+class YARD::Parser::OrderedParser
+  def initialize(global_state, files); end
+
+  def files; end
+  def files=(_arg0); end
+  def parse; end
+end
+
+class YARD::Parser::ParserSyntaxError < ::YARD::Parser::UndocumentableError; end
+
+module YARD::Parser::Ruby
+  def s(*args); end
+end
+
+class YARD::Parser::Ruby::AstNode < ::Array
+  def initialize(type, arr, opts = T.unsafe(nil)); end
+
+  def ==(other); end
+  def block?; end
+  def call?; end
+  def children; end
+  def comments; end
+  def comments_hash_flag; end
+  def comments_range; end
+  def condition?; end
+  def def?; end
+  def docstring; end
+  def docstring=(_arg0); end
+  def docstring_hash_flag; end
+  def docstring_hash_flag=(_arg0); end
+  def docstring_range; end
+  def docstring_range=(_arg0); end
+  def file; end
+  def file=(_arg0); end
+  def first_line; end
+  def full_source; end
+  def full_source=(_arg0); end
+  def group; end
+  def group=(_arg0); end
+  def has_line?; end
+  def inspect; end
+  def jump(*node_types); end
+  def kw?; end
+  def line; end
+  def line_range; end
+  def line_range=(_arg0); end
+  def literal?; end
+  def loop?; end
+  def parent; end
+  def parent=(_arg0); end
+  def pretty_print(q); end
+  def ref?; end
+  def show; end
+  def source; end
+  def source=(_arg0); end
+  def source_range; end
+  def source_range=(_arg0); end
+  def to_s; end
+  def token?; end
+  def traverse; end
+  def type; end
+  def type=(_arg0); end
+  def unfreeze; end
+
+  private
+
+  def reset_line_info; end
+
+  class << self
+    def node_class_for(type); end
+  end
+end
+
+YARD::Parser::Ruby::AstNode::KEYWORDS = T.let(T.unsafe(nil), Hash)
+
+class YARD::Parser::Ruby::ClassNode < ::YARD::Parser::Ruby::KeywordNode
+  def block; end
+  def class_name; end
+  def superclass; end
+end
+
+class YARD::Parser::Ruby::CommentNode < ::YARD::Parser::Ruby::AstNode
+  def comments; end
+  def docstring; end
+  def docstring=(value); end
+  def first_line; end
+  def source; end
+end
+
+class YARD::Parser::Ruby::ConditionalNode < ::YARD::Parser::Ruby::KeywordNode
+  def condition; end
+  def condition?; end
+  def else_block; end
+  def then_block; end
+
+  private
+
+  def cmod?; end
+end
+
+class YARD::Parser::Ruby::KeywordNode < ::YARD::Parser::Ruby::AstNode
+  def kw?; end
+end
+
+module YARD::Parser::Ruby::Legacy; end
+
+class YARD::Parser::Ruby::Legacy::RubyLex
+  include ::YARD::Parser::Ruby::Legacy::RubyToken
+  include ::IRB
+
+  def initialize(content); end
+
+  def char_no; end
+  def continue; end
+  def exception_on_syntax_error; end
+  def exception_on_syntax_error=(_arg0); end
+  def get_read; end
+  def getc; end
+  def getc_of_rests; end
+  def gets; end
+  def identify_comment; end
+  def identify_gvar; end
+  def identify_here_document; end
+  def identify_identifier; end
+  def identify_number(start); end
+  def identify_quotation(initial_char); end
+  def identify_string(ltype, quoted = T.unsafe(nil), opener = T.unsafe(nil), initial_char = T.unsafe(nil)); end
+  def indent; end
+  def lex; end
+  def lex_init; end
+  def lex_int2; end
+  def lex_state; end
+  def line_no; end
+  def peek(i = T.unsafe(nil)); end
+  def peek_equal?(str); end
+  def read_auto_clean_up; end
+  def read_auto_clean_up=(_arg0); end
+  def read_escape; end
+  def skip_inner_expression; end
+  def skip_space; end
+  def skip_space=(_arg0); end
+  def token; end
+  def ungetc(c = T.unsafe(nil)); end
+
+  class << self
+    def debug?; end
+  end
+end
+
+YARD::Parser::Ruby::Legacy::RubyLex::ACCEPTS_COLON = T.let(T.unsafe(nil), Array)
+
+class YARD::Parser::Ruby::Legacy::RubyLex::BufferedReader
+  def initialize(content); end
+
+  def column; end
+  def divert_read_from(reserve); end
+  def get_read; end
+  def getc; end
+  def getc_already_read; end
+  def line_num; end
+  def peek(at); end
+  def peek_equal(str); end
+  def ungetc(_ch); end
+end
+
+YARD::Parser::Ruby::Legacy::RubyLex::DEINDENT_CLAUSE = T.let(T.unsafe(nil), Array)
+YARD::Parser::Ruby::Legacy::RubyLex::DLtype2Token = T.let(T.unsafe(nil), Hash)
+YARD::Parser::Ruby::Legacy::RubyLex::ENINDENT_CLAUSE = T.let(T.unsafe(nil), Array)
+YARD::Parser::Ruby::Legacy::RubyLex::Ltype2Token = T.let(T.unsafe(nil), Hash)
+YARD::Parser::Ruby::Legacy::RubyLex::PERCENT_LTYPE = T.let(T.unsafe(nil), Hash)
+YARD::Parser::Ruby::Legacy::RubyLex::PERCENT_PAREN = T.let(T.unsafe(nil), Hash)
+
+class YARD::Parser::Ruby::Legacy::RubyParser < ::YARD::Parser::Base
+  def initialize(source, _filename); end
+
+  def encoding_line; end
+  def enumerator; end
+  def parse; end
+  def shebang_line; end
+  def tokenize; end
+end
+
+module YARD::Parser::Ruby::Legacy::RubyToken
+  def Token(token, value = T.unsafe(nil)); end
+  def set_token_position(line, char); end
+
+  class << self
+    def def_token(token_n, super_token = T.unsafe(nil), reading = T.unsafe(nil), *opts); end
+  end
+end
+
+YARD::Parser::Ruby::Legacy::RubyToken::EXPR_ARG = T.let(T.unsafe(nil), Symbol)
+YARD::Parser::Ruby::Legacy::RubyToken::EXPR_BEG = T.let(T.unsafe(nil), Symbol)
+YARD::Parser::Ruby::Legacy::RubyToken::EXPR_CLASS = T.let(T.unsafe(nil), Symbol)
+YARD::Parser::Ruby::Legacy::RubyToken::EXPR_DOT = T.let(T.unsafe(nil), Symbol)
+YARD::Parser::Ruby::Legacy::RubyToken::EXPR_END = T.let(T.unsafe(nil), Symbol)
+YARD::Parser::Ruby::Legacy::RubyToken::EXPR_FNAME = T.let(T.unsafe(nil), Symbol)
+YARD::Parser::Ruby::Legacy::RubyToken::EXPR_MID = T.let(T.unsafe(nil), Symbol)
+YARD::Parser::Ruby::Legacy::RubyToken::NEWLINE_TOKEN = T.let(T.unsafe(nil), YARD::Parser::Ruby::Legacy::RubyToken::TkNL)
+
+class YARD::Parser::Ruby::Legacy::RubyToken::OPASGN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkALIAS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkAMPER < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkAND < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkANDOP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkAREF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkASET < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkASSIGN < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkASSOC < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkAT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkUnknownChar; end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkBACKQUOTE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkBACKSLASH < ::YARD::Parser::Ruby::Legacy::RubyToken::TkUnknownChar; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkBACK_REF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkBEGIN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkBITAND < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkBITNOT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkBITOR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkBITXOR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkBREAK < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkBlockContents < ::YARD::Parser::Ruby::Legacy::RubyToken::Token
+  def text; end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkCASE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkCLASS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkCMP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkCOLON < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkCOLON2 < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkCOLON3 < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkCOMMA < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkCOMMENT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkCONSTANT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkDEF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkDEFINED < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkDIV < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkDO < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkDOLLAR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkUnknownChar; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkDOT < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkDOT2 < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkDOT3 < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkDREGEXP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkNode; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkDSTRING < ::YARD::Parser::Ruby::Legacy::RubyToken::TkNode; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkDXSTRING < ::YARD::Parser::Ruby::Legacy::RubyToken::TkNode; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkELSE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkELSIF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkEND < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkEND_OF_SCRIPT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkWhitespace; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkENSURE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkEQ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkEQQ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkError < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkFALSE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkFID < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkFLOAT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkFOR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkGEQ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkGT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkGVAR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkIDENTIFIER < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkIF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkIF_MOD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkIN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkINTEGER < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkIVAR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkId < ::YARD::Parser::Ruby::Legacy::RubyToken::Token
+  def initialize(line_no, char_no, name); end
+
+  def name; end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkKW < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkLABEL < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkLBRACE < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkLBRACK < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkLEQ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkLPAREN < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkLSHFT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkLT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkMATCH < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkMINUS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkMOD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkMODULE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkMULT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkNEQ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkNEXT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkNIL < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkNL < ::YARD::Parser::Ruby::Legacy::RubyToken::TkWhitespace; end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkNMATCH < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkNOT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkNOTOP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkNTH_REF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkNode < ::YARD::Parser::Ruby::Legacy::RubyToken::Token
+  def node; end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkOPASGN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  def initialize(line_no, char_no, op); end
+
+  def op; end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkOR < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkOROP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkOp < ::YARD::Parser::Ruby::Legacy::RubyToken::Token
+  def name; end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkPLUS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkPOW < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkQUESTION < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkRBRACE < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkRBRACK < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkREDO < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkREGEXP < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkRESCUE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkRETRY < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkRETURN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkRPAREN < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkRSHFT < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+YARD::Parser::Ruby::Legacy::RubyToken::TkReading2Token = T.let(T.unsafe(nil), Hash)
+class YARD::Parser::Ruby::Legacy::RubyToken::TkSELF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkSEMICOLON < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkSPACE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkWhitespace; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkSTAR < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkSTRING < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkSUPER < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkSYMBEG < ::YARD::Parser::Ruby::Legacy::RubyToken::TkId; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkSYMBOL < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkStatementEnd < ::YARD::Parser::Ruby::Legacy::RubyToken::Token
+  def text; end
+end
+
+YARD::Parser::Ruby::Legacy::RubyToken::TkSymbol2Token = T.let(T.unsafe(nil), Hash)
+class YARD::Parser::Ruby::Legacy::RubyToken::TkTHEN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkTRUE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkUMINUS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkUNDEF < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkUNLESS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkUNLESS_MOD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkUNTIL < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkUNTIL_MOD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkUPLUS < ::YARD::Parser::Ruby::Legacy::RubyToken::TkOp
+  class << self
+    def op_name; end
+  end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkUnknownChar < ::YARD::Parser::Ruby::Legacy::RubyToken::Token
+  def initialize(line_no, char_no, _id); end
+
+  def name; end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkVal < ::YARD::Parser::Ruby::Legacy::RubyToken::Token
+  def initialize(line_no, char_no, value = T.unsafe(nil)); end
+end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::TkWHEN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkWHILE < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkWHILE_MOD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkWhitespace < ::YARD::Parser::Ruby::Legacy::RubyToken::Token; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkXSTRING < ::YARD::Parser::Ruby::Legacy::RubyToken::TkVal; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TkYIELD < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::Tk__FILE__ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::Tk__LINE__ < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TklBEGIN < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+class YARD::Parser::Ruby::Legacy::RubyToken::TklEND < ::YARD::Parser::Ruby::Legacy::RubyToken::TkKW; end
+
+class YARD::Parser::Ruby::Legacy::RubyToken::Token
+  def initialize(line_no, char_no); end
+
+  def char_no; end
+  def lex_state; end
+  def lex_state=(_arg0); end
+  def line_no; end
+  def set_text(text); end
+  def text; end
+end
+
+YARD::Parser::Ruby::Legacy::RubyToken::Token::NO_TEXT = T.let(T.unsafe(nil), String)
+YARD::Parser::Ruby::Legacy::RubyToken::TokenDefinitions = T.let(T.unsafe(nil), Array)
+
+class YARD::Parser::Ruby::Legacy::Statement
+  def initialize(tokens, block = T.unsafe(nil), comments = T.unsafe(nil)); end
+
+  def block; end
+  def comments; end
+  def comments_hash_flag; end
+  def comments_hash_flag=(_arg0); end
+  def comments_range; end
+  def comments_range=(_arg0); end
+  def first_line; end
+  def group; end
+  def group=(_arg0); end
+  def inspect; end
+  def line; end
+  def line_range; end
+  def show; end
+  def signature; end
+  def source(include_block = T.unsafe(nil)); end
+  def to_s(include_block = T.unsafe(nil)); end
+  def tokens; end
+
+  private
+
+  def clean_tokens(tokens); end
+end
+
+class YARD::Parser::Ruby::Legacy::StatementList < ::Array
+  include ::YARD::Parser::Ruby::Legacy::RubyToken
+
+  def initialize(content); end
+
+  def encoding_line; end
+  def encoding_line=(_arg0); end
+  def shebang_line; end
+  def shebang_line=(_arg0); end
+
+  private
+
+  def balances?(tk); end
+  def next_statement; end
+  def parse_statements; end
+  def peek_no_space; end
+  def process_block_token(tk); end
+  def process_complex_block_opener(tk); end
+  def process_initial_comment(tk); end
+  def process_simple_block_opener(tk); end
+  def process_statement_end(tk); end
+  def process_token(tk); end
+  def push_token(tk); end
+  def sanitize_block; end
+  def sanitize_statement_end; end
+end
+
+YARD::Parser::Ruby::Legacy::StatementList::OPEN_BLOCK_TOKENS = T.let(T.unsafe(nil), Array)
+
+class YARD::Parser::Ruby::Legacy::TokenList < ::Array
+  include ::YARD::Parser::Ruby::Legacy::RubyToken
+
+  def initialize(content = T.unsafe(nil)); end
+
+  def <<(*tokens); end
+  def push(*tokens); end
+  def squeeze(type = T.unsafe(nil)); end
+  def to_s(full_statement = T.unsafe(nil), show_block = T.unsafe(nil)); end
+
+  private
+
+  def convert_token(lex, tk); end
+  def parse_content(content); end
+end
+
+class YARD::Parser::Ruby::LiteralNode < ::YARD::Parser::Ruby::AstNode
+  def literal?; end
+end
+
+class YARD::Parser::Ruby::LoopNode < ::YARD::Parser::Ruby::KeywordNode
+  def block; end
+  def condition; end
+  def loop?; end
+end
+
+class YARD::Parser::Ruby::MethodCallNode < ::YARD::Parser::Ruby::AstNode
+  def block; end
+  def block_param; end
+  def call?; end
+  def method_name(name_only = T.unsafe(nil)); end
+  def namespace; end
+  def parameters(include_block_param = T.unsafe(nil)); end
+
+  private
+
+  def call_has_paren?; end
+  def index_adjust; end
+end
+
+class YARD::Parser::Ruby::MethodDefinitionNode < ::YARD::Parser::Ruby::AstNode
+  def block(*_arg0); end
+  def def?; end
+  def kw?; end
+  def method_name(name_only = T.unsafe(nil)); end
+  def namespace; end
+  def parameters(include_block_param = T.unsafe(nil)); end
+  def signature; end
+
+  private
+
+  def index_adjust; end
+end
+
+class YARD::Parser::Ruby::ModuleNode < ::YARD::Parser::Ruby::KeywordNode
+  def block; end
+  def module_name; end
+end
+
+class YARD::Parser::Ruby::ParameterNode < ::YARD::Parser::Ruby::AstNode
+  def block_param; end
+  def double_splat_param; end
+  def named_params; end
+  def splat_param; end
+  def unnamed_end_params; end
+  def unnamed_optional_params; end
+  def unnamed_required_params; end
+end
+
+class YARD::Parser::Ruby::ReferenceNode < ::YARD::Parser::Ruby::AstNode
+  def namespace; end
+  def path; end
+  def ref?; end
+end
+
+class YARD::Parser::Ruby::RipperParser < ::Ripper
+  def initialize(source, filename, *args); end
+
+  def ast; end
+  def charno; end
+  def comments; end
+  def encoding_line; end
+  def enumerator; end
+  def file; end
+  def file_encoding; end
+  def frozen_string_line; end
+  def on_BEGIN(*args); end
+  def on_CHAR(tok); end
+  def on_END(*args); end
+  def on___end__(tok); end
+  def on_alias(*args); end
+  def on_alias_error(*args); end
+  def on_arg_ambiguous(*args); end
+  def on_arg_paren(*args); end
+  def on_args_add(list, item); end
+  def on_args_add_block(list, item); end
+  def on_args_add_star(list, item); end
+  def on_args_forward(*args); end
+  def on_args_new(*args); end
+  def on_aryptn(*args); end
+  def on_assign(*args); end
+  def on_assign_error(*args); end
+  def on_assoc_splat(*args); end
+  def on_backref(tok); end
+  def on_backtick(tok); end
+  def on_begin(*args); end
+  def on_binary(*args); end
+  def on_block_var(*args); end
+  def on_blockarg(*args); end
+  def on_brace_block(*args); end
+  def on_break(*args); end
+  def on_call(*args); end
+  def on_case(*args); end
+  def on_class(*args); end
+  def on_class_name_error(*args); end
+  def on_comma(tok); end
+  def on_command(*args); end
+  def on_command_call(*args); end
+  def on_const(tok); end
+  def on_const_path_field(*args); end
+  def on_const_ref(*args); end
+  def on_cvar(tok); end
+  def on_def(*args); end
+  def on_defined(*args); end
+  def on_defs(*args); end
+  def on_do_block(*args); end
+  def on_dot2(*args); end
+  def on_dot3(*args); end
+  def on_else(*args); end
+  def on_elsif(*args); end
+  def on_embexpr_beg(tok); end
+  def on_embexpr_end(tok); end
+  def on_embvar(tok); end
+  def on_ensure(*args); end
+  def on_excessed_comma(*args); end
+  def on_fcall(*args); end
+  def on_field(*args); end
+  def on_float(tok); end
+  def on_for(*args); end
+  def on_gvar(tok); end
+  def on_heredoc_beg(tok); end
+  def on_heredoc_dedent(*args); end
+  def on_heredoc_end(tok); end
+  def on_hshptn(*args); end
+  def on_ident(tok); end
+  def on_if(*args); end
+  def on_if_mod(*args); end
+  def on_ifop(*args); end
+  def on_ignored_nl(tok); end
+  def on_ignored_sp(tok); end
+  def on_imaginary(tok); end
+  def on_in(*args); end
+  def on_int(tok); end
+  def on_ivar(tok); end
+  def on_kw(tok); end
+  def on_kwrest_param(*args); end
+  def on_label_end(tok); end
+  def on_lbrace(tok); end
+  def on_lparen(tok); end
+  def on_magic_comment(*args); end
+  def on_massign(*args); end
+  def on_method_add_arg(list, item); end
+  def on_method_add_block(list, item); end
+  def on_mlhs_add(list, item); end
+  def on_mlhs_add_post(list, item); end
+  def on_mlhs_add_star(list, item); end
+  def on_mlhs_new(*args); end
+  def on_mlhs_paren(*args); end
+  def on_module(*args); end
+  def on_mrhs_add(list, item); end
+  def on_mrhs_add_star(list, item); end
+  def on_mrhs_new(*args); end
+  def on_mrhs_new_from_args(*args); end
+  def on_next(*args); end
+  def on_nl(tok); end
+  def on_nokw_param(*args); end
+  def on_op(tok); end
+  def on_opassign(*args); end
+  def on_operator_ambiguous(*args); end
+  def on_param_error(*args); end
+  def on_paren(*args); end
+  def on_period(tok); end
+  def on_qsymbols_add(list, item); end
+  def on_qsymbols_beg(tok); end
+  def on_qsymbols_new(*args); end
+  def on_qwords_add(list, item); end
+  def on_qwords_beg(tok); end
+  def on_qwords_new(*args); end
+  def on_rational(tok); end
+  def on_rbrace(tok); end
+  def on_redo(*args); end
+  def on_regexp_add(list, item); end
+  def on_regexp_beg(tok); end
+  def on_regexp_end(tok); end
+  def on_regexp_literal(*args); end
+  def on_regexp_new(*args); end
+  def on_rescue_mod(*args); end
+  def on_rest_param(*args); end
+  def on_retry(*args); end
+  def on_return(*args); end
+  def on_return0(*args); end
+  def on_rparen(tok); end
+  def on_sclass(*args); end
+  def on_semicolon(tok); end
+  def on_stmts_add(list, item); end
+  def on_stmts_new(*args); end
+  def on_string_add(list, item); end
+  def on_string_concat(*args); end
+  def on_string_dvar(*args); end
+  def on_string_embexpr(*args); end
+  def on_super(*args); end
+  def on_symbeg(tok); end
+  def on_symbol(*args); end
+  def on_symbol_literal(*args); end
+  def on_symbols_add(list, item); end
+  def on_symbols_beg(tok); end
+  def on_symbols_new(*args); end
+  def on_tlambda(tok); end
+  def on_tlambeg(tok); end
+  def on_top_const_field(*args); end
+  def on_tstring_beg(tok); end
+  def on_tstring_content(tok); end
+  def on_tstring_end(tok); end
+  def on_undef(*args); end
+  def on_unless(*args); end
+  def on_unless_mod(*args); end
+  def on_until(*args); end
+  def on_until_mod(*args); end
+  def on_var_alias(*args); end
+  def on_var_field(*args); end
+  def on_var_ref(*args); end
+  def on_vcall(*args); end
+  def on_when(*args); end
+  def on_while(*args); end
+  def on_while_mod(*args); end
+  def on_word_add(list, item); end
+  def on_word_new(*args); end
+  def on_words_add(list, item); end
+  def on_words_beg(tok); end
+  def on_words_new(*args); end
+  def on_words_sep(tok); end
+  def on_xstring_add(list, item); end
+  def on_xstring_literal(*args); end
+  def on_xstring_new(*args); end
+  def on_yield(*args); end
+  def on_yield0(*args); end
+  def on_zsuper(*args); end
+  def parse; end
+  def root; end
+  def shebang_line; end
+  def tokens; end
+
+  private
+
+  def add_comment(line, node = T.unsafe(nil), before_node = T.unsafe(nil), into = T.unsafe(nil)); end
+  def add_token(token, data); end
+  def comment_starts_line?(charno); end
+  def compile_error(msg); end
+  def freeze_tree(node = T.unsafe(nil)); end
+  def insert_comments; end
+  def on_aref(*args); end
+  def on_aref_field(*args); end
+  def on_array(other); end
+  def on_assoc_new(*args); end
+  def on_assoclist_from_args(*args); end
+  def on_bare_assoc_hash(*args); end
+  def on_body_stmt(*args); end
+  def on_bodystmt(*args); end
+  def on_comment(comment); end
+  def on_const_path_ref(*args); end
+  def on_dyna_symbol(sym); end
+  def on_embdoc(text); end
+  def on_embdoc_beg(text); end
+  def on_embdoc_end(text); end
+  def on_hash(*args); end
+  def on_label(data); end
+  def on_lambda(*args); end
+  def on_lbracket(tok); end
+  def on_params(*args); end
+  def on_parse_error(msg); end
+  def on_program(*args); end
+  def on_rbracket(tok); end
+  def on_rescue(exc, *args); end
+  def on_sp(tok); end
+  def on_string_content(*args); end
+  def on_string_literal(*args); end
+  def on_top_const_ref(*args); end
+  def on_unary(op, val); end
+  def on_void_stmt; end
+  def visit_event(node); end
+  def visit_event_arr(node); end
+  def visit_ns_token(token, data, ast_token = T.unsafe(nil)); end
+end
+
+YARD::Parser::Ruby::RipperParser::AST_TOKENS = T.let(T.unsafe(nil), Array)
+YARD::Parser::Ruby::RipperParser::MAPPINGS = T.let(T.unsafe(nil), Hash)
+YARD::Parser::Ruby::RipperParser::REV_MAPPINGS = T.let(T.unsafe(nil), Hash)
+
+class YARD::Parser::Ruby::RubyParser < ::YARD::Parser::Base
+  def initialize(source, filename); end
+
+  def encoding_line; end
+  def enumerator; end
+  def frozen_string_line; end
+  def parse; end
+  def shebang_line; end
+  def tokenize; end
+end
+
+class YARD::Parser::Ruby::TokenResolver
+  include ::Enumerable
+  include ::YARD::CodeObjects::NamespaceMapper
+
+  def initialize(source, namespace = T.unsafe(nil)); end
+
+  def each; end
+
+  protected
+
+  def last_sep; end
+  def last_sep=(v); end
+  def next_object; end
+  def next_object=(v); end
+  def object; end
+  def object=(v); end
+  def skip_group; end
+  def skip_group=(v); end
+
+  private
+
+  def lookup(toktype, name); end
+  def object_resolved_types(obj = T.unsafe(nil)); end
+  def pop_state; end
+  def push_state; end
+
+  class << self
+    def state_attr(*attrs); end
+  end
+end
+
+class YARD::Parser::SourceParser
+  def initialize(parser_type = T.unsafe(nil), globals1 = T.unsafe(nil), globals2 = T.unsafe(nil)); end
+
+  def contents; end
+  def file; end
+  def file=(_arg0); end
+  def globals; end
+  def parse(content = T.unsafe(nil)); end
+  def parser_type; end
+  def tokenize(content); end
+
+  private
+
+  def convert_encoding(content); end
+  def parser_class; end
+  def parser_type=(value); end
+  def parser_type_for_filename(filename); end
+  def post_process; end
+
+  class << self
+    def after_parse_file(&block); end
+    def after_parse_file_callbacks; end
+    def after_parse_list(&block); end
+    def after_parse_list_callbacks; end
+    def before_parse_file(&block); end
+    def before_parse_file_callbacks; end
+    def before_parse_list(&block); end
+    def before_parse_list_callbacks; end
+    def parse(paths = T.unsafe(nil), excluded = T.unsafe(nil), level = T.unsafe(nil)); end
+    def parse_string(content, ptype = T.unsafe(nil)); end
+    def parser_type; end
+    def parser_type=(value); end
+    def parser_type_extensions; end
+    def parser_type_extensions=(value); end
+    def parser_type_for_extension(extension); end
+    def parser_types; end
+    def parser_types=(value); end
+    def register_parser_type(type, parser_klass, extensions = T.unsafe(nil)); end
+    def tokenize(content, ptype = T.unsafe(nil)); end
+    def validated_parser_type(type); end
+
+    private
+
+    def parse_in_order(*files); end
+  end
+end
+
+YARD::Parser::SourceParser::DEFAULT_PATH_GLOB = T.let(T.unsafe(nil), Array)
+YARD::Parser::SourceParser::ENCODING_BYTE_ORDER_MARKS = T.let(T.unsafe(nil), Hash)
+YARD::Parser::SourceParser::ENCODING_LINE = T.let(T.unsafe(nil), Regexp)
+YARD::Parser::SourceParser::FROZEN_STRING_LINE = T.let(T.unsafe(nil), Regexp)
+YARD::Parser::SourceParser::SHEBANG_LINE = T.let(T.unsafe(nil), Regexp)
+class YARD::Parser::UndocumentableError < ::RuntimeError; end
+YARD::ROOT = T.let(T.unsafe(nil), String)
+module YARD::Rake; end
+
+class YARD::Rake::YardocTask < ::Rake::TaskLib
+  def initialize(name = T.unsafe(nil)); end
+
+  def after; end
+  def after=(_arg0); end
+  def before; end
+  def before=(_arg0); end
+  def files; end
+  def files=(_arg0); end
+  def name; end
+  def name=(_arg0); end
+  def options; end
+  def options=(_arg0); end
+  def stats_options; end
+  def stats_options=(_arg0); end
+  def verifier; end
+  def verifier=(_arg0); end
+
+  protected
+
+  def define; end
+end
+
+module YARD::Registry
+  extend ::Enumerable
+
+  class << self
+    def [](path); end
+    def all(*types); end
+    def at(path); end
+    def checksum_for(data); end
+    def checksums; end
+    def clear; end
+    def delete(object); end
+    def delete_from_disk; end
+    def each(&block); end
+    def instance; end
+    def load(files = T.unsafe(nil), reparse = T.unsafe(nil)); end
+    def load!(file = T.unsafe(nil)); end
+    def load_all; end
+    def load_yardoc(file = T.unsafe(nil)); end
+    def locale(name); end
+    def lock_for_writing(file = T.unsafe(nil), &block); end
+    def locked_for_writing?(file = T.unsafe(nil)); end
+    def paths(reload = T.unsafe(nil)); end
+    def po_dir; end
+    def po_dir=(dir); end
+    def proxy_types; end
+    def register(object); end
+    def resolve(namespace, name, inheritance = T.unsafe(nil), proxy_fallback = T.unsafe(nil), type = T.unsafe(nil)); end
+    def root; end
+    def save(merge = T.unsafe(nil), file = T.unsafe(nil)); end
+    def single_object_db; end
+    def single_object_db=(v); end
+    def yardoc_file; end
+    def yardoc_file=(v); end
+    def yardoc_file_for_gem(gem, ver_require = T.unsafe(nil), for_writing = T.unsafe(nil)); end
+
+    private
+
+    def global_yardoc_file(spec, for_writing = T.unsafe(nil)); end
+    def local_yardoc_file(spec, for_writing = T.unsafe(nil)); end
+    def old_global_yardoc_file(spec, for_writing = T.unsafe(nil)); end
+    def partial_resolve(namespace, name, type = T.unsafe(nil)); end
+    def thread_local_resolver; end
+    def thread_local_store; end
+    def thread_local_store=(value); end
+  end
+end
+
+YARD::Registry::DEFAULT_PO_DIR = T.let(T.unsafe(nil), String)
+YARD::Registry::DEFAULT_YARDOC_FILE = T.let(T.unsafe(nil), String)
+YARD::Registry::LOCAL_YARDOC_INDEX = T.let(T.unsafe(nil), String)
+
+class YARD::RegistryResolver
+  include ::YARD::CodeObjects::NamespaceMapper
+
+  def initialize(registry = T.unsafe(nil)); end
+
+  def lookup_by_path(path, opts = T.unsafe(nil)); end
+
+  private
+
+  def collect_namespaces(object); end
+  def lookup_path_direct(namespace, path, type); end
+  def lookup_path_inherited(namespace, path, type); end
+  def split_on_separators_match; end
+  def starts_with_default_separator_match; end
+  def starts_with_separator_match; end
+  def validate(obj, type); end
+end
+
+class YARD::RegistryStore
+  def initialize; end
+
+  def [](key); end
+  def []=(key, value); end
+  def checksums; end
+  def delete(key); end
+  def destroy(force = T.unsafe(nil)); end
+  def file; end
+  def get(key); end
+  def keys(reload = T.unsafe(nil)); end
+  def load(file = T.unsafe(nil)); end
+  def load!(file = T.unsafe(nil)); end
+  def load_all; end
+  def locale(name); end
+  def lock_for_writing(file = T.unsafe(nil), &block); end
+  def locked_for_writing?(file = T.unsafe(nil)); end
+  def paths_for_type(type, reload = T.unsafe(nil)); end
+  def proxy_types; end
+  def put(key, value); end
+  def root; end
+  def save(merge = T.unsafe(nil), file = T.unsafe(nil)); end
+  def values(reload = T.unsafe(nil)); end
+  def values_for_type(type, reload = T.unsafe(nil)); end
+
+  protected
+
+  def checksums_path; end
+  def load_yardoc; end
+  def object_types_path; end
+  def objects_path; end
+  def proxy_types_path; end
+
+  private
+
+  def all_disk_objects; end
+  def load_checksums; end
+  def load_locale(name); end
+  def load_object_types; end
+  def load_proxy_types; end
+  def load_root; end
+  def load_yardoc_old; end
+  def write_checksums; end
+  def write_complete_lock; end
+  def write_object_types; end
+  def write_proxy_types; end
+end
+
+module YARD::Serializers; end
+
+class YARD::Serializers::Base
+  def initialize(opts = T.unsafe(nil)); end
+
+  def after_serialize(data); end
+  def before_serialize; end
+  def exists?(object); end
+  def options; end
+  def serialize(object, data); end
+  def serialized_path(object); end
+end
+
+class YARD::Serializers::FileSystemSerializer < ::YARD::Serializers::Base
+  def initialize(opts = T.unsafe(nil)); end
+
+  def basepath; end
+  def basepath=(value); end
+  def exists?(object); end
+  def extension; end
+  def extension=(value); end
+  def serialize(object, data); end
+  def serialized_path(object); end
+
+  private
+
+  def build_filename_map; end
+  def encode_path_components(*components); end
+  def mapped_name(object); end
+end
+
+class YARD::Serializers::ProcessSerializer < ::YARD::Serializers::Base
+  def initialize(cmd); end
+
+  def serialize(_object, data); end
+end
+
+class YARD::Serializers::StdoutSerializer < ::YARD::Serializers::Base
+  def initialize(wrap = T.unsafe(nil)); end
+
+  def serialize(_object, data); end
+
+  private
+
+  def word_wrap(text, _length = T.unsafe(nil)); end
+end
+
+class YARD::Serializers::YardocSerializer < ::YARD::Serializers::FileSystemSerializer
+  def initialize(yfile); end
+
+  def checksums_path; end
+  def complete?; end
+  def complete_lock_path; end
+  def deserialize(path, is_path = T.unsafe(nil)); end
+  def lock_for_writing; end
+  def locked_for_writing?; end
+  def object_types_path; end
+  def objects_path; end
+  def processing_path; end
+  def proxy_types_path; end
+  def serialize(object); end
+  def serialized_path(object); end
+
+  private
+
+  def dump(object); end
+  def internal_dump(object, first_object = T.unsafe(nil)); end
+end
+
+module YARD::Server
+  class << self
+    def register_static_path(path); end
+  end
+end
+
+class YARD::Server::Adapter
+  def initialize(libs, opts = T.unsafe(nil), server_opts = T.unsafe(nil)); end
+
+  def add_library(library); end
+  def document_root; end
+  def document_root=(_arg0); end
+  def libraries; end
+  def libraries=(_arg0); end
+  def options; end
+  def options=(_arg0); end
+  def router; end
+  def router=(_arg0); end
+  def server_options; end
+  def server_options=(_arg0); end
+  def start; end
+
+  class << self
+    def setup; end
+    def shutdown; end
+  end
+end
+
+module YARD::Server::Commands; end
+
+class YARD::Server::Commands::Base
+  def initialize(opts = T.unsafe(nil)); end
+
+  def adapter; end
+  def adapter=(_arg0); end
+  def body; end
+  def body=(_arg0); end
+  def caching; end
+  def caching=(_arg0); end
+  def call(request); end
+  def command_options; end
+  def command_options=(_arg0); end
+  def headers; end
+  def headers=(_arg0); end
+  def path; end
+  def path=(_arg0); end
+  def request; end
+  def request=(_arg0); end
+  def run; end
+  def status; end
+  def status=(_arg0); end
+
+  protected
+
+  def cache(data); end
+  def not_found; end
+  def redirect(url); end
+  def render(object = T.unsafe(nil)); end
+
+  private
+
+  def add_cache_control; end
+end
+
+class YARD::Server::Commands::DisplayFileCommand < ::YARD::Server::Commands::LibraryCommand
+  def index; end
+  def index=(_arg0); end
+  def run; end
+end
+
+class YARD::Server::Commands::DisplayObjectCommand < ::YARD::Server::Commands::LibraryCommand
+  include ::YARD::Server::DocServerHelper
+
+  def index; end
+  def not_found; end
+  def run; end
+
+  private
+
+  def object_path; end
+end
+
+class YARD::Server::Commands::FramesCommand < ::YARD::Server::Commands::DisplayObjectCommand
+  def run; end
+end
+
+class YARD::Server::Commands::LibraryCommand < ::YARD::Server::Commands::Base
+  def initialize(opts = T.unsafe(nil)); end
+
+  def call(request); end
+  def incremental; end
+  def incremental=(_arg0); end
+  def library; end
+  def library=(_arg0); end
+  def options; end
+  def options=(_arg0); end
+  def serializer; end
+  def serializer=(_arg0); end
+  def single_library; end
+  def single_library=(_arg0); end
+  def use_fork; end
+  def use_fork=(_arg0); end
+
+  private
+
+  def call_with_fork(request, &block); end
+  def call_without_fork(request); end
+  def can_fork?; end
+  def fulldoc_template; end
+  def load_yardoc; end
+  def not_prepared; end
+  def restore_template_info; end
+  def save_default_template_info; end
+  def setup_library; end
+  def setup_yardopts; end
+end
+
+YARD::Server::Commands::LibraryCommand::CAN_FORK = T.let(T.unsafe(nil), TrueClass)
+
+class YARD::Server::Commands::LibraryIndexCommand < ::YARD::Server::Commands::Base
+  def options; end
+  def options=(_arg0); end
+  def run; end
+end
+
+class YARD::Server::Commands::LibraryIndexOptions < ::YARD::CLI::YardocOptions
+  def adapter; end
+  def adapter=(_arg0); end
+  def libraries; end
+  def libraries=(_arg0); end
+  def serialize; end
+  def serialize=(_arg0); end
+  def template; end
+  def template=(_arg0); end
+  def type; end
+  def type=(_arg0); end
+end
+
+class YARD::Server::Commands::LibraryOptions < ::YARD::CLI::YardocOptions
+  def adapter; end
+  def command; end
+  def command=(_arg0); end
+  def each(&block); end
+  def frames; end
+  def frames=(_arg0); end
+  def library; end
+  def serialize; end
+  def serializer; end
+  def single_library; end
+end
+
+class YARD::Server::Commands::ListCommand < ::YARD::Server::Commands::LibraryCommand
+  include ::YARD::Templates::Helpers::BaseHelper
+
+  def run; end
+end
+
+class YARD::Server::Commands::RootRequestCommand < ::YARD::Server::Commands::Base
+  include ::WEBrick::HTTPUtils
+  include ::YARD::Server::Commands::StaticFileHelpers
+
+  def run; end
+end
+
+class YARD::Server::Commands::SearchCommand < ::YARD::Server::Commands::LibraryCommand
+  include ::YARD::Templates::Helpers::BaseHelper
+  include ::YARD::Templates::Helpers::ModuleHelper
+  include ::YARD::Server::DocServerHelper
+
+  def query; end
+  def query=(_arg0); end
+  def results; end
+  def results=(_arg0); end
+  def run; end
+  def visible_results; end
+
+  private
+
+  def search_for_object; end
+  def serve_normal; end
+  def serve_xhr; end
+  def url_for(object); end
+end
+
+class YARD::Server::Commands::StaticFileCommand < ::YARD::Server::Commands::LibraryCommand
+  include ::WEBrick::HTTPUtils
+  include ::YARD::Server::Commands::StaticFileHelpers
+
+  def run; end
+end
+
+YARD::Server::Commands::StaticFileCommand::STATIC_PATHS = T.let(T.unsafe(nil), Array)
+
+module YARD::Server::Commands::StaticFileHelpers
+  include ::WEBrick::HTTPUtils
+
+  def favicon?; end
+  def static_template_file?; end
+
+  private
+
+  def find_file(adapter, url); end
+
+  class << self
+    def find_file(adapter, url); end
+  end
+end
+
+module YARD::Server::DocServerHelper
+  def abs_url(*path_components); end
+  def base_path(path); end
+  def mtime(file); end
+  def mtime_url(file); end
+  def router; end
+  def url_for(obj, anchor = T.unsafe(nil), relative = T.unsafe(nil)); end
+  def url_for_file(filename, anchor = T.unsafe(nil)); end
+  def url_for_frameset; end
+  def url_for_index; end
+  def url_for_list(type); end
+  def url_for_main; end
+end
+
+class YARD::Server::DocServerSerializer < ::YARD::Serializers::FileSystemSerializer
+  def initialize(_command = T.unsafe(nil)); end
+
+  def serialized_path(object); end
+
+  private
+
+  def urlencode(name); end
+end
+
+class YARD::Server::FinishRequest < ::RuntimeError; end
+class YARD::Server::LibraryNotPreparedError < ::RuntimeError; end
+
+class YARD::Server::LibraryVersion
+  def initialize(name, version = T.unsafe(nil), yardoc = T.unsafe(nil), source = T.unsafe(nil)); end
+
+  def ==(other); end
+  def eql?(other); end
+  def equal?(other); end
+  def gemspec; end
+  def hash; end
+  def name; end
+  def name=(_arg0); end
+  def prepare!; end
+  def ready?; end
+  def source; end
+  def source=(_arg0); end
+  def source_path; end
+  def source_path=(_arg0); end
+  def to_s(url_format = T.unsafe(nil)); end
+  def version; end
+  def version=(_arg0); end
+  def yardoc_file; end
+  def yardoc_file=(_arg0); end
+
+  protected
+
+  def load_yardoc_from_disk; end
+  def load_yardoc_from_gem; end
+  def source_path_for_disk; end
+  def source_path_for_gem; end
+  def yardoc_file_for_gem; end
+
+  private
+
+  def load_source_path; end
+  def load_yardoc_file; end
+  def serializer; end
+end
+
+class YARD::Server::NotFoundError < ::RuntimeError; end
+
+class YARD::Server::Router
+  include ::YARD::Server::StaticCaching
+  include ::YARD::Server::Commands
+
+  def initialize(adapter); end
+
+  def adapter; end
+  def adapter=(_arg0); end
+  def call(request); end
+  def docs_prefix; end
+  def list_prefix; end
+  def parse_library_from_path(paths); end
+  def request; end
+  def request=(_arg0); end
+  def search_prefix; end
+  def static_prefix; end
+
+  protected
+
+  def final_options(library, paths); end
+  def route(path = T.unsafe(nil)); end
+  def route_docs(library, paths); end
+  def route_index; end
+  def route_list(library, paths); end
+  def route_search(library, paths); end
+  def route_static(library, paths); end
+end
+
+module YARD::Server::StaticCaching
+  def check_static_cache; end
+end
+
+class YARD::Server::WebrickAdapter < ::YARD::Server::Adapter
+  def start; end
+end
+
+class YARD::Server::WebrickServlet < ::WEBrick::HTTPServlet::AbstractServlet
+  def initialize(server, adapter); end
+
+  def adapter; end
+  def adapter=(_arg0); end
+  def do_GET(request, response); end
+end
+
+class YARD::StubProxy
+  def initialize(path, transient = T.unsafe(nil)); end
+
+  def _dump(_depth); end
+  def hash; end
+  def method_missing(meth, *args, &block); end
+
+  class << self
+    def _load(str); end
+  end
+end
+
+YARD::StubProxy::FILELEN = T.let(T.unsafe(nil), Integer)
+YARD::TEMPLATE_ROOT = T.let(T.unsafe(nil), String)
+module YARD::Tags; end
+
+class YARD::Tags::AttributeDirective < ::YARD::Tags::MethodDirective
+  def after_parse; end
+
+  protected
+
+  def method_name; end
+  def method_signature; end
+
+  private
+
+  def create_attribute_data(object); end
+  def readable?; end
+  def writable?; end
+end
+
+class YARD::Tags::DefaultFactory
+  def parse_tag(tag_name, text); end
+  def parse_tag_with_name(tag_name, text); end
+  def parse_tag_with_options(tag_name, text); end
+  def parse_tag_with_title_and_text(tag_name, text); end
+  def parse_tag_with_types(tag_name, text); end
+  def parse_tag_with_types_and_name(tag_name, text); end
+  def parse_tag_with_types_and_title(tag_name, text); end
+  def parse_tag_with_types_name_and_default(tag_name, text); end
+
+  private
+
+  def extract_name_from_text(text); end
+  def extract_title_and_desc_from_text(text); end
+  def extract_types_and_name_from_text(text, opening_types = T.unsafe(nil), closing_types = T.unsafe(nil)); end
+  def extract_types_and_name_from_text_unstripped(text, opening_types = T.unsafe(nil), closing_types = T.unsafe(nil)); end
+end
+
+YARD::Tags::DefaultFactory::TYPELIST_CLOSING_CHARS = T.let(T.unsafe(nil), String)
+YARD::Tags::DefaultFactory::TYPELIST_OPENING_CHARS = T.let(T.unsafe(nil), String)
+
+class YARD::Tags::DefaultTag < ::YARD::Tags::Tag
+  def initialize(tag_name, text, types = T.unsafe(nil), name = T.unsafe(nil), defaults = T.unsafe(nil)); end
+
+  def defaults; end
+end
+
+class YARD::Tags::Directive
+  def initialize(tag, parser); end
+
+  def after_parse; end
+  def call; end
+  def expanded_text; end
+  def expanded_text=(_arg0); end
+  def handler; end
+  def object; end
+  def parser=(_arg0); end
+  def tag; end
+  def tag=(_arg0); end
+
+  protected
+
+  def parser; end
+end
+
+class YARD::Tags::EndGroupDirective < ::YARD::Tags::Directive
+  def call; end
+end
+
+class YARD::Tags::GroupDirective < ::YARD::Tags::Directive
+  def call; end
+end
+
+class YARD::Tags::Library
+  def initialize(factory = T.unsafe(nil)); end
+
+  def abstract_tag(text); end
+  def api_tag(text); end
+  def attr_reader_tag(text); end
+  def attr_tag(text); end
+  def attr_writer_tag(text); end
+  def attribute_directive(tag, parser); end
+  def author_tag(text); end
+  def deprecated_tag(text); end
+  def directive_create(tag_name, tag_buf, parser); end
+  def endgroup_directive(tag, parser); end
+  def example_tag(text); end
+  def factory; end
+  def factory=(_arg0); end
+  def group_directive(tag, parser); end
+  def has_directive?(tag_name); end
+  def has_tag?(tag_name); end
+  def macro_directive(tag, parser); end
+  def method_directive(tag, parser); end
+  def note_tag(text); end
+  def option_tag(text); end
+  def overload_tag(text); end
+  def param_tag(text); end
+  def parse_directive(tag, parser); end
+  def private_tag(text); end
+  def raise_tag(text); end
+  def return_tag(text); end
+  def scope_directive(tag, parser); end
+  def see_tag(text); end
+  def since_tag(text); end
+  def tag_create(tag_name, tag_buf); end
+  def todo_tag(text); end
+  def version_tag(text); end
+  def visibility_directive(tag, parser); end
+  def yield_tag(text); end
+  def yieldparam_tag(text); end
+  def yieldreturn_tag(text); end
+
+  private
+
+  def directive_call(tag, parser); end
+  def send_to_factory(tag_name, meth, text); end
+
+  class << self
+    def default_factory; end
+    def default_factory=(factory); end
+    def define_directive(tag, tag_meth = T.unsafe(nil), directive_class = T.unsafe(nil)); end
+    def define_tag(label, tag, meth = T.unsafe(nil)); end
+    def directive_method_name(tag_name); end
+    def factory_method_for(tag); end
+    def factory_method_for_directive(directive); end
+    def instance; end
+    def labels; end
+    def sorted_labels; end
+    def tag_method_name(tag_name); end
+    def transitive_tags; end
+    def transitive_tags=(_arg0); end
+    def visible_tags; end
+    def visible_tags=(_arg0); end
+
+    private
+
+    def tag_or_directive_method_name(tag_name, type = T.unsafe(nil)); end
+  end
+end
+
+class YARD::Tags::MacroDirective < ::YARD::Tags::Directive
+  def call; end
+
+  private
+
+  def anonymous?; end
+  def attach?; end
+  def class_method?; end
+  def expand(macro_data); end
+  def find_or_create; end
+  def new?; end
+  def warn; end
+end
+
+class YARD::Tags::MethodDirective < ::YARD::Tags::Directive
+  def after_parse; end
+  def call; end
+
+  protected
+
+  def create_object; end
+  def method_name; end
+  def method_signature; end
+  def sanitized_tag_signature; end
+  def use_indented_text; end
+end
+
+YARD::Tags::MethodDirective::SCOPE_MATCH = T.let(T.unsafe(nil), Regexp)
+
+class YARD::Tags::OptionTag < ::YARD::Tags::Tag
+  def initialize(tag_name, name, pair); end
+
+  def pair; end
+  def pair=(_arg0); end
+end
+
+class YARD::Tags::OverloadTag < ::YARD::Tags::Tag
+  def initialize(tag_name, text); end
+
+  def docstring; end
+  def has_tag?(name); end
+  def is_a?(other); end
+  def kind_of?(other); end
+  def method_missing(*args, &block); end
+  def name(prefix = T.unsafe(nil)); end
+  def object=(value); end
+  def parameters; end
+  def signature; end
+  def tag(name); end
+  def tags(name = T.unsafe(nil)); end
+  def type; end
+
+  private
+
+  def parse_signature; end
+  def parse_tag(text); end
+end
+
+class YARD::Tags::ParseDirective < ::YARD::Tags::Directive
+  def call; end
+end
+
+module YARD::Tags::RefTag
+  def owner; end
+  def owner=(_arg0); end
+end
+
+class YARD::Tags::RefTagList
+  def initialize(tag_name, owner, name = T.unsafe(nil)); end
+
+  def name; end
+  def name=(_arg0); end
+  def owner; end
+  def owner=(_arg0); end
+  def tag_name; end
+  def tag_name=(_arg0); end
+  def tags; end
+end
+
+class YARD::Tags::ScopeDirective < ::YARD::Tags::Directive
+  def call; end
+end
+
+class YARD::Tags::Tag
+  def initialize(tag_name, text, types = T.unsafe(nil), name = T.unsafe(nil)); end
+
+  def explain_types; end
+  def name; end
+  def name=(_arg0); end
+  def object; end
+  def object=(_arg0); end
+  def tag_name; end
+  def tag_name=(_arg0); end
+  def text; end
+  def text=(_arg0); end
+  def type; end
+  def types; end
+  def types=(_arg0); end
+end
+
+class YARD::Tags::TagFormatError < ::RuntimeError; end
+
+class YARD::Tags::TypesExplainer
+  class << self
+    def explain(*types); end
+    def explain!(*types); end
+  end
+end
+
+class YARD::Tags::TypesExplainer::CollectionType < ::YARD::Tags::TypesExplainer::Type
+  def initialize(name, types); end
+
+  def to_s(_singular = T.unsafe(nil)); end
+  def types; end
+  def types=(_arg0); end
+end
+
+class YARD::Tags::TypesExplainer::FixedCollectionType < ::YARD::Tags::TypesExplainer::CollectionType
+  def to_s(_singular = T.unsafe(nil)); end
+end
+
+class YARD::Tags::TypesExplainer::HashCollectionType < ::YARD::Tags::TypesExplainer::Type
+  def initialize(name, key_types, value_types); end
+
+  def key_types; end
+  def key_types=(_arg0); end
+  def to_s(_singular = T.unsafe(nil)); end
+  def value_types; end
+  def value_types=(_arg0); end
+end
+
+class YARD::Tags::TypesExplainer::Parser
+  include ::YARD::CodeObjects
+
+  def initialize(string); end
+
+  def parse; end
+
+  class << self
+    def parse(string); end
+  end
+end
+
+YARD::Tags::TypesExplainer::Parser::TOKENS = T.let(T.unsafe(nil), Hash)
+
+class YARD::Tags::TypesExplainer::Type
+  def initialize(name); end
+
+  def name; end
+  def name=(_arg0); end
+  def to_s(singular = T.unsafe(nil)); end
+
+  private
+
+  def list_join(list); end
+end
+
+class YARD::Tags::VisibilityDirective < ::YARD::Tags::Directive
+  def call; end
+end
+
+module YARD::Templates; end
+
+module YARD::Templates::Engine
+  class << self
+    def generate(objects, options = T.unsafe(nil)); end
+    def register_template_path(path); end
+    def render(options = T.unsafe(nil)); end
+    def template(*path); end
+    def template!(path, full_paths = T.unsafe(nil)); end
+    def template_paths; end
+    def template_paths=(_arg0); end
+    def with_serializer(object, serializer); end
+
+    private
+
+    def find_template_paths(from_template, path); end
+    def set_default_options(options = T.unsafe(nil)); end
+    def template_module_name(path); end
+  end
+end
+
+module YARD::Templates::ErbCache
+  class << self
+    def clear!; end
+    def method_for(filename); end
+  end
+end
+
+module YARD::Templates::Helpers; end
+
+module YARD::Templates::Helpers::BaseHelper
+  def format_object_title(object); end
+  def format_object_type(object); end
+  def format_source(value); end
+  def format_types(list, brackets = T.unsafe(nil)); end
+  def globals; end
+  def h(text); end
+  def link_file(filename, title = T.unsafe(nil), anchor = T.unsafe(nil)); end
+  def link_include_file(file); end
+  def link_include_object(obj); end
+  def link_object(obj, title = T.unsafe(nil)); end
+  def link_url(url, title = T.unsafe(nil), params = T.unsafe(nil)); end
+  def linkify(*args); end
+  def object; end
+  def object=(_arg0); end
+  def owner; end
+  def run_verifier(list); end
+  def serializer; end
+  def serializer=(_arg0); end
+end
+
+module YARD::Templates::Helpers::FilterHelper
+  def is_class?(object); end
+  def is_method?(object); end
+  def is_module?(object); end
+  def is_namespace?(object); end
+end
+
+module YARD::Templates::Helpers::HtmlHelper
+  include ::YARD::Templates::Helpers::MarkupHelper
+  include ::YARD::Templates::Helpers::ModuleHelper
+  include ::YARD::Templates::Helpers::HtmlSyntaxHighlightHelper
+
+  def anchor_for(object); end
+  def charset; end
+  def format_object_name_list(objects); end
+  def format_types(typelist, brackets = T.unsafe(nil)); end
+  def h(text); end
+  def html_markup_asciidoc(text); end
+  def html_markup_html(text); end
+  def html_markup_markdown(text); end
+  def html_markup_none(text); end
+  def html_markup_org(text); end
+  def html_markup_pre(text); end
+  def html_markup_rdoc(text); end
+  def html_markup_ruby(source); end
+  def html_markup_text(text); end
+  def html_markup_textile(text); end
+  def html_markup_textile_strict(text); end
+  def html_syntax_highlight(source, type = T.unsafe(nil)); end
+  def html_syntax_highlight_plain(source); end
+  def htmlify(text, markup = T.unsafe(nil)); end
+  def htmlify_line(*args); end
+  def insert_include(text, markup = T.unsafe(nil)); end
+  def link_file(filename, title = T.unsafe(nil), anchor = T.unsafe(nil)); end
+  def link_include_file(file); end
+  def link_include_object(obj); end
+  def link_object(obj, title = T.unsafe(nil), anchor = T.unsafe(nil), relative = T.unsafe(nil)); end
+  def link_url(url, title = T.unsafe(nil), params = T.unsafe(nil)); end
+  def mtime(_file); end
+  def mtime_url(obj, anchor = T.unsafe(nil), relative = T.unsafe(nil)); end
+  def resolve_links(text); end
+  def signature(meth, link = T.unsafe(nil), show_extras = T.unsafe(nil), full_attr_name = T.unsafe(nil)); end
+  def signature_types(meth, link = T.unsafe(nil)); end
+  def url_for(obj, anchor = T.unsafe(nil), relative = T.unsafe(nil)); end
+  def url_for_file(filename, anchor = T.unsafe(nil)); end
+  def url_for_frameset; end
+  def url_for_index; end
+  def url_for_list(type); end
+  def url_for_main; end
+
+  private
+
+  def convert_method_to_overload(meth); end
+  def detect_lang_in_codeblock_attributes(pre_html_attrs, code_html_attrs); end
+  def parse_codeblocks(html); end
+  def parse_lang_for_codeblock(source); end
+  def tag_attrs(opts = T.unsafe(nil)); end
+  def urlencode(text); end
+
+  class << self
+    def urlencode(text); end
+  end
+end
+
+YARD::Templates::Helpers::HtmlHelper::ASCIIDOC_ATTRIBUTES = T.let(T.unsafe(nil), Hash)
+YARD::Templates::Helpers::HtmlHelper::URLMATCH = T.let(T.unsafe(nil), Regexp)
+
+module YARD::Templates::Helpers::HtmlSyntaxHighlightHelper
+  include ::YARD::Templates::Helpers::ModuleHelper
+
+  def html_syntax_highlight_ruby(source); end
+
+  private
+
+  def clean_token_object(token_obj); end
+  def html_syntax_highlight_ruby_legacy(source); end
+  def html_syntax_highlight_ruby_ripper(source); end
+end
+
+module YARD::Templates::Helpers::Markup; end
+
+class YARD::Templates::Helpers::Markup::RDocMarkdown < ::YARD::Templates::Helpers::Markup::RDocMarkup
+  def initialize(text); end
+
+  def fix_typewriter(html); end
+end
+
+class YARD::Templates::Helpers::Markup::RDocMarkup
+  def initialize(text); end
+
+  def from_path; end
+  def from_path=(_arg0); end
+  def to_html; end
+
+  private
+
+  def fix_dash_dash(text); end
+  def fix_typewriter(text); end
+end
+
+YARD::Templates::Helpers::Markup::RDocMarkup::MARKUP = RDoc::Markup
+
+class YARD::Templates::Helpers::Markup::RDocMarkupToHtml < ::RDoc::Markup::ToHtml
+  def initialize; end
+
+  def accept_paragraph(*args); end
+  def from_path; end
+  def from_path=(_arg0); end
+  def handle_special_HYPERLINK(special); end
+end
+
+module YARD::Templates::Helpers::MarkupHelper
+  def load_markup_provider(type = T.unsafe(nil)); end
+  def markup_class(type = T.unsafe(nil)); end
+  def markup_file_contents(contents); end
+  def markup_for_file(contents, filename); end
+  def markup_provider(type = T.unsafe(nil)); end
+
+  class << self
+    def clear_markup_cache; end
+    def markup_cache; end
+    def markup_cache=(_arg0); end
+  end
+end
+
+YARD::Templates::Helpers::MarkupHelper::MARKUP_EXTENSIONS = T.let(T.unsafe(nil), Hash)
+YARD::Templates::Helpers::MarkupHelper::MARKUP_FILE_SHEBANG = T.let(T.unsafe(nil), Regexp)
+YARD::Templates::Helpers::MarkupHelper::MARKUP_PROVIDERS = T.let(T.unsafe(nil), Hash)
+
+module YARD::Templates::Helpers::MethodHelper
+  def format_args(object); end
+  def format_block(object); end
+  def format_code(object, _show_lines = T.unsafe(nil)); end
+  def format_constant(value); end
+  def format_lines(object); end
+  def format_return_types(object); end
+end
+
+module YARD::Templates::Helpers::ModuleHelper
+  def prune_method_listing(list, hide_attributes = T.unsafe(nil)); end
+end
+
+module YARD::Templates::Helpers::TextHelper
+  def align_right(text, spacer = T.unsafe(nil), col = T.unsafe(nil)); end
+  def h(text); end
+  def hr(col = T.unsafe(nil), sep = T.unsafe(nil)); end
+  def indent(text, len = T.unsafe(nil)); end
+  def signature(meth); end
+  def title_align_right(text, col = T.unsafe(nil)); end
+  def wrap(text, col = T.unsafe(nil)); end
+
+  private
+
+  def resolve_links(text); end
+end
+
+module YARD::Templates::Helpers::UMLHelper
+  def format_path(object); end
+  def h(text); end
+  def tidy(data); end
+  def uml_visibility(object); end
+end
+
+class YARD::Templates::Section < ::Array
+  def initialize(name, *args); end
+
+  def <<(*args); end
+  def ==(other); end
+  def [](*args); end
+  def any(item); end
+  def dup; end
+  def eql?(other); end
+  def inspect; end
+  def name; end
+  def name=(_arg0); end
+  def place(*args); end
+  def push(*args); end
+  def to_a; end
+  def unshift(*args); end
+
+  private
+
+  def parse_sections(args); end
+end
+
+module YARD::Templates::Template
+  include ::YARD::Templates::ErbCache
+  include ::YARD::Templates::Helpers::BaseHelper
+  include ::YARD::Templates::Helpers::MethodHelper
+
+  mixes_in_class_methods ::YARD::Templates::Template::ClassMethods
+
+  def initialize(opts = T.unsafe(nil)); end
+
+  def T(*path); end
+  def class; end
+  def class=(_arg0); end
+  def erb(section, &block); end
+  def file(basename, allow_inherited = T.unsafe(nil)); end
+  def init; end
+  def inspect; end
+  def options; end
+  def options=(value); end
+  def run(opts = T.unsafe(nil), sects = T.unsafe(nil), start_at = T.unsafe(nil), break_first = T.unsafe(nil), &block); end
+  def section; end
+  def section=(_arg0); end
+  def sections(*args); end
+  def superb(sect = T.unsafe(nil), &block); end
+  def yieldall(opts = T.unsafe(nil), &block); end
+
+  protected
+
+  def erb_file_for(section); end
+  def erb_with(content, filename = T.unsafe(nil)); end
+
+  private
+
+  def add_options(opts = T.unsafe(nil)); end
+  def cache(section); end
+  def cache_filename(section); end
+  def render_section(section, &block); end
+  def set_ivars; end
+  def with_section; end
+
+  class << self
+    def extra_includes; end
+    def extra_includes=(_arg0); end
+    def include_extra(template, options); end
+    def included(klass); end
+  end
+end
+
+module YARD::Templates::Template::ClassMethods
+  def initialize(path, full_paths); end
+
+  def S(*args); end
+  def T(*path); end
+  def find_file(basename); end
+  def find_nth_file(basename, index = T.unsafe(nil)); end
+  def full_path; end
+  def full_path=(_arg0); end
+  def full_paths; end
+  def is_a?(klass); end
+  def new(*args); end
+  def path; end
+  def path=(_arg0); end
+  def reset_full_paths; end
+  def run(*args); end
+
+  private
+
+  def include_inherited(full_paths); end
+  def include_parent; end
+  def load_setup_rb; end
+end
+
+class YARD::Templates::TemplateOptions < ::YARD::Options
+  def __globals; end
+  def default_return; end
+  def default_return=(_arg0); end
+  def embed_mixins; end
+  def embed_mixins=(_arg0); end
+  def embed_mixins_match?(mixin); end
+  def format; end
+  def format=(_arg0); end
+  def globals; end
+  def globals=(_arg0); end
+  def hide_void_return; end
+  def hide_void_return=(_arg0); end
+  def highlight; end
+  def highlight=(_arg0); end
+  def index; end
+  def index=(_arg0); end
+  def markup; end
+  def markup=(_arg0); end
+  def markup_provider; end
+  def markup_provider=(_arg0); end
+  def no_highlight; end
+  def no_highlight=(value); end
+  def object; end
+  def object=(_arg0); end
+  def owner; end
+  def owner=(_arg0); end
+  def page_title; end
+  def page_title=(_arg0); end
+  def serialize; end
+  def serialize=(_arg0); end
+  def serializer; end
+  def serializer=(_arg0); end
+  def template; end
+  def template=(_arg0); end
+  def type; end
+  def type=(_arg0); end
+  def verifier; end
+  def verifier=(_arg0); end
+end
+
+YARD::VERSION = T.let(T.unsafe(nil), String)
+
+class YARD::Verifier
+  def initialize(*expressions); end
+
+  def add_expressions(*expressions); end
+  def call(object); end
+  def expressions; end
+  def expressions=(value); end
+  def method_missing(sym, *args, &block); end
+  def run(list); end
+
+  protected
+
+  def o; end
+  def object; end
+
+  private
+
+  def create_method_from_expressions; end
+  def modify_nilclass; end
+  def parse_expression(expr); end
+  def unmodify_nilclass; end
+end
+
+YARD::Verifier::NILCLASS_METHODS = T.let(T.unsafe(nil), Array)
diff --git a/sorbet/tapioca/require.rb b/sorbet/tapioca/require.rb
new file mode 100644
index 00000000..21ed7740
--- /dev/null
+++ b/sorbet/tapioca/require.rb
@@ -0,0 +1,8 @@
+# typed: strong
+# frozen_string_literal: true
+
+require "ast"
+require "method_source"
+require "parser/current"
+require "pry/forwardable"
+require "rake/tasklib"