spoom 1.5.0 → 1.7.2

data/rbi/spoom.rbi

@@ -0,0 +1,3567 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `spoom` gem.
+# Please instead update this file by running `spoom srb sigs export`.
+
+module Spoom
+  class << self
+    sig { params(ruby: ::String, file: ::String, comments: T::Boolean).returns(::Prism::Node) }
+    def parse_ruby(ruby, file:, comments: T.unsafe(nil)); end
+  end
+end
+
+module Spoom::Cli; end
+
+class Spoom::Cli::Deadcode < ::Thor
+  include ::Spoom::Colorize
+  include ::Spoom::Cli::Helper
+
+  sig { params(paths: ::String).void }
+  def deadcode(*paths); end
+
+  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+  def remove(location_string); end
+end
+
+module Spoom::Cli::Helper
+  include ::Spoom::Colorize
+
+  requires_ancestor { Thor }
+
+  sig { params(string: ::String).returns(::String) }
+  def blue(string); end
+
+  sig { params(paths: T::Array[::String], include_rbi_files: T::Boolean).returns(T::Array[::String]) }
+  def collect_files(paths, include_rbi_files: T.unsafe(nil)); end
+
+  sig { returns(T::Boolean) }
+  def color?; end
+
+  sig { params(string: ::String, color: ::Spoom::Color).returns(::String) }
+  def colorize(string, *color); end
+
+  sig { returns(::Spoom::Context) }
+  def context; end
+
+  sig { returns(::Spoom::Context) }
+  def context_requiring_sorbet!; end
+
+  sig { params(string: ::String).returns(::String) }
+  def cyan(string); end
+
+  sig { returns(::String) }
+  def exec_path; end
+
+  sig { params(string: ::String).returns(::String) }
+  def gray(string); end
+
+  sig { params(string: ::String).returns(::String) }
+  def green(string); end
+
+  sig { params(string: ::String).returns(::String) }
+  def highlight(string); end
+
+  sig { params(string: ::String).returns(::String) }
+  def red(string); end
+
+  sig { params(message: ::String).void }
+  def say(message); end
+
+  sig { params(message: ::String, status: T.nilable(::String), nl: T::Boolean).void }
+  def say_error(message, status: T.unsafe(nil), nl: T.unsafe(nil)); end
+
+  sig { params(message: ::String, status: T.nilable(::String), nl: T::Boolean).void }
+  def say_warning(message, status: T.unsafe(nil), nl: T.unsafe(nil)); end
+
+  sig { params(string: ::String).returns(::String) }
+  def yellow(string); end
+end
+
+class Spoom::Cli::Main < ::Thor
+  include ::Spoom::Colorize
+  include ::Spoom::Cli::Helper
+
+  def __print_version; end
+
+  sig { params(directory: ::String).void }
+  def bump(directory = T.unsafe(nil)); end
+
+  def coverage(*args); end
+  def deadcode(*args); end
+  def lsp(*args); end
+  def srb(*args); end
+  def tc(*paths_to_select); end
+
+  class << self
+    def exit_on_failure?; end
+  end
+end
+
+Spoom::Cli::Main::SORT_CODE = T.let(T.unsafe(nil), String)
+Spoom::Cli::Main::SORT_ENUM = T.let(T.unsafe(nil), Array)
+Spoom::Cli::Main::SORT_LOC = T.let(T.unsafe(nil), String)
+module Spoom::Cli::Srb; end
+
+class Spoom::Cli::Srb::Assertions < ::Thor
+  include ::Spoom::Colorize
+  include ::Spoom::Cli::Helper
+
+  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+  def transform_files(files, &block); end
+  def translate(*paths); end
+end
+
+class Spoom::Cli::Srb::Bump < ::Thor
+  include ::Spoom::Colorize
+  include ::Spoom::Cli::Helper
+
+  sig { params(directory: ::String).void }
+  def bump(directory = T.unsafe(nil)); end
+
+  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+  def print_changes(files, command:, from: T.unsafe(nil), to: T.unsafe(nil), dry: T.unsafe(nil), path: T.unsafe(nil)); end
+  def undo_changes(files, from_strictness); end
+end
+
+class Spoom::Cli::Srb::Coverage < ::Thor
+  include ::Spoom::Colorize
+  include ::Spoom::Cli::Helper
+
+  def bundle_install(path, sha); end
+  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+  def message_no_data(file); end
+  def open(file = T.unsafe(nil)); end
+  def parse_time(string, option); end
+  def report; end
+  def snapshot; end
+  def timeline; end
+end
+
+Spoom::Cli::Srb::Coverage::DATA_DIR = T.let(T.unsafe(nil), String)
+
+class Spoom::Cli::Srb::LSP < ::Thor
+  include ::Spoom::Colorize
+  include ::Spoom::Cli::Helper
+
+  def defs(file, line, col); end
+  def find(query); end
+  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+  def hover(file, line, col); end
+  def list; end
+  def lsp_client; end
+  def refs(file, line, col); end
+  def run(&block); end
+  def sigs(file, line, col); end
+  def symbol_printer; end
+  def symbols(file); end
+  def to_uri(path); end
+  def types(file, line, col); end
+end
+
+class Spoom::Cli::Srb::Main < ::Thor
+  def assertions(*args); end
+  def bump(*args); end
+  def coverage(*args); end
+  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+  def lsp(*args); end
+  def metrics(*args); end
+  def sigs(*args); end
+  def tc(*args); end
+end
+
+class Spoom::Cli::Srb::Metrics < ::Thor
+  include ::Spoom::Colorize
+  include ::Spoom::Cli::Helper
+
+  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+  def show(*paths); end
+end
+
+class Spoom::Cli::Srb::Sigs < ::Thor
+  include ::Spoom::Colorize
+  include ::Spoom::Cli::Helper
+
+  def exec(context, command); end
+  def export(output_path = T.unsafe(nil)); end
+  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+  def strip(*paths); end
+  def transform_files(files, &block); end
+  def translate(*paths); end
+end
+
+class Spoom::Cli::Srb::Tc < ::Thor
+  include ::Spoom::Colorize
+  include ::Spoom::Cli::Helper
+
+  def colorize_message(message); end
+  def format_error(error, format); end
+  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+  def tc(*paths_to_select); end
+end
+
+Spoom::Cli::Srb::Tc::DEFAULT_FORMAT = T.let(T.unsafe(nil), String)
+Spoom::Cli::Srb::Tc::SORT_CODE = T.let(T.unsafe(nil), String)
+Spoom::Cli::Srb::Tc::SORT_ENUM = T.let(T.unsafe(nil), Array)
+Spoom::Cli::Srb::Tc::SORT_LOC = T.let(T.unsafe(nil), String)
+
+class Spoom::Color < ::T::Enum
+  enums do
+    BLACK = new
+    BLUE = new
+    BOLD = new
+    CLEAR = new
+    CYAN = new
+    GREEN = new
+    LIGHT_BLACK = new
+    LIGHT_BLUE = new
+    LIGHT_CYAN = new
+    LIGHT_GREEN = new
+    LIGHT_MAGENTA = new
+    LIGHT_RED = new
+    LIGHT_WHITE = new
+    LIGHT_YELLOW = new
+    MAGENTA = new
+    RED = new
+    WHITE = new
+    YELLOW = new
+  end
+
+  sig { returns(::String) }
+  def ansi_code; end
+end
+
+module Spoom::Colorize
+  sig { params(string: ::String, color: ::Spoom::Color).returns(::String) }
+  def set_color(string, *color); end
+end
+
+class Spoom::Context
+  include ::Spoom::Context::Bundle
+  include ::Spoom::Context::Exec
+  include ::Spoom::Context::FileSystem
+  include ::Spoom::Context::Git
+  include ::Spoom::Context::Sorbet
+
+  sig { params(absolute_path: ::String).void }
+  def initialize(absolute_path); end
+
+  sig { returns(::String) }
+  def absolute_path; end
+
+  class << self
+    sig { params(name: T.nilable(::String)).returns(T.attached_class) }
+    def mktmp!(name = T.unsafe(nil)); end
+  end
+end
+
+module Spoom::Context::Bundle
+  requires_ancestor { Spoom::Context }
+
+  sig { params(command: ::String, version: T.nilable(::String), capture_err: T::Boolean).returns(::Spoom::ExecResult) }
+  def bundle(command, version: T.unsafe(nil), capture_err: T.unsafe(nil)); end
+
+  sig { params(command: ::String, version: T.nilable(::String), capture_err: T::Boolean).returns(::Spoom::ExecResult) }
+  def bundle_exec(command, version: T.unsafe(nil), capture_err: T.unsafe(nil)); end
+
+  sig { params(version: T.nilable(::String), capture_err: T::Boolean).returns(::Spoom::ExecResult) }
+  def bundle_install!(version: T.unsafe(nil), capture_err: T.unsafe(nil)); end
+
+  sig { params(gem: ::String).returns(T.nilable(::Gem::Version)) }
+  def gem_version_from_gemfile_lock(gem); end
+
+  sig { returns(T::Hash[::String, ::Bundler::LazySpecification]) }
+  def gemfile_lock_specs; end
+
+  sig { returns(T.nilable(::String)) }
+  def read_gemfile; end
+
+  sig { returns(T.nilable(::String)) }
+  def read_gemfile_lock; end
+
+  sig { params(contents: ::String, append: T::Boolean).void }
+  def write_gemfile!(contents, append: T.unsafe(nil)); end
+end
+
+module Spoom::Context::Exec
+  requires_ancestor { Spoom::Context }
+
+  sig { params(command: ::String, capture_err: T::Boolean).returns(::Spoom::ExecResult) }
+  def exec(command, capture_err: T.unsafe(nil)); end
+end
+
+module Spoom::Context::FileSystem
+  requires_ancestor { Spoom::Context }
+
+  sig { params(relative_path: ::String).returns(::String) }
+  def absolute_path_to(relative_path); end
+
+  sig do
+    params(
+      allow_extensions: T::Array[::String],
+      allow_mime_types: T::Array[::String],
+      exclude_patterns: T::Array[::String]
+    ).returns(T::Array[::String])
+  end
+  def collect_files(allow_extensions: T.unsafe(nil), allow_mime_types: T.unsafe(nil), exclude_patterns: T.unsafe(nil)); end
+
+  sig { void }
+  def destroy!; end
+
+  sig { returns(T::Boolean) }
+  def exist?; end
+
+  sig { params(relative_path: ::String).returns(T::Boolean) }
+  def file?(relative_path); end
+
+  sig { params(pattern: ::String).returns(T::Array[::String]) }
+  def glob(pattern = T.unsafe(nil)); end
+
+  sig { returns(T::Array[::String]) }
+  def list; end
+
+  sig { void }
+  def mkdir!; end
+
+  sig { params(from_relative_path: ::String, to_relative_path: ::String).void }
+  def move!(from_relative_path, to_relative_path); end
+
+  sig { params(relative_path: ::String).returns(::String) }
+  def read(relative_path); end
+
+  sig { params(relative_path: ::String).void }
+  def remove!(relative_path); end
+
+  sig { params(relative_path: ::String, contents: ::String, append: T::Boolean).void }
+  def write!(relative_path, contents = T.unsafe(nil), append: T.unsafe(nil)); end
+end
+
+module Spoom::Context::Git
+  requires_ancestor { Spoom::Context }
+
+  sig { params(command: ::String).returns(::Spoom::ExecResult) }
+  def git(command); end
+
+  sig { params(ref: ::String).returns(::Spoom::ExecResult) }
+  def git_checkout!(ref: T.unsafe(nil)); end
+
+  sig { params(branch_name: ::String, ref: T.nilable(::String)).returns(::Spoom::ExecResult) }
+  def git_checkout_new_branch!(branch_name, ref: T.unsafe(nil)); end
+
+  sig { params(message: ::String, time: ::Time, allow_empty: T::Boolean).returns(::Spoom::ExecResult) }
+  def git_commit!(message: T.unsafe(nil), time: T.unsafe(nil), allow_empty: T.unsafe(nil)); end
+
+  sig { returns(T.nilable(::String)) }
+  def git_current_branch; end
+
+  sig { params(arg: ::String).returns(::Spoom::ExecResult) }
+  def git_diff(*arg); end
+
+  sig { params(branch: T.nilable(::String)).returns(::Spoom::ExecResult) }
+  def git_init!(branch: T.unsafe(nil)); end
+
+  sig { params(short_sha: T::Boolean).returns(T.nilable(::Spoom::Git::Commit)) }
+  def git_last_commit(short_sha: T.unsafe(nil)); end
+
+  sig { params(arg: ::String).returns(::Spoom::ExecResult) }
+  def git_log(*arg); end
+
+  sig { params(remote: ::String, ref: ::String, force: T::Boolean).returns(::Spoom::ExecResult) }
+  def git_push!(remote, ref, force: T.unsafe(nil)); end
+
+  sig { params(arg: ::String).returns(::Spoom::ExecResult) }
+  def git_show(*arg); end
+
+  sig { params(path: ::String).returns(T::Boolean) }
+  def git_workdir_clean?(path: T.unsafe(nil)); end
+end
+
+module Spoom::Context::Sorbet
+  requires_ancestor { Spoom::Context }
+
+  sig { returns(T::Boolean) }
+  def has_sorbet_config?; end
+
+  sig { params(relative_path: ::String).returns(T.nilable(::String)) }
+  def read_file_strictness(relative_path); end
+
+  sig { returns(::String) }
+  def read_sorbet_config; end
+
+  sig { returns(::Spoom::Sorbet::Config) }
+  def sorbet_config; end
+
+  sig { returns(T.nilable(::Spoom::Git::Commit)) }
+  def sorbet_intro_commit; end
+
+  sig { returns(T.nilable(::Spoom::Git::Commit)) }
+  def sorbet_removal_commit; end
+
+  sig { params(arg: ::String, sorbet_bin: T.nilable(::String), capture_err: T::Boolean).returns(::Spoom::ExecResult) }
+  def srb(*arg, sorbet_bin: T.unsafe(nil), capture_err: T.unsafe(nil)); end
+
+  sig { params(with_config: T.nilable(::Spoom::Sorbet::Config), include_rbis: T::Boolean).returns(T::Array[::String]) }
+  def srb_files(with_config: T.unsafe(nil), include_rbis: T.unsafe(nil)); end
+
+  sig do
+    params(
+      strictness: ::String,
+      with_config: T.nilable(::Spoom::Sorbet::Config),
+      include_rbis: T::Boolean
+    ).returns(T::Array[::String])
+  end
+  def srb_files_with_strictness(strictness, with_config: T.unsafe(nil), include_rbis: T.unsafe(nil)); end
+
+  sig do
+    params(
+      arg: ::String,
+      sorbet_bin: T.nilable(::String),
+      capture_err: T::Boolean
+    ).returns(T.nilable(T::Hash[::String, ::Integer]))
+  end
+  def srb_metrics(*arg, sorbet_bin: T.unsafe(nil), capture_err: T.unsafe(nil)); end
+
+  sig { params(arg: ::String, sorbet_bin: T.nilable(::String), capture_err: T::Boolean).returns(::Spoom::ExecResult) }
+  def srb_tc(*arg, sorbet_bin: T.unsafe(nil), capture_err: T.unsafe(nil)); end
+
+  sig { params(arg: ::String, sorbet_bin: T.nilable(::String), capture_err: T::Boolean).returns(T.nilable(::String)) }
+  def srb_version(*arg, sorbet_bin: T.unsafe(nil), capture_err: T.unsafe(nil)); end
+
+  sig { params(contents: ::String, append: T::Boolean).void }
+  def write_sorbet_config!(contents, append: T.unsafe(nil)); end
+end
+
+class Spoom::Counters < ::Hash
+  sig { void }
+  def initialize; end
+
+  sig { params(key: ::String).returns(::Integer) }
+  def [](key); end
+
+  sig { params(key: ::String).void }
+  def increment(key); end
+end
+
+module Spoom::Coverage
+  class << self
+    sig { params(context: ::Spoom::Context).returns(::Spoom::FileTree) }
+    def file_tree(context); end
+
+    sig do
+      params(
+        context: ::Spoom::Context,
+        snapshots: T::Array[::Spoom::Coverage::Snapshot],
+        palette: ::Spoom::Coverage::D3::ColorPalette
+      ).returns(::Spoom::Coverage::Report)
+    end
+    def report(context, snapshots, palette:); end
+
+    sig do
+      params(
+        context: ::Spoom::Context,
+        rbi: T::Boolean,
+        sorbet_bin: T.nilable(::String)
+      ).returns(::Spoom::Coverage::Snapshot)
+    end
+    def snapshot(context, rbi: T.unsafe(nil), sorbet_bin: T.unsafe(nil)); end
+  end
+end
+
+module Spoom::Coverage::Cards; end
+
+class Spoom::Coverage::Cards::Card < ::Spoom::Coverage::Template
+  sig { params(template: ::String, title: T.nilable(::String), body: T.nilable(::String)).void }
+  def initialize(template: T.unsafe(nil), title: T.unsafe(nil), body: T.unsafe(nil)); end
+
+  def body; end
+
+  sig { returns(T.nilable(::String)) }
+  def title; end
+end
+
+Spoom::Coverage::Cards::Card::TEMPLATE = T.let(T.unsafe(nil), String)
+
+class Spoom::Coverage::Cards::Erb < ::Spoom::Coverage::Cards::Card
+  abstract!
+
+  sig { void }
+  def initialize; end
+
+  sig { abstract.returns(::String) }
+  def erb; end
+
+  sig { override.returns(::String) }
+  def html; end
+end
+
+class Spoom::Coverage::Cards::Map < ::Spoom::Coverage::Cards::Card
+  sig do
+    params(
+      file_tree: ::Spoom::FileTree,
+      nodes_strictnesses: T::Hash[::Spoom::FileTree::Node, T.nilable(::String)],
+      nodes_strictness_scores: T::Hash[::Spoom::FileTree::Node, ::Float],
+      title: ::String
+    ).void
+  end
+  def initialize(file_tree:, nodes_strictnesses:, nodes_strictness_scores:, title: T.unsafe(nil)); end
+end
+
+class Spoom::Coverage::Cards::Snapshot < ::Spoom::Coverage::Cards::Card
+  sig { params(snapshot: ::Spoom::Coverage::Snapshot, title: ::String).void }
+  def initialize(snapshot:, title: T.unsafe(nil)); end
+
+  sig { returns(::Spoom::Coverage::D3::Pie::Calls) }
+  def pie_calls; end
+
+  sig { returns(::Spoom::Coverage::D3::Pie::Sigils) }
+  def pie_sigils; end
+
+  sig { returns(::Spoom::Coverage::D3::Pie::Sigs) }
+  def pie_sigs; end
+
+  sig { returns(::Spoom::Coverage::Snapshot) }
+  def snapshot; end
+end
+
+Spoom::Coverage::Cards::Snapshot::TEMPLATE = T.let(T.unsafe(nil), String)
+
+class Spoom::Coverage::Cards::SorbetIntro < ::Spoom::Coverage::Cards::Erb
+  sig { params(sorbet_intro_commit: T.nilable(::String), sorbet_intro_date: T.nilable(::Time)).void }
+  def initialize(sorbet_intro_commit: T.unsafe(nil), sorbet_intro_date: T.unsafe(nil)); end
+
+  sig { override.returns(::String) }
+  def erb; end
+end
+
+class Spoom::Coverage::Cards::Timeline < ::Spoom::Coverage::Cards::Card
+  sig { params(title: ::String, timeline: ::Spoom::Coverage::D3::Timeline).void }
+  def initialize(title:, timeline:); end
+end
+
+class Spoom::Coverage::Cards::Timeline::Calls < ::Spoom::Coverage::Cards::Timeline
+  sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
+  def initialize(snapshots:, title: T.unsafe(nil)); end
+end
+
+class Spoom::Coverage::Cards::Timeline::RBIs < ::Spoom::Coverage::Cards::Timeline
+  sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
+  def initialize(snapshots:, title: T.unsafe(nil)); end
+end
+
+class Spoom::Coverage::Cards::Timeline::Runtimes < ::Spoom::Coverage::Cards::Timeline
+  sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
+  def initialize(snapshots:, title: T.unsafe(nil)); end
+end
+
+class Spoom::Coverage::Cards::Timeline::Sigils < ::Spoom::Coverage::Cards::Timeline
+  sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
+  def initialize(snapshots:, title: T.unsafe(nil)); end
+end
+
+class Spoom::Coverage::Cards::Timeline::Sigs < ::Spoom::Coverage::Cards::Timeline
+  sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
+  def initialize(snapshots:, title: T.unsafe(nil)); end
+end
+
+class Spoom::Coverage::Cards::Timeline::Versions < ::Spoom::Coverage::Cards::Timeline
+  sig { params(snapshots: T::Array[::Spoom::Coverage::Snapshot], title: ::String).void }
+  def initialize(snapshots:, title: T.unsafe(nil)); end
+end
+
+module Spoom::Coverage::D3
+  class << self
+    sig { params(palette: ::Spoom::Coverage::D3::ColorPalette).returns(::String) }
+    def header_script(palette); end
+
+    sig { returns(::String) }
+    def header_style; end
+  end
+end
+
+class Spoom::Coverage::D3::Base
+  abstract!
+
+  sig { params(id: ::String, data: T.untyped).void }
+  def initialize(id, data); end
+
+  sig { returns(::String) }
+  def html; end
+
+  sig { returns(::String) }
+  def id; end
+
+  sig { abstract.returns(::String) }
+  def script; end
+
+  sig { returns(::String) }
+  def tooltip; end
+
+  class << self
+    sig { returns(::String) }
+    def header_script; end
+
+    sig { returns(::String) }
+    def header_style; end
+  end
+end
+
+Spoom::Coverage::D3::COLOR_FALSE = T.let(T.unsafe(nil), String)
+Spoom::Coverage::D3::COLOR_IGNORE = T.let(T.unsafe(nil), String)
+Spoom::Coverage::D3::COLOR_STRICT = T.let(T.unsafe(nil), String)
+Spoom::Coverage::D3::COLOR_STRONG = T.let(T.unsafe(nil), String)
+Spoom::Coverage::D3::COLOR_TRUE = T.let(T.unsafe(nil), String)
+
+class Spoom::Coverage::D3::CircleMap < ::Spoom::Coverage::D3::Base
+  sig { override.returns(::String) }
+  def script; end
+
+  class << self
+    sig { returns(::String) }
+    def header_script; end
+
+    sig { returns(::String) }
+    def header_style; end
+  end
+end
+
+class Spoom::Coverage::D3::CircleMap::Sigils < ::Spoom::Coverage::D3::CircleMap
+  sig do
+    params(
+      id: ::String,
+      file_tree: ::Spoom::FileTree,
+      nodes_strictnesses: T::Hash[::Spoom::FileTree::Node, T.nilable(::String)],
+      nodes_scores: T::Hash[::Spoom::FileTree::Node, ::Float]
+    ).void
+  end
+  def initialize(id, file_tree, nodes_strictnesses, nodes_scores); end
+
+  sig { params(node: ::Spoom::FileTree::Node).returns(T::Hash[::Symbol, T.untyped]) }
+  def tree_node_to_json(node); end
+end
+
+class Spoom::Coverage::D3::ColorPalette < ::T::Struct
+  prop :ignore, ::String
+  prop :false, ::String
+  prop :true, ::String
+  prop :strict, ::String
+  prop :strong, ::String
+
+  class << self
+    def inherited(s); end
+  end
+end
+
+class Spoom::Coverage::D3::Pie < ::Spoom::Coverage::D3::Base
+  abstract!
+
+  sig { params(id: ::String, title: ::String, data: T.untyped).void }
+  def initialize(id, title, data); end
+
+  sig { override.returns(::String) }
+  def script; end
+
+  class << self
+    sig { returns(::String) }
+    def header_script; end
+
+    sig { returns(::String) }
+    def header_style; end
+  end
+end
+
+class Spoom::Coverage::D3::Pie::Calls < ::Spoom::Coverage::D3::Pie
+  sig { params(id: ::String, title: ::String, snapshot: ::Spoom::Coverage::Snapshot).void }
+  def initialize(id, title, snapshot); end
+
+  sig { override.returns(::String) }
+  def tooltip; end
+end
+
+class Spoom::Coverage::D3::Pie::Sigils < ::Spoom::Coverage::D3::Pie
+  sig { params(id: ::String, title: ::String, snapshot: ::Spoom::Coverage::Snapshot).void }
+  def initialize(id, title, snapshot); end
+
+  sig { override.returns(::String) }
+  def tooltip; end
+end
+
+class Spoom::Coverage::D3::Pie::Sigs < ::Spoom::Coverage::D3::Pie
+  sig { params(id: ::String, title: ::String, snapshot: ::Spoom::Coverage::Snapshot).void }
+  def initialize(id, title, snapshot); end
+
+  sig { override.returns(::String) }
+  def tooltip; end
+end
+
+class Spoom::Coverage::D3::Timeline < ::Spoom::Coverage::D3::Base
+  abstract!
+
+  sig { params(id: ::String, data: T.untyped, keys: T::Array[::String]).void }
+  def initialize(id, data, keys); end
+
+  sig { params(y: ::String, color: ::String, curve: ::String).returns(::String) }
+  def area(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end
+
+  sig { params(y: ::String, color: ::String, curve: ::String).returns(::String) }
+  def line(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end
+
+  sig { abstract.returns(::String) }
+  def plot; end
+
+  sig { params(y: ::String).returns(::String) }
+  def points(y:); end
+
+  sig { override.returns(::String) }
+  def script; end
+
+  sig { returns(::String) }
+  def x_scale; end
+
+  sig { returns(::String) }
+  def x_ticks; end
+
+  sig { params(min: ::String, max: ::String, ticks: ::String).returns(::String) }
+  def y_scale(min:, max:, ticks:); end
+
+  sig { params(ticks: ::String, format: ::String, padding: ::Integer).returns(::String) }
+  def y_ticks(ticks:, format:, padding:); end
+
+  class << self
+    sig { returns(::String) }
+    def header_script; end
+
+    sig { returns(::String) }
+    def header_style; end
+  end
+end
+
+class Spoom::Coverage::D3::Timeline::Calls < ::Spoom::Coverage::D3::Timeline::Stacked
+  sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
+  def initialize(id, snapshots); end
+
+  sig { override.returns(::String) }
+  def tooltip; end
+end
+
+class Spoom::Coverage::D3::Timeline::RBIs < ::Spoom::Coverage::D3::Timeline::Stacked
+  sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
+  def initialize(id, snapshots); end
+
+  sig { override.params(y: ::String, color: ::String, curve: ::String).returns(::String) }
+  def line(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end
+
+  sig { override.returns(::String) }
+  def plot; end
+
+  sig { override.returns(::String) }
+  def script; end
+
+  sig { override.returns(::String) }
+  def tooltip; end
+end
+
+class Spoom::Coverage::D3::Timeline::Runtimes < ::Spoom::Coverage::D3::Timeline
+  sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
+  def initialize(id, snapshots); end
+
+  sig { override.returns(::String) }
+  def plot; end
+
+  sig { override.returns(::String) }
+  def tooltip; end
+end
+
+class Spoom::Coverage::D3::Timeline::Sigils < ::Spoom::Coverage::D3::Timeline::Stacked
+  sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
+  def initialize(id, snapshots); end
+
+  sig { override.returns(::String) }
+  def tooltip; end
+end
+
+class Spoom::Coverage::D3::Timeline::Sigs < ::Spoom::Coverage::D3::Timeline::Stacked
+  sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
+  def initialize(id, snapshots); end
+
+  sig { override.returns(::String) }
+  def tooltip; end
+end
+
+class Spoom::Coverage::D3::Timeline::Stacked < ::Spoom::Coverage::D3::Timeline
+  abstract!
+
+  sig { override.params(y: ::String, color: ::String, curve: ::String).returns(::String) }
+  def line(y:, color: T.unsafe(nil), curve: T.unsafe(nil)); end
+
+  sig { override.returns(::String) }
+  def plot; end
+
+  sig { override.returns(::String) }
+  def script; end
+end
+
+class Spoom::Coverage::D3::Timeline::Versions < ::Spoom::Coverage::D3::Timeline
+  sig { params(id: ::String, snapshots: T::Array[::Spoom::Coverage::Snapshot]).void }
+  def initialize(id, snapshots); end
+
+  sig { override.returns(::String) }
+  def plot; end
+
+  sig { override.returns(::String) }
+  def tooltip; end
+end
+
+class Spoom::Coverage::Page < ::Spoom::Coverage::Template
+  abstract!
+
+  sig { params(title: ::String, palette: ::Spoom::Coverage::D3::ColorPalette, template: ::String).void }
+  def initialize(title:, palette:, template: T.unsafe(nil)); end
+
+  sig { returns(::String) }
+  def body_html; end
+
+  sig { abstract.returns(T::Array[::Spoom::Coverage::Cards::Card]) }
+  def cards; end
+
+  sig { returns(::String) }
+  def footer_html; end
+
+  sig { returns(::String) }
+  def header_html; end
+
+  sig { returns(::String) }
+  def header_script; end
+
+  sig { returns(::String) }
+  def header_style; end
+
+  sig { returns(::Spoom::Coverage::D3::ColorPalette) }
+  def palette; end
+
+  sig { returns(::String) }
+  def title; end
+end
+
+Spoom::Coverage::Page::TEMPLATE = T.let(T.unsafe(nil), String)
+
+class Spoom::Coverage::Report < ::Spoom::Coverage::Page
+  sig do
+    params(
+      project_name: ::String,
+      palette: ::Spoom::Coverage::D3::ColorPalette,
+      snapshots: T::Array[::Spoom::Coverage::Snapshot],
+      file_tree: ::Spoom::FileTree,
+      nodes_strictnesses: T::Hash[::Spoom::FileTree::Node, T.nilable(::String)],
+      nodes_strictness_scores: T::Hash[::Spoom::FileTree::Node, ::Float],
+      sorbet_intro_commit: T.nilable(::String),
+      sorbet_intro_date: T.nilable(::Time)
+    ).void
+  end
+  def initialize(project_name:, palette:, snapshots:, file_tree:, nodes_strictnesses:, nodes_strictness_scores:, sorbet_intro_commit: T.unsafe(nil), sorbet_intro_date: T.unsafe(nil)); end
+
+  sig { override.returns(T::Array[::Spoom::Coverage::Cards::Card]) }
+  def cards; end
+
+  sig { override.returns(::String) }
+  def header_html; end
+end
+
+class Spoom::Coverage::Snapshot < ::T::Struct
+  prop :timestamp, ::Integer, default: T.unsafe(nil)
+  prop :version_static, T.nilable(::String), default: T.unsafe(nil)
+  prop :version_runtime, T.nilable(::String), default: T.unsafe(nil)
+  prop :duration, ::Integer, default: T.unsafe(nil)
+  prop :commit_sha, T.nilable(::String), default: T.unsafe(nil)
+  prop :commit_timestamp, T.nilable(::Integer), default: T.unsafe(nil)
+  prop :files, ::Integer, default: T.unsafe(nil)
+  prop :rbi_files, ::Integer, default: T.unsafe(nil)
+  prop :modules, ::Integer, default: T.unsafe(nil)
+  prop :classes, ::Integer, default: T.unsafe(nil)
+  prop :singleton_classes, ::Integer, default: T.unsafe(nil)
+  prop :methods_without_sig, ::Integer, default: T.unsafe(nil)
+  prop :methods_with_sig, ::Integer, default: T.unsafe(nil)
+  prop :calls_untyped, ::Integer, default: T.unsafe(nil)
+  prop :calls_typed, ::Integer, default: T.unsafe(nil)
+  prop :sigils, T::Hash[::String, ::Integer], default: T.unsafe(nil)
+  prop :methods_with_sig_excluding_rbis, ::Integer, default: T.unsafe(nil)
+  prop :methods_without_sig_excluding_rbis, ::Integer, default: T.unsafe(nil)
+  prop :sigils_excluding_rbis, T::Hash[::String, ::Integer], default: T.unsafe(nil)
+
+  sig { params(out: T.any(::IO, ::StringIO), colors: T::Boolean, indent_level: ::Integer).void }
+  def print(out: T.unsafe(nil), colors: T.unsafe(nil), indent_level: T.unsafe(nil)); end
+
+  sig { params(arg: T.untyped).returns(::String) }
+  def to_json(*arg); end
+
+  class << self
+    sig { params(json: ::String).returns(::Spoom::Coverage::Snapshot) }
+    def from_json(json); end
+
+    sig { params(obj: T::Hash[::String, T.untyped]).returns(::Spoom::Coverage::Snapshot) }
+    def from_obj(obj); end
+
+    def inherited(s); end
+  end
+end
+
+Spoom::Coverage::Snapshot::STRICTNESSES = T.let(T.unsafe(nil), Array)
+
+class Spoom::Coverage::SnapshotPrinter < ::Spoom::Printer
+  sig { params(snapshot: ::Spoom::Coverage::Snapshot).void }
+  def print_snapshot(snapshot); end
+
+  private
+
+  sig { params(value: T.nilable(::Integer), total: T.nilable(::Integer)).returns(::String) }
+  def percent(value, total); end
+
+  sig { params(hash: T::Hash[::String, ::Integer], total: ::Integer).void }
+  def print_map(hash, total); end
+end
+
+class Spoom::Coverage::Template
+  abstract!
+
+  sig { params(template: ::String).void }
+  def initialize(template:); end
+
+  sig { returns(::String) }
+  def erb; end
+
+  sig { returns(::Binding) }
+  def get_binding; end
+
+  sig { returns(::String) }
+  def html; end
+end
+
+module Spoom::Deadcode
+  class << self
+    sig { params(context: ::Spoom::Context).returns(T::Array[T.class_of(Spoom::Deadcode::Plugins::Base)]) }
+    def load_custom_plugins(context); end
+
+    sig { params(context: ::Spoom::Context).returns(T::Set[T.class_of(Spoom::Deadcode::Plugins::Base)]) }
+    def plugins_from_gemfile_lock(context); end
+  end
+end
+
+Spoom::Deadcode::DEFAULT_CUSTOM_PLUGINS_PATH = T.let(T.unsafe(nil), String)
+Spoom::Deadcode::DEFAULT_PLUGINS = T.let(T.unsafe(nil), Set)
+
+class Spoom::Deadcode::Definition < ::T::Struct
+  const :kind, ::Spoom::Deadcode::Definition::Kind
+  const :name, ::String
+  const :full_name, ::String
+  const :location, ::Spoom::Location
+  const :status, ::Spoom::Deadcode::Definition::Status, default: T.unsafe(nil)
+
+  sig { void }
+  def alive!; end
+
+  sig { returns(T::Boolean) }
+  def alive?; end
+
+  sig { returns(T::Boolean) }
+  def attr_reader?; end
+
+  sig { returns(T::Boolean) }
+  def attr_writer?; end
+
+  sig { returns(T::Boolean) }
+  def class?; end
+
+  sig { returns(T::Boolean) }
+  def constant?; end
+
+  sig { returns(T::Boolean) }
+  def dead?; end
+
+  sig { void }
+  def ignored!; end
+
+  sig { returns(T::Boolean) }
+  def ignored?; end
+
+  sig { returns(T::Boolean) }
+  def method?; end
+
+  sig { returns(T::Boolean) }
+  def module?; end
+
+  sig { params(args: T.untyped).returns(::String) }
+  def to_json(*args); end
+
+  class << self
+    def inherited(s); end
+  end
+end
+
+class Spoom::Deadcode::Definition::Kind < ::T::Enum
+  enums do
+    AttrReader = new
+    AttrWriter = new
+    Class = new
+    Constant = new
+    Method = new
+    Module = new
+  end
+end
+
+class Spoom::Deadcode::Definition::Status < ::T::Enum
+  enums do
+    ALIVE = new
+    DEAD = new
+    IGNORED = new
+  end
+end
+
+class Spoom::Deadcode::ERB < ::Erubi::Engine
+  sig { params(input: T.untyped, properties: T.untyped).void }
+  def initialize(input, properties = T.unsafe(nil)); end
+
+  private
+
+  sig { override.params(code: T.untyped).void }
+  def add_code(code); end
+
+  sig { override.params(indicator: T.untyped, code: T.untyped).void }
+  def add_expression(indicator, code); end
+
+  sig { override.params(_: T.untyped).void }
+  def add_postamble(_); end
+
+  sig { override.params(text: T.untyped).void }
+  def add_text(text); end
+
+  sig { params(src: T.untyped).void }
+  def flush_newline_if_pending(src); end
+end
+
+Spoom::Deadcode::ERB::BLOCK_EXPR = T.let(T.unsafe(nil), Regexp)
+
+class Spoom::Deadcode::Index
+  sig { params(model: ::Spoom::Model).void }
+  def initialize(model); end
+
+  sig { returns(T::Array[::Spoom::Deadcode::Definition]) }
+  def all_definitions; end
+
+  sig { returns(T::Array[::Spoom::Model::Reference]) }
+  def all_references; end
+
+  sig { params(plugins: T::Array[::Spoom::Deadcode::Plugins::Base]).void }
+  def apply_plugins!(plugins); end
+
+  sig { params(definition: ::Spoom::Deadcode::Definition).void }
+  def define(definition); end
+
+  sig { returns(T::Hash[::String, T::Array[::Spoom::Deadcode::Definition]]) }
+  def definitions; end
+
+  sig { params(name: ::String).returns(T::Array[::Spoom::Deadcode::Definition]) }
+  def definitions_for_name(name); end
+
+  sig { void }
+  def finalize!; end
+
+  sig { params(symbol_def: ::Spoom::Model::SymbolDef).void }
+  def ignore(symbol_def); end
+
+  sig { params(erb: ::String, file: ::String, plugins: T::Array[::Spoom::Deadcode::Plugins::Base]).void }
+  def index_erb(erb, file:, plugins: T.unsafe(nil)); end
+
+  sig { params(file: ::String, plugins: T::Array[::Spoom::Deadcode::Plugins::Base]).void }
+  def index_file(file, plugins: T.unsafe(nil)); end
+
+  sig { params(rb: ::String, file: ::String, plugins: T::Array[::Spoom::Deadcode::Plugins::Base]).void }
+  def index_ruby(rb, file:, plugins: T.unsafe(nil)); end
+
+  sig { returns(::Spoom::Model) }
+  def model; end
+
+  sig { params(name: ::String, location: ::Spoom::Location).void }
+  def reference_constant(name, location); end
+
+  sig { params(name: ::String, location: ::Spoom::Location).void }
+  def reference_method(name, location); end
+
+  sig { returns(T::Hash[::String, T::Array[::Spoom::Model::Reference]]) }
+  def references; end
+end
+
+class Spoom::Deadcode::Index::Error < ::Spoom::Error
+  sig { params(message: ::String, parent: ::Exception).void }
+  def initialize(message, parent:); end
+end
+
+class Spoom::Deadcode::Indexer < ::Spoom::Visitor
+  sig do
+    params(
+      path: ::String,
+      index: ::Spoom::Deadcode::Index,
+      plugins: T::Array[::Spoom::Deadcode::Plugins::Base]
+    ).void
+  end
+  def initialize(path, index, plugins: T.unsafe(nil)); end
+
+  sig { returns(::Spoom::Deadcode::Index) }
+  def index; end
+
+  sig { returns(::String) }
+  def path; end
+
+  sig { override.params(node: ::Prism::CallNode).void }
+  def visit_call_node(node); end
+end
+
+Spoom::Deadcode::PLUGINS_FOR_GEM = T.let(T.unsafe(nil), Hash)
+module Spoom::Deadcode::Plugins; end
+
+class Spoom::Deadcode::Plugins::ActionMailer < ::Spoom::Deadcode::Plugins::Base
+  sig { override.params(send: ::Spoom::Deadcode::Send).void }
+  def on_send(send); end
+end
+
+class Spoom::Deadcode::Plugins::ActionMailerPreview < ::Spoom::Deadcode::Plugins::Base
+  sig { override.params(definition: ::Spoom::Model::Method).void }
+  def on_define_method(definition); end
+end
+
+class Spoom::Deadcode::Plugins::ActionPack < ::Spoom::Deadcode::Plugins::Base
+  sig { override.params(definition: ::Spoom::Model::Method).void }
+  def on_define_method(definition); end
+
+  sig { override.params(send: ::Spoom::Deadcode::Send).void }
+  def on_send(send); end
+end
+
+Spoom::Deadcode::Plugins::ActionPack::CALLBACKS = T.let(T.unsafe(nil), Array)
+class Spoom::Deadcode::Plugins::ActiveJob < ::Spoom::Deadcode::Plugins::Base; end
+
+class Spoom::Deadcode::Plugins::ActiveModel < ::Spoom::Deadcode::Plugins::Base
+  sig { override.params(send: ::Spoom::Deadcode::Send).void }
+  def on_send(send); end
+end
+
+class Spoom::Deadcode::Plugins::ActiveRecord < ::Spoom::Deadcode::Plugins::Base
+  sig { override.params(send: ::Spoom::Deadcode::Send).void }
+  def on_send(send); end
+end
+
+Spoom::Deadcode::Plugins::ActiveRecord::ARRAY_METHODS = T.let(T.unsafe(nil), Array)
+Spoom::Deadcode::Plugins::ActiveRecord::CALLBACKS = T.let(T.unsafe(nil), Array)
+Spoom::Deadcode::Plugins::ActiveRecord::CALLBACK_CONDITIONS = T.let(T.unsafe(nil), Array)
+Spoom::Deadcode::Plugins::ActiveRecord::CRUD_METHODS = T.let(T.unsafe(nil), Array)
+
+class Spoom::Deadcode::Plugins::ActiveSupport < ::Spoom::Deadcode::Plugins::Base
+  sig { override.params(send: ::Spoom::Deadcode::Send).void }
+  def on_send(send); end
+end
+
+Spoom::Deadcode::Plugins::ActiveSupport::SETUP_AND_TEARDOWN_METHODS = T.let(T.unsafe(nil), Array)
+
+class Spoom::Deadcode::Plugins::Base
+  abstract!
+
+  sig { params(index: ::Spoom::Deadcode::Index).void }
+  def initialize(index); end
+
+  sig { returns(::Spoom::Deadcode::Index) }
+  def index; end
+
+  sig { params(definition: ::Spoom::Model::Attr).void }
+  def internal_on_define_accessor(definition); end
+
+  sig { params(definition: ::Spoom::Model::Class).void }
+  def internal_on_define_class(definition); end
+
+  sig { params(definition: ::Spoom::Model::Constant).void }
+  def internal_on_define_constant(definition); end
+
+  sig { params(definition: ::Spoom::Model::Method).void }
+  def internal_on_define_method(definition); end
+
+  sig { params(definition: ::Spoom::Model::Module).void }
+  def internal_on_define_module(definition); end
+
+  sig { params(definition: ::Spoom::Model::Attr).void }
+  def on_define_accessor(definition); end
+
+  sig { params(definition: ::Spoom::Model::Class).void }
+  def on_define_class(definition); end
+
+  sig { params(definition: ::Spoom::Model::Constant).void }
+  def on_define_constant(definition); end
+
+  sig { params(definition: ::Spoom::Model::Method).void }
+  def on_define_method(definition); end
+
+  sig { params(definition: ::Spoom::Model::Module).void }
+  def on_define_module(definition); end
+
+  sig { params(send: ::Spoom::Deadcode::Send).void }
+  def on_send(send); end
+
+  private
+
+  sig { params(name: ::String).returns(::String) }
+  def camelize(name); end
+
+  sig { params(name: T.nilable(::String)).returns(T::Boolean) }
+  def ignored_class_name?(name); end
+
+  sig { params(name: ::String).returns(T::Boolean) }
+  def ignored_constant_name?(name); end
+
+  sig { params(name: ::String).returns(T::Boolean) }
+  def ignored_method_name?(name); end
+
+  sig { params(name: ::String).returns(T::Boolean) }
+  def ignored_module_name?(name); end
+
+  sig { params(name: ::String, names_variable: ::Symbol, patterns_variable: ::Symbol).returns(T::Boolean) }
+  def ignored_name?(name, names_variable, patterns_variable); end
+
+  sig { params(definition: ::Spoom::Model::Class).returns(T::Boolean) }
+  def ignored_subclass?(definition); end
+
+  sig { params(const: ::Symbol).returns(T::Set[::String]) }
+  def names(const); end
+
+  sig { params(const: ::Symbol).returns(T::Array[::Regexp]) }
+  def patterns(const); end
+
+  sig { params(definition: ::Spoom::Model::Namespace, superclass_name: ::String).returns(T::Boolean) }
+  def subclass_of?(definition, superclass_name); end
+
+  class << self
+    sig { params(names: T.any(::Regexp, ::String)).void }
+    def ignore_classes_inheriting_from(*names); end
+
+    sig { params(names: T.any(::Regexp, ::String)).void }
+    def ignore_classes_named(*names); end
+
+    sig { params(names: T.any(::Regexp, ::String)).void }
+    def ignore_constants_named(*names); end
+
+    sig { params(names: T.any(::Regexp, ::String)).void }
+    def ignore_methods_named(*names); end
+
+    sig { params(names: T.any(::Regexp, ::String)).void }
+    def ignore_modules_named(*names); end
+
+    private
+
+    sig do
+      params(
+        names: T::Array[T.any(::Regexp, ::String)],
+        names_variable: ::Symbol,
+        patterns_variable: ::Symbol
+      ).void
+    end
+    def save_names_and_patterns(names, names_variable, patterns_variable); end
+  end
+end
+
+class Spoom::Deadcode::Plugins::GraphQL < ::Spoom::Deadcode::Plugins::Base
+  sig { override.params(send: ::Spoom::Deadcode::Send).void }
+  def on_send(send); end
+end
+
+class Spoom::Deadcode::Plugins::Minitest < ::Spoom::Deadcode::Plugins::Base
+  sig { override.params(definition: ::Spoom::Model::Method).void }
+  def on_define_method(definition); end
+
+  sig { override.params(send: ::Spoom::Deadcode::Send).void }
+  def on_send(send); end
+end
+
+class Spoom::Deadcode::Plugins::Namespaces < ::Spoom::Deadcode::Plugins::Base
+  sig { override.params(definition: ::Spoom::Model::Class).void }
+  def on_define_class(definition); end
+
+  sig { override.params(definition: ::Spoom::Model::Module).void }
+  def on_define_module(definition); end
+
+  private
+
+  sig { params(symbol_def: ::Spoom::Model::Namespace).returns(T::Boolean) }
+  def used_as_namespace?(symbol_def); end
+end
+
+class Spoom::Deadcode::Plugins::RSpec < ::Spoom::Deadcode::Plugins::Base; end
+
+class Spoom::Deadcode::Plugins::Rails < ::Spoom::Deadcode::Plugins::Base
+  sig { override.params(definition: ::Spoom::Model::Class).void }
+  def on_define_class(definition); end
+
+  sig { override.params(definition: ::Spoom::Model::Module).void }
+  def on_define_module(definition); end
+
+  private
+
+  sig { params(symbol_def: ::Spoom::Model::Namespace).returns(T::Boolean) }
+  def file_is_helper?(symbol_def); end
+end
+
+class Spoom::Deadcode::Plugins::Rake < ::Spoom::Deadcode::Plugins::Base; end
+
+class Spoom::Deadcode::Plugins::Rubocop < ::Spoom::Deadcode::Plugins::Base
+  sig { override.params(definition: ::Spoom::Model::Constant).void }
+  def on_define_constant(definition); end
+
+  sig { override.params(definition: ::Spoom::Model::Method).void }
+  def on_define_method(definition); end
+end
+
+Spoom::Deadcode::Plugins::Rubocop::RUBOCOP_CONSTANTS = T.let(T.unsafe(nil), Set)
+
+class Spoom::Deadcode::Plugins::Ruby < ::Spoom::Deadcode::Plugins::Base
+  sig { override.params(send: ::Spoom::Deadcode::Send).void }
+  def on_send(send); end
+
+  private
+
+  sig { params(send: ::Spoom::Deadcode::Send, node: ::Prism::Node).void }
+  def reference_symbol_as_constant(send, node); end
+end
+
+class Spoom::Deadcode::Plugins::Sorbet < ::Spoom::Deadcode::Plugins::Base
+  sig { override.params(definition: ::Spoom::Model::Constant).void }
+  def on_define_constant(definition); end
+
+  sig { override.params(definition: ::Spoom::Model::Method).void }
+  def on_define_method(definition); end
+
+  private
+
+  sig { params(definition: ::Spoom::Model::Constant).returns(T::Boolean) }
+  def sorbet_enum_constant?(definition); end
+
+  sig { params(definition: ::Spoom::Model::Constant).returns(T::Boolean) }
+  def sorbet_type_member?(definition); end
+end
+
+class Spoom::Deadcode::Plugins::Thor < ::Spoom::Deadcode::Plugins::Base
+  sig { override.params(definition: ::Spoom::Model::Method).void }
+  def on_define_method(definition); end
+end
+
+class Spoom::Deadcode::Remover
+  sig { params(context: ::Spoom::Context).void }
+  def initialize(context); end
+
+  sig { params(kind: T.nilable(::Spoom::Deadcode::Definition::Kind), location: ::Spoom::Location).returns(::String) }
+  def remove_location(kind, location); end
+end
+
+class Spoom::Deadcode::Remover::Error < ::Spoom::Error; end
+
+class Spoom::Deadcode::Remover::NodeContext
+  sig do
+    params(
+      source: ::String,
+      comments: T::Hash[::Integer, ::Prism::Comment],
+      node: ::Prism::Node,
+      nesting: T::Array[::Prism::Node]
+    ).void
+  end
+  def initialize(source, comments, node, nesting); end
+
+  sig { params(node: ::Prism::Node).returns(T::Array[::Prism::Comment]) }
+  def attached_comments(node); end
+
+  sig { returns(T.nilable(::Prism::CallNode)) }
+  def attached_sig; end
+
+  sig { returns(T::Array[::Prism::Node]) }
+  def attached_sigs; end
+
+  sig { returns(T::Hash[::Integer, ::Prism::Comment]) }
+  def comments; end
+
+  sig { params(start_line: ::Integer, end_line: ::Integer).returns(T::Array[::Prism::Comment]) }
+  def comments_between_lines(start_line, end_line); end
+
+  sig { returns(T::Array[::Prism::Node]) }
+  def nesting; end
+
+  def nesting=(_arg0); end
+
+  sig { returns(T.nilable(::Prism::Node)) }
+  def next_node; end
+
+  sig { returns(T::Array[::Prism::Node]) }
+  def next_nodes; end
+
+  sig { returns(::Prism::Node) }
+  def node; end
+
+  sig { returns(::Spoom::Deadcode::Remover::NodeContext) }
+  def parent_context; end
+
+  sig { returns(::Prism::Node) }
+  def parent_node; end
+
+  sig { returns(T.nilable(::Prism::Node)) }
+  def previous_node; end
+
+  sig { returns(T::Array[::Prism::Node]) }
+  def previous_nodes; end
+
+  sig { returns(T.nilable(::Spoom::Deadcode::Remover::NodeContext)) }
+  def sclass_context; end
+
+  sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
+  def sorbet_extend_sig?(node); end
+
+  sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
+  def sorbet_signature?(node); end
+end
+
+class Spoom::Deadcode::Remover::NodeFinder < ::Spoom::Visitor
+  sig { params(location: ::Spoom::Location, kind: T.nilable(::Spoom::Deadcode::Definition::Kind)).void }
+  def initialize(location, kind); end
+
+  sig { returns(T.nilable(::Prism::Node)) }
+  def node; end
+
+  sig { returns(T::Array[::Prism::Node]) }
+  def nodes_nesting; end
+
+  sig { override.params(node: T.nilable(::Prism::Node)).void }
+  def visit(node); end
+
+  class << self
+    sig do
+      params(
+        source: ::String,
+        location: ::Spoom::Location,
+        kind: T.nilable(::Spoom::Deadcode::Definition::Kind)
+      ).returns(::Spoom::Deadcode::Remover::NodeContext)
+    end
+    def find(source, location, kind); end
+
+    sig { params(node: ::Prism::Node, kind: ::Spoom::Deadcode::Definition::Kind).returns(T::Boolean) }
+    def node_match_kind?(node, kind); end
+  end
+end
+
+class Spoom::Deadcode::Remover::NodeRemover
+  sig do
+    params(
+      source: ::String,
+      kind: T.nilable(::Spoom::Deadcode::Definition::Kind),
+      location: ::Spoom::Location
+    ).void
+  end
+  def initialize(source, kind, location); end
+
+  sig { void }
+  def apply_edit; end
+
+  sig { returns(::String) }
+  def new_source; end
+
+  private
+
+  sig { params(context: ::Spoom::Deadcode::Remover::NodeContext).void }
+  def delete_attr_accessor(context); end
+
+  sig { params(start_char: ::Integer, end_char: ::Integer).void }
+  def delete_chars(start_char, end_char); end
+
+  sig { params(context: ::Spoom::Deadcode::Remover::NodeContext).void }
+  def delete_constant_assignment(context); end
+
+  sig { params(start_line: ::Integer, end_line: ::Integer).void }
+  def delete_lines(start_line, end_line); end
+
+  sig { params(context: ::Spoom::Deadcode::Remover::NodeContext).void }
+  def delete_node_and_comments_and_sigs(context); end
+
+  sig do
+    params(
+      node: ::Prism::Node,
+      send_context: ::Spoom::Deadcode::Remover::NodeContext,
+      was_removed: T::Boolean
+    ).void
+  end
+  def insert_accessor(node, send_context, was_removed:); end
+
+  sig { params(start_char: ::Integer, end_char: ::Integer, replacement: ::String).void }
+  def replace_chars(start_char, end_char, replacement); end
+
+  sig do
+    params(
+      node: ::Prism::CallNode,
+      name: ::String,
+      kind: T.nilable(::Spoom::Deadcode::Definition::Kind)
+    ).returns(::String)
+  end
+  def transform_sig(node, name:, kind:); end
+end
+
+class Spoom::Deadcode::Send < ::T::Struct
+  const :node, ::Prism::CallNode
+  const :name, ::String
+  const :recv, T.nilable(::Prism::Node), default: T.unsafe(nil)
+  const :args, T::Array[::Prism::Node], default: T.unsafe(nil)
+  const :block, T.nilable(::Prism::Node), default: T.unsafe(nil)
+  const :location, ::Spoom::Location
+
+  sig do
+    type_parameters(:T)
+      .params(
+        arg_type: T::Class[T.type_parameter(:T)],
+        block: T.proc.params(arg: T.type_parameter(:T)).void
+      ).void
+  end
+  def each_arg(arg_type, &block); end
+
+  sig { params(block: T.proc.params(key: ::Prism::Node, value: T.nilable(::Prism::Node)).void).void }
+  def each_arg_assoc(&block); end
+
+  class << self
+    def inherited(s); end
+  end
+end
+
+class Spoom::Error < ::StandardError; end
+
+class Spoom::ExecResult < ::T::Struct
+  const :out, ::String
+  const :err, T.nilable(::String)
+  const :status, T::Boolean
+  const :exit_code, ::Integer
+
+  sig { returns(::String) }
+  def to_s; end
+
+  class << self
+    def inherited(s); end
+  end
+end
+
+class Spoom::FileCollector
+  sig do
+    params(
+      allow_extensions: T::Array[::String],
+      allow_mime_types: T::Array[::String],
+      exclude_patterns: T::Array[::String]
+    ).void
+  end
+  def initialize(allow_extensions: T.unsafe(nil), allow_mime_types: T.unsafe(nil), exclude_patterns: T.unsafe(nil)); end
+
+  sig { returns(T::Array[::String]) }
+  def files; end
+
+  sig { params(path: ::String).void }
+  def visit_path(path); end
+
+  sig { params(paths: T::Array[::String]).void }
+  def visit_paths(paths); end
+
+  private
+
+  sig { params(path: ::String).returns(::String) }
+  def clean_path(path); end
+
+  sig { params(path: ::String).returns(T::Boolean) }
+  def excluded_file?(path); end
+
+  sig { params(path: ::String).returns(T::Boolean) }
+  def excluded_path?(path); end
+
+  sig { params(path: ::String).returns(T.nilable(::String)) }
+  def mime_type_for(path); end
+
+  sig { params(path: ::String).void }
+  def visit_directory(path); end
+
+  sig { params(path: ::String).void }
+  def visit_file(path); end
+end
+
+class Spoom::FileTree
+  sig { params(paths: T::Enumerable[::String]).void }
+  def initialize(paths = T.unsafe(nil)); end
+
+  sig { params(path: ::String).returns(::Spoom::FileTree::Node) }
+  def add_path(path); end
+
+  sig { params(paths: T::Enumerable[::String]).void }
+  def add_paths(paths); end
+
+  sig { returns(T::Array[::Spoom::FileTree::Node]) }
+  def nodes; end
+
+  sig { params(context: ::Spoom::Context).returns(T::Hash[::Spoom::FileTree::Node, ::Float]) }
+  def nodes_strictness_scores(context); end
+
+  sig { returns(T::Array[::String]) }
+  def paths; end
+
+  sig { params(context: ::Spoom::Context).returns(T::Hash[::String, ::Float]) }
+  def paths_strictness_scores(context); end
+
+  sig { params(out: T.any(::IO, ::StringIO), colors: T::Boolean).void }
+  def print(out: T.unsafe(nil), colors: T.unsafe(nil)); end
+
+  sig { returns(T::Array[::Spoom::FileTree::Node]) }
+  def roots; end
+end
+
+class Spoom::FileTree::CollectNodes < ::Spoom::FileTree::Visitor
+  sig { void }
+  def initialize; end
+
+  sig { returns(T::Array[::Spoom::FileTree::Node]) }
+  def nodes; end
+
+  sig { override.params(node: ::Spoom::FileTree::Node).void }
+  def visit_node(node); end
+end
+
+class Spoom::FileTree::CollectScores < ::Spoom::FileTree::CollectStrictnesses
+  sig { params(context: ::Spoom::Context).void }
+  def initialize(context); end
+
+  sig { returns(T::Hash[::Spoom::FileTree::Node, ::Float]) }
+  def scores; end
+
+  sig { override.params(node: ::Spoom::FileTree::Node).void }
+  def visit_node(node); end
+
+  private
+
+  sig { params(node: ::Spoom::FileTree::Node).returns(::Float) }
+  def node_score(node); end
+
+  sig { params(strictness: T.nilable(::String)).returns(::Float) }
+  def strictness_score(strictness); end
+end
+
+class Spoom::FileTree::CollectStrictnesses < ::Spoom::FileTree::Visitor
+  sig { params(context: ::Spoom::Context).void }
+  def initialize(context); end
+
+  sig { returns(T::Hash[::Spoom::FileTree::Node, T.nilable(::String)]) }
+  def strictnesses; end
+
+  sig { override.params(node: ::Spoom::FileTree::Node).void }
+  def visit_node(node); end
+end
+
+class Spoom::FileTree::Node < ::T::Struct
+  const :parent, T.nilable(::Spoom::FileTree::Node)
+  const :name, ::String
+  const :children, T::Hash[::String, ::Spoom::FileTree::Node], default: T.unsafe(nil)
+
+  sig { returns(::String) }
+  def path; end
+
+  class << self
+    def inherited(s); end
+  end
+end
+
+class Spoom::FileTree::Printer < ::Spoom::FileTree::Visitor
+  sig do
+    params(
+      strictnesses: T::Hash[::Spoom::FileTree::Node, T.nilable(::String)],
+      out: T.any(::IO, ::StringIO),
+      colors: T::Boolean
+    ).void
+  end
+  def initialize(strictnesses, out: T.unsafe(nil), colors: T.unsafe(nil)); end
+
+  sig { override.params(node: ::Spoom::FileTree::Node).void }
+  def visit_node(node); end
+
+  private
+
+  sig { params(strictness: T.nilable(::String)).returns(::Spoom::Color) }
+  def strictness_color(strictness); end
+end
+
+class Spoom::FileTree::Visitor
+  abstract!
+
+  sig { params(node: ::Spoom::FileTree::Node).void }
+  def visit_node(node); end
+
+  sig { params(nodes: T::Array[::Spoom::FileTree::Node]).void }
+  def visit_nodes(nodes); end
+
+  sig { params(tree: ::Spoom::FileTree).void }
+  def visit_tree(tree); end
+end
+
+module Spoom::Git; end
+
+class Spoom::Git::Commit < ::T::Struct
+  const :sha, ::String
+  const :time, ::Time
+
+  sig { returns(::Integer) }
+  def timestamp; end
+
+  class << self
+    def inherited(s); end
+
+    sig { params(string: ::String).returns(T.nilable(::Spoom::Git::Commit)) }
+    def parse_line(string); end
+  end
+end
+
+module Spoom::LSP; end
+
+class Spoom::LSP::Client
+  sig { params(sorbet_bin: ::String, sorbet_args: ::String, path: ::String).void }
+  def initialize(sorbet_bin, *sorbet_args, path: T.unsafe(nil)); end
+
+  sig { void }
+  def close; end
+
+  sig { params(uri: ::String, line: ::Integer, column: ::Integer).returns(T::Array[::Spoom::LSP::Location]) }
+  def definitions(uri, line, column); end
+
+  sig { params(uri: ::String).returns(T::Array[::Spoom::LSP::DocumentSymbol]) }
+  def document_symbols(uri); end
+
+  sig { params(uri: ::String, line: ::Integer, column: ::Integer).returns(T.nilable(::Spoom::LSP::Hover)) }
+  def hover(uri, line, column); end
+
+  sig { returns(::Integer) }
+  def next_id; end
+
+  sig { params(workspace_path: ::String).void }
+  def open(workspace_path); end
+
+  sig { returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+  def read; end
+
+  sig { returns(T.nilable(::String)) }
+  def read_raw; end
+
+  sig do
+    params(
+      uri: ::String,
+      line: ::Integer,
+      column: ::Integer,
+      include_decl: T::Boolean
+    ).returns(T::Array[::Spoom::LSP::Location])
+  end
+  def references(uri, line, column, include_decl = T.unsafe(nil)); end
+
+  sig { params(message: ::Spoom::LSP::Message).returns(T.nilable(T::Hash[T.untyped, T.untyped])) }
+  def send(message); end
+
+  sig { params(json_string: ::String).void }
+  def send_raw(json_string); end
+
+  sig { params(uri: ::String, line: ::Integer, column: ::Integer).returns(T::Array[::Spoom::LSP::SignatureHelp]) }
+  def signatures(uri, line, column); end
+
+  sig { params(query: ::String).returns(T::Array[::Spoom::LSP::DocumentSymbol]) }
+  def symbols(query); end
+
+  sig { params(uri: ::String, line: ::Integer, column: ::Integer).returns(T::Array[::Spoom::LSP::Location]) }
+  def type_definitions(uri, line, column); end
+end
+
+class Spoom::LSP::Diagnostic < ::T::Struct
+  include ::Spoom::LSP::PrintableSymbol
+
+  const :range, ::Spoom::LSP::Range
+  const :code, ::Integer
+  const :message, ::String
+  const :information, ::Object
+
+  sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+  def accept_printer(printer); end
+
+  sig { returns(::String) }
+  def to_s; end
+
+  class << self
+    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Diagnostic) }
+    def from_json(json); end
+
+    def inherited(s); end
+  end
+end
+
+class Spoom::LSP::DocumentSymbol < ::T::Struct
+  include ::Spoom::LSP::PrintableSymbol
+
+  const :name, ::String
+  const :detail, T.nilable(::String)
+  const :kind, ::Integer
+  const :location, T.nilable(::Spoom::LSP::Location)
+  const :range, T.nilable(::Spoom::LSP::Range)
+  const :children, T::Array[::Spoom::LSP::DocumentSymbol]
+
+  sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+  def accept_printer(printer); end
+
+  sig { returns(::String) }
+  def kind_string; end
+
+  sig { returns(::String) }
+  def to_s; end
+
+  class << self
+    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::DocumentSymbol) }
+    def from_json(json); end
+
+    def inherited(s); end
+  end
+end
+
+Spoom::LSP::DocumentSymbol::SYMBOL_KINDS = T.let(T.unsafe(nil), Hash)
+class Spoom::LSP::Error < ::Spoom::Error; end
+class Spoom::LSP::Error::AlreadyOpen < ::Spoom::LSP::Error; end
+class Spoom::LSP::Error::BadHeaders < ::Spoom::LSP::Error; end
+
+class Spoom::LSP::Error::Diagnostics < ::Spoom::LSP::Error
+  sig { params(uri: ::String, diagnostics: T::Array[::Spoom::LSP::Diagnostic]).void }
+  def initialize(uri, diagnostics); end
+
+  sig { returns(T::Array[::Spoom::LSP::Diagnostic]) }
+  def diagnostics; end
+
+  sig { returns(::String) }
+  def uri; end
+
+  class << self
+    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Error::Diagnostics) }
+    def from_json(json); end
+  end
+end
+
+class Spoom::LSP::Hover < ::T::Struct
+  include ::Spoom::LSP::PrintableSymbol
+
+  const :contents, ::String
+  const :range, T.nilable(T::Range[T.untyped])
+
+  sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+  def accept_printer(printer); end
+
+  sig { returns(::String) }
+  def to_s; end
+
+  class << self
+    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Hover) }
+    def from_json(json); end
+
+    def inherited(s); end
+  end
+end
+
+class Spoom::LSP::Location < ::T::Struct
+  include ::Spoom::LSP::PrintableSymbol
+
+  const :uri, ::String
+  const :range, ::Spoom::LSP::Range
+
+  sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+  def accept_printer(printer); end
+
+  sig { returns(::String) }
+  def to_s; end
+
+  class << self
+    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Location) }
+    def from_json(json); end
+
+    def inherited(s); end
+  end
+end
+
+class Spoom::LSP::Message
+  sig { void }
+  def initialize; end
+
+  sig { returns(T::Hash[T.untyped, T.untyped]) }
+  def as_json; end
+
+  sig { params(args: T.untyped).returns(::String) }
+  def to_json(*args); end
+end
+
+class Spoom::LSP::Notification < ::Spoom::LSP::Message
+  sig { params(method: ::String, params: T::Hash[T.untyped, T.untyped]).void }
+  def initialize(method, params); end
+
+  sig { returns(::String) }
+  def method; end
+
+  sig { returns(T::Hash[T.untyped, T.untyped]) }
+  def params; end
+end
+
+class Spoom::LSP::Position < ::T::Struct
+  include ::Spoom::LSP::PrintableSymbol
+
+  const :line, ::Integer
+  const :char, ::Integer
+
+  sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+  def accept_printer(printer); end
+
+  sig { returns(::String) }
+  def to_s; end
+
+  class << self
+    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Position) }
+    def from_json(json); end
+
+    def inherited(s); end
+  end
+end
+
+module Spoom::LSP::PrintableSymbol
+  interface!
+
+  sig { abstract.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+  def accept_printer(printer); end
+end
+
+class Spoom::LSP::Range < ::T::Struct
+  include ::Spoom::LSP::PrintableSymbol
+
+  const :start, ::Spoom::LSP::Position
+  const :end, ::Spoom::LSP::Position
+
+  sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+  def accept_printer(printer); end
+
+  sig { returns(::String) }
+  def to_s; end
+
+  class << self
+    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::Range) }
+    def from_json(json); end
+
+    def inherited(s); end
+  end
+end
+
+class Spoom::LSP::Request < ::Spoom::LSP::Message
+  sig { params(id: ::Integer, method: ::String, params: T::Hash[T.untyped, T.untyped]).void }
+  def initialize(id, method, params); end
+
+  sig { returns(::Integer) }
+  def id; end
+
+  sig { returns(T::Hash[T.untyped, T.untyped]) }
+  def params; end
+end
+
+class Spoom::LSP::ResponseError < ::Spoom::LSP::Error
+  sig { params(code: ::Integer, message: ::String, data: T::Hash[T.untyped, T.untyped]).void }
+  def initialize(code, message, data); end
+
+  sig { returns(::Integer) }
+  def code; end
+
+  sig { returns(T::Hash[T.untyped, T.untyped]) }
+  def data; end
+
+  class << self
+    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::ResponseError) }
+    def from_json(json); end
+  end
+end
+
+class Spoom::LSP::SignatureHelp < ::T::Struct
+  include ::Spoom::LSP::PrintableSymbol
+
+  const :label, T.nilable(::String)
+  const :doc, ::Object
+  const :params, T::Array[T.untyped]
+
+  sig { override.params(printer: ::Spoom::LSP::SymbolPrinter).void }
+  def accept_printer(printer); end
+
+  sig { returns(::String) }
+  def to_s; end
+
+  class << self
+    sig { params(json: T::Hash[T.untyped, T.untyped]).returns(::Spoom::LSP::SignatureHelp) }
+    def from_json(json); end
+
+    def inherited(s); end
+  end
+end
+
+class Spoom::LSP::SymbolPrinter < ::Spoom::Printer
+  sig do
+    params(
+      out: T.any(::IO, ::StringIO),
+      colors: T::Boolean,
+      indent_level: ::Integer,
+      prefix: T.nilable(::String)
+    ).void
+  end
+  def initialize(out: T.unsafe(nil), colors: T.unsafe(nil), indent_level: T.unsafe(nil), prefix: T.unsafe(nil)); end
+
+  sig { params(uri: ::String).returns(::String) }
+  def clean_uri(uri); end
+
+  sig { returns(T.nilable(::String)) }
+  def prefix; end
+
+  def prefix=(_arg0); end
+
+  sig { params(objects: T::Array[::Spoom::LSP::PrintableSymbol]).void }
+  def print_list(objects); end
+
+  sig { params(object: T.nilable(::Spoom::LSP::PrintableSymbol)).void }
+  def print_object(object); end
+
+  sig { params(objects: T::Array[::Spoom::LSP::PrintableSymbol]).void }
+  def print_objects(objects); end
+
+  sig { returns(T::Set[::Integer]) }
+  def seen; end
+end
+
+class Spoom::Location
+  include ::Comparable
+
+  sig do
+    params(
+      file: ::String,
+      start_line: T.nilable(::Integer),
+      start_column: T.nilable(::Integer),
+      end_line: T.nilable(::Integer),
+      end_column: T.nilable(::Integer)
+    ).void
+  end
+  def initialize(file, start_line: T.unsafe(nil), start_column: T.unsafe(nil), end_line: T.unsafe(nil), end_column: T.unsafe(nil)); end
+
+  sig { override.params(other: ::BasicObject).returns(T.nilable(::Integer)) }
+  def <=>(other); end
+
+  def end_column; end
+  def end_line; end
+
+  sig { returns(::String) }
+  def file; end
+
+  sig { params(other: ::Spoom::Location).returns(T::Boolean) }
+  def include?(other); end
+
+  def start_column; end
+
+  sig { returns(T.nilable(::Integer)) }
+  def start_line; end
+
+  sig { returns(::String) }
+  def to_s; end
+
+  class << self
+    sig { params(file: ::String, location: ::Prism::Location).returns(::Spoom::Location) }
+    def from_prism(file, location); end
+
+    sig { params(location_string: ::String).returns(::Spoom::Location) }
+    def from_string(location_string); end
+  end
+end
+
+class Spoom::Location::LocationError < ::Spoom::Error; end
+
+class Spoom::Model
+  sig { void }
+  def initialize; end
+
+  sig { params(full_name: ::String).returns(::Spoom::Model::Symbol) }
+  def [](full_name); end
+
+  sig { void }
+  def finalize!; end
+
+  sig { params(full_name: ::String).returns(::Spoom::Model::Symbol) }
+  def register_symbol(full_name); end
+
+  sig { params(full_name: ::String, context: ::Spoom::Model::Symbol).returns(::Spoom::Model::Symbol) }
+  def resolve_symbol(full_name, context:); end
+
+  sig { params(symbol: ::Spoom::Model::Symbol).returns(T::Array[::Spoom::Model::Symbol]) }
+  def subtypes(symbol); end
+
+  sig { params(symbol: ::Spoom::Model::Symbol).returns(T::Array[::Spoom::Model::Symbol]) }
+  def supertypes(symbol); end
+
+  sig { returns(T::Hash[::String, ::Spoom::Model::Symbol]) }
+  def symbols; end
+
+  sig { returns(Spoom::Poset[::Spoom::Model::Symbol]) }
+  def symbols_hierarchy; end
+
+  private
+
+  sig { void }
+  def compute_symbols_hierarchy!; end
+end
+
+class Spoom::Model::Attr < ::Spoom::Model::Property
+  abstract!
+end
+
+class Spoom::Model::AttrAccessor < ::Spoom::Model::Attr; end
+class Spoom::Model::AttrReader < ::Spoom::Model::Attr; end
+class Spoom::Model::AttrWriter < ::Spoom::Model::Attr; end
+
+class Spoom::Model::Builder < ::Spoom::Model::NamespaceVisitor
+  sig { params(model: ::Spoom::Model, file: ::String).void }
+  def initialize(model, file); end
+
+  sig { override.params(node: ::Prism::CallNode).void }
+  def visit_call_node(node); end
+
+  sig { override.params(node: ::Prism::ClassNode).void }
+  def visit_class_node(node); end
+
+  sig { override.params(node: ::Prism::ConstantPathWriteNode).void }
+  def visit_constant_path_write_node(node); end
+
+  sig { override.params(node: ::Prism::ConstantWriteNode).void }
+  def visit_constant_write_node(node); end
+
+  sig { override.params(node: ::Prism::DefNode).void }
+  def visit_def_node(node); end
+
+  sig { override.params(node: ::Prism::ModuleNode).void }
+  def visit_module_node(node); end
+
+  sig { override.params(node: ::Prism::MultiWriteNode).void }
+  def visit_multi_write_node(node); end
+
+  sig { override.params(node: ::Prism::SingletonClassNode).void }
+  def visit_singleton_class_node(node); end
+
+  private
+
+  sig { returns(T::Array[::Spoom::Model::Sig]) }
+  def collect_sigs; end
+
+  sig { returns(::Spoom::Model::Visibility) }
+  def current_visibility; end
+
+  sig { params(node: ::Prism::Node).returns(T::Array[::Spoom::Model::Comment]) }
+  def node_comments(node); end
+
+  sig { params(node: ::Prism::Node).returns(::Spoom::Location) }
+  def node_location(node); end
+end
+
+class Spoom::Model::Class < ::Spoom::Model::Namespace
+  sig do
+    params(
+      symbol: ::Spoom::Model::Symbol,
+      owner: T.nilable(::Spoom::Model::Namespace),
+      location: ::Spoom::Location,
+      superclass_name: T.nilable(::String),
+      comments: T::Array[::Spoom::Model::Comment]
+    ).void
+  end
+  def initialize(symbol, owner:, location:, superclass_name: T.unsafe(nil), comments: T.unsafe(nil)); end
+
+  sig { returns(T.nilable(::String)) }
+  def superclass_name; end
+
+  def superclass_name=(_arg0); end
+end
+
+class Spoom::Model::Comment
+  sig { params(string: ::String, location: ::Spoom::Location).void }
+  def initialize(string, location); end
+
+  sig { returns(::Spoom::Location) }
+  def location; end
+
+  sig { returns(::String) }
+  def string; end
+end
+
+class Spoom::Model::Constant < ::Spoom::Model::SymbolDef
+  sig do
+    params(
+      symbol: ::Spoom::Model::Symbol,
+      owner: T.nilable(::Spoom::Model::Namespace),
+      location: ::Spoom::Location,
+      value: ::String,
+      comments: T::Array[::Spoom::Model::Comment]
+    ).void
+  end
+  def initialize(symbol, owner:, location:, value:, comments: T.unsafe(nil)); end
+
+  sig { returns(::String) }
+  def value; end
+end
+
+class Spoom::Model::Error < ::Spoom::Error; end
+class Spoom::Model::Extend < ::Spoom::Model::Mixin; end
+class Spoom::Model::Include < ::Spoom::Model::Mixin; end
+class Spoom::Model::Method < ::Spoom::Model::Property; end
+
+class Spoom::Model::Mixin
+  abstract!
+
+  sig { params(name: ::String).void }
+  def initialize(name); end
+
+  sig { returns(::String) }
+  def name; end
+end
+
+class Spoom::Model::Module < ::Spoom::Model::Namespace; end
+
+class Spoom::Model::Namespace < ::Spoom::Model::SymbolDef
+  abstract!
+
+  sig do
+    params(
+      symbol: ::Spoom::Model::Symbol,
+      owner: T.nilable(::Spoom::Model::Namespace),
+      location: ::Spoom::Location,
+      comments: T::Array[::Spoom::Model::Comment]
+    ).void
+  end
+  def initialize(symbol, owner:, location:, comments: T.unsafe(nil)); end
+
+  sig { returns(T::Array[::Spoom::Model::SymbolDef]) }
+  def children; end
+
+  sig { returns(T::Array[::Spoom::Model::Mixin]) }
+  def mixins; end
+end
+
+class Spoom::Model::NamespaceVisitor < ::Spoom::Visitor
+  abstract!
+
+  sig { void }
+  def initialize; end
+
+  sig { override.params(node: T.nilable(::Prism::Node)).void }
+  def visit(node); end
+end
+
+class Spoom::Model::Prepend < ::Spoom::Model::Mixin; end
+
+class Spoom::Model::Property < ::Spoom::Model::SymbolDef
+  abstract!
+
+  sig do
+    params(
+      symbol: ::Spoom::Model::Symbol,
+      owner: T.nilable(::Spoom::Model::Namespace),
+      location: ::Spoom::Location,
+      visibility: ::Spoom::Model::Visibility,
+      sigs: T::Array[::Spoom::Model::Sig],
+      comments: T::Array[::Spoom::Model::Comment]
+    ).void
+  end
+  def initialize(symbol, owner:, location:, visibility:, sigs: T.unsafe(nil), comments: T.unsafe(nil)); end
+
+  sig { returns(T::Array[::Spoom::Model::Sig]) }
+  def sigs; end
+
+  sig { returns(::Spoom::Model::Visibility) }
+  def visibility; end
+end
+
+class Spoom::Model::Reference < ::T::Struct
+  const :kind, ::Spoom::Model::Reference::Kind
+  const :name, ::String
+  const :location, ::Spoom::Location
+
+  sig { returns(T::Boolean) }
+  def constant?; end
+
+  sig { returns(T::Boolean) }
+  def method?; end
+
+  class << self
+    sig { params(name: ::String, location: ::Spoom::Location).returns(::Spoom::Model::Reference) }
+    def constant(name, location); end
+
+    def inherited(s); end
+
+    sig { params(name: ::String, location: ::Spoom::Location).returns(::Spoom::Model::Reference) }
+    def method(name, location); end
+  end
+end
+
+class Spoom::Model::Reference::Kind < ::T::Enum
+  enums do
+    Constant = new
+    Method = new
+  end
+end
+
+class Spoom::Model::ReferencesVisitor < ::Spoom::Visitor
+  sig { params(file: ::String).void }
+  def initialize(file); end
+
+  sig { returns(T::Array[::Spoom::Model::Reference]) }
+  def references; end
+
+  sig { override.params(node: ::Prism::AliasMethodNode).void }
+  def visit_alias_method_node(node); end
+
+  sig { override.params(node: ::Prism::AndNode).void }
+  def visit_and_node(node); end
+
+  sig { override.params(node: ::Prism::BlockArgumentNode).void }
+  def visit_block_argument_node(node); end
+
+  sig { override.params(node: ::Prism::CallAndWriteNode).void }
+  def visit_call_and_write_node(node); end
+
+  sig { override.params(node: ::Prism::CallNode).void }
+  def visit_call_node(node); end
+
+  sig { override.params(node: ::Prism::CallOperatorWriteNode).void }
+  def visit_call_operator_write_node(node); end
+
+  sig { override.params(node: ::Prism::CallOrWriteNode).void }
+  def visit_call_or_write_node(node); end
+
+  sig { override.params(node: ::Prism::ClassNode).void }
+  def visit_class_node(node); end
+
+  sig { override.params(node: ::Prism::ConstantAndWriteNode).void }
+  def visit_constant_and_write_node(node); end
+
+  sig { override.params(node: ::Prism::ConstantOperatorWriteNode).void }
+  def visit_constant_operator_write_node(node); end
+
+  sig { override.params(node: ::Prism::ConstantOrWriteNode).void }
+  def visit_constant_or_write_node(node); end
+
+  sig { override.params(node: ::Prism::ConstantPathNode).void }
+  def visit_constant_path_node(node); end
+
+  sig { override.params(node: ::Prism::ConstantPathWriteNode).void }
+  def visit_constant_path_write_node(node); end
+
+  sig { override.params(node: ::Prism::ConstantReadNode).void }
+  def visit_constant_read_node(node); end
+
+  sig { override.params(node: ::Prism::ConstantWriteNode).void }
+  def visit_constant_write_node(node); end
+
+  sig { override.params(node: ::Prism::LocalVariableAndWriteNode).void }
+  def visit_local_variable_and_write_node(node); end
+
+  sig { override.params(node: ::Prism::LocalVariableOperatorWriteNode).void }
+  def visit_local_variable_operator_write_node(node); end
+
+  sig { override.params(node: ::Prism::LocalVariableOrWriteNode).void }
+  def visit_local_variable_or_write_node(node); end
+
+  sig { override.params(node: ::Prism::LocalVariableWriteNode).void }
+  def visit_local_variable_write_node(node); end
+
+  sig { override.params(node: ::Prism::ModuleNode).void }
+  def visit_module_node(node); end
+
+  sig { override.params(node: ::Prism::MultiWriteNode).void }
+  def visit_multi_write_node(node); end
+
+  sig { override.params(node: ::Prism::OrNode).void }
+  def visit_or_node(node); end
+
+  private
+
+  sig { params(node: ::Prism::Node).returns(::Spoom::Location) }
+  def node_location(node); end
+
+  sig { params(name: ::String, node: ::Prism::Node).void }
+  def reference_constant(name, node); end
+
+  sig { params(name: ::String, node: ::Prism::Node).void }
+  def reference_method(name, node); end
+end
+
+class Spoom::Model::Sig
+  sig { params(string: ::String).void }
+  def initialize(string); end
+
+  sig { returns(::String) }
+  def string; end
+end
+
+class Spoom::Model::SingletonClass < ::Spoom::Model::Namespace; end
+
+class Spoom::Model::Symbol
+  sig { params(full_name: ::String).void }
+  def initialize(full_name); end
+
+  sig { returns(T::Array[::Spoom::Model::SymbolDef]) }
+  def definitions; end
+
+  sig { returns(::String) }
+  def full_name; end
+
+  sig { returns(::String) }
+  def name; end
+
+  sig { returns(::String) }
+  def to_s; end
+end
+
+class Spoom::Model::SymbolDef
+  abstract!
+
+  sig do
+    params(
+      symbol: ::Spoom::Model::Symbol,
+      owner: T.nilable(::Spoom::Model::Namespace),
+      location: ::Spoom::Location,
+      comments: T::Array[::Spoom::Model::Comment]
+    ).void
+  end
+  def initialize(symbol, owner:, location:, comments:); end
+
+  sig { returns(T::Array[::Spoom::Model::Comment]) }
+  def comments; end
+
+  sig { returns(::String) }
+  def full_name; end
+
+  sig { returns(::Spoom::Location) }
+  def location; end
+
+  sig { returns(::String) }
+  def name; end
+
+  sig { returns(T.nilable(::Spoom::Model::Namespace)) }
+  def owner; end
+
+  sig { returns(::Spoom::Model::Symbol) }
+  def symbol; end
+end
+
+class Spoom::Model::UnresolvedSymbol < ::Spoom::Model::Symbol
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+class Spoom::Model::Visibility < ::T::Enum
+  enums do
+    Private = new
+    Protected = new
+    Public = new
+  end
+end
+
+class Spoom::ParseError < ::Spoom::Error; end
+
+class Spoom::Poset
+  sig { void }
+  def initialize; end
+
+  sig { params(value: T.untyped).returns(Spoom::Poset::Element[T.untyped]) }
+  def [](value); end
+
+  sig { params(from: T.untyped, to: T.untyped).void }
+  def add_direct_edge(from, to); end
+
+  sig { params(value: T.untyped).returns(Spoom::Poset::Element[T.untyped]) }
+  def add_element(value); end
+
+  sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+  def direct_edge?(from, to); end
+
+  sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
+  def edge?(from, to); end
+
+  sig { params(value: T.untyped).returns(T::Boolean) }
+  def element?(value); end
+
+  sig { params(direct: T::Boolean, transitive: T::Boolean).void }
+  def show_dot(direct: T.unsafe(nil), transitive: T.unsafe(nil)); end
+
+  sig { params(direct: T::Boolean, transitive: T::Boolean).returns(::String) }
+  def to_dot(direct: T.unsafe(nil), transitive: T.unsafe(nil)); end
+end
+
+class Spoom::Poset::Element
+  include ::Comparable
+
+  sig { params(value: T.untyped).void }
+  def initialize(value); end
+
+  sig { params(other: T.untyped).returns(T.nilable(::Integer)) }
+  def <=>(other); end
+
+  sig { returns(T::Array[T.untyped]) }
+  def ancestors; end
+
+  sig { returns(T::Array[T.untyped]) }
+  def children; end
+
+  sig { returns(T::Array[T.untyped]) }
+  def descendants; end
+
+  def dfroms; end
+
+  sig { returns(T::Set[Spoom::Poset::Element[T.untyped]]) }
+  def dtos; end
+
+  def froms; end
+
+  sig { returns(T::Array[T.untyped]) }
+  def parents; end
+
+  def tos; end
+
+  sig { returns(T.untyped) }
+  def value; end
+end
+
+class Spoom::Poset::Error < ::Spoom::Error; end
+
+class Spoom::Printer
+  include ::Spoom::Colorize
+
+  sig { params(out: T.any(::IO, ::StringIO), colors: T::Boolean, indent_level: ::Integer).void }
+  def initialize(out: T.unsafe(nil), colors: T.unsafe(nil), indent_level: T.unsafe(nil)); end
+
+  sig { params(string: ::String, color: ::Spoom::Color).returns(::String) }
+  def colorize(string, *color); end
+
+  sig { void }
+  def dedent; end
+
+  sig { void }
+  def indent; end
+
+  sig { returns(T.any(::IO, ::StringIO)) }
+  def out; end
+
+  def out=(_arg0); end
+
+  sig { params(string: T.nilable(::String)).void }
+  def print(string); end
+
+  sig { params(string: T.nilable(::String), color: ::Spoom::Color).void }
+  def print_colored(string, *color); end
+
+  sig { params(string: T.nilable(::String)).void }
+  def printl(string); end
+
+  sig { void }
+  def printn; end
+
+  sig { void }
+  def printt; end
+end
+
+module Spoom::RBS; end
+class Spoom::RBS::Annotations < ::Spoom::RBS::Comment; end
+
+class Spoom::RBS::Comment
+  sig { params(string: ::String, location: ::Prism::Location).void }
+  def initialize(string, location); end
+
+  sig { returns(::Prism::Location) }
+  def location; end
+
+  sig { returns(::String) }
+  def string; end
+end
+
+class Spoom::RBS::Comments
+  sig { void }
+  def initialize; end
+
+  sig { returns(T::Array[::Spoom::RBS::Annotations]) }
+  def annotations; end
+
+  sig { returns(T::Boolean) }
+  def empty?; end
+
+  sig { returns(T::Array[::Spoom::RBS::Signature]) }
+  def signatures; end
+end
+
+module Spoom::RBS::ExtractRBSComments
+  sig { params(node: ::Prism::Node).returns(::Spoom::RBS::Comments) }
+  def node_rbs_comments(node); end
+end
+
+class Spoom::RBS::Signature < ::Spoom::RBS::Comment; end
+Spoom::SPOOM_PATH = T.let(T.unsafe(nil), String)
+module Spoom::Sorbet; end
+Spoom::Sorbet::BIN_PATH = T.let(T.unsafe(nil), String)
+Spoom::Sorbet::CONFIG_PATH = T.let(T.unsafe(nil), String)
+
+class Spoom::Sorbet::Config
+  sig { void }
+  def initialize; end
+
+  def allowed_extensions; end
+  def allowed_extensions=(_arg0); end
+
+  sig { returns(::Spoom::Sorbet::Config) }
+  def copy; end
+
+  def ignore; end
+  def ignore=(_arg0); end
+
+  sig { returns(T::Boolean) }
+  def no_stdlib; end
+
+  def no_stdlib=(_arg0); end
+
+  sig { returns(::String) }
+  def options_string; end
+
+  sig { returns(T::Array[::String]) }
+  def paths; end
+
+  def paths=(_arg0); end
+
+  class << self
+    sig { params(sorbet_config_path: ::String).returns(::Spoom::Sorbet::Config) }
+    def parse_file(sorbet_config_path); end
+
+    sig { params(sorbet_config: ::String).returns(::Spoom::Sorbet::Config) }
+    def parse_string(sorbet_config); end
+
+    private
+
+    sig { params(line: ::String).returns(::String) }
+    def parse_option(line); end
+  end
+end
+
+Spoom::Sorbet::Config::DEFAULT_ALLOWED_EXTENSIONS = T.let(T.unsafe(nil), Array)
+
+class Spoom::Sorbet::Error < ::Spoom::Error
+  sig { params(message: ::String, result: ::Spoom::ExecResult).void }
+  def initialize(message, result); end
+
+  sig { returns(::Spoom::ExecResult) }
+  def result; end
+end
+
+class Spoom::Sorbet::Error::Killed < ::Spoom::Sorbet::Error; end
+class Spoom::Sorbet::Error::Segfault < ::Spoom::Sorbet::Error; end
+
+module Spoom::Sorbet::Errors
+  class << self
+    sig { params(errors: T::Array[::Spoom::Sorbet::Errors::Error]).returns(T::Array[::Spoom::Sorbet::Errors::Error]) }
+    def sort_errors_by_code(errors); end
+
+    sig { params(errors: T::Array[::Spoom::Sorbet::Errors::Error]).returns(::REXML::Document) }
+    def to_junit_xml(errors); end
+  end
+end
+
+Spoom::Sorbet::Errors::DEFAULT_ERROR_URL_BASE = T.let(T.unsafe(nil), String)
+
+class Spoom::Sorbet::Errors::Error
+  include ::Comparable
+
+  sig do
+    params(
+      file: T.nilable(::String),
+      line: T.nilable(::Integer),
+      message: T.nilable(::String),
+      code: T.nilable(::Integer),
+      more: T::Array[::String]
+    ).void
+  end
+  def initialize(file, line, message, code, more = T.unsafe(nil)); end
+
+  sig { params(other: T.untyped).returns(::Integer) }
+  def <=>(other); end
+
+  def code; end
+
+  sig { returns(T.nilable(::String)) }
+  def file; end
+
+  sig { returns(T::Set[::String]) }
+  def files_from_error_sections; end
+
+  sig { returns(T.nilable(::Integer)) }
+  def line; end
+
+  def message; end
+
+  sig { returns(T::Array[::String]) }
+  def more; end
+
+  sig { returns(::REXML::Element) }
+  def to_junit_xml_element; end
+
+  sig { returns(::String) }
+  def to_s; end
+end
+
+class Spoom::Sorbet::Errors::Parser
+  sig { params(error_url_base: ::String).void }
+  def initialize(error_url_base: T.unsafe(nil)); end
+
+  sig { params(output: ::String).returns(T::Array[::Spoom::Sorbet::Errors::Error]) }
+  def parse(output); end
+
+  private
+
+  sig { params(line: ::String).void }
+  def append_error(line); end
+
+  sig { void }
+  def close_error; end
+
+  sig { params(error_url_base: ::String).returns(::Regexp) }
+  def error_line_match_regexp(error_url_base); end
+
+  sig { params(line: ::String).returns(T.nilable(::Spoom::Sorbet::Errors::Error)) }
+  def match_error_line(line); end
+
+  sig { params(error: ::Spoom::Sorbet::Errors::Error).void }
+  def open_error(error); end
+
+  class << self
+    sig { params(output: ::String, error_url_base: ::String).returns(T::Array[::Spoom::Sorbet::Errors::Error]) }
+    def parse_string(output, error_url_base: T.unsafe(nil)); end
+  end
+end
+
+Spoom::Sorbet::Errors::Parser::HEADER = T.let(T.unsafe(nil), Array)
+class Spoom::Sorbet::Errors::Parser::ParseError < ::Spoom::Error; end
+Spoom::Sorbet::GEM_PATH = T.let(T.unsafe(nil), String)
+Spoom::Sorbet::GEM_VERSION = T.let(T.unsafe(nil), String)
+Spoom::Sorbet::KILLED_CODE = T.let(T.unsafe(nil), Integer)
+
+module Spoom::Sorbet::Metrics
+  class << self
+    sig { params(files: T::Array[::String]).returns(Spoom::Counters) }
+    def collect_code_metrics(files); end
+  end
+end
+
+class Spoom::Sorbet::Metrics::CodeMetricsVisitor < ::Spoom::Visitor
+  include ::Spoom::RBS::ExtractRBSComments
+
+  sig { params(counters: Spoom::Counters).void }
+  def initialize(counters); end
+
+  sig { returns(Spoom::Counters) }
+  def counters; end
+
+  sig { override.params(node: T.nilable(::Prism::Node)).void }
+  def visit(node); end
+
+  sig { override.params(node: ::Prism::CallNode).void }
+  def visit_call_node(node); end
+
+  sig { override.params(node: ::Prism::ClassNode).void }
+  def visit_class_node(node); end
+
+  sig { override.params(node: ::Prism::DefNode).void }
+  def visit_def_node(node); end
+
+  sig { override.params(node: ::Prism::ModuleNode).void }
+  def visit_module_node(node); end
+
+  sig { override.params(node: ::Prism::SingletonClassNode).void }
+  def visit_singleton_class_node(node); end
+
+  private
+
+  sig { returns(T::Array[::Prism::CallNode]) }
+  def collect_last_srb_sigs; end
+
+  sig { params(node: T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode)).returns(::String) }
+  def node_key(node); end
+
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_attr_accessor(node); end
+
+  sig do
+    params(
+      node: T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode),
+      block: T.proc.void
+    ).void
+  end
+  def visit_scope(node, &block); end
+
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_sig(node); end
+
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_type_member(node); end
+end
+
+module Spoom::Sorbet::Metrics::MetricsFileParser
+  class << self
+    sig { params(path: ::String, prefix: ::String).returns(T::Hash[::String, ::Integer]) }
+    def parse_file(path, prefix = T.unsafe(nil)); end
+
+    sig { params(obj: T::Hash[::String, T.untyped], prefix: ::String).returns(Spoom::Counters) }
+    def parse_hash(obj, prefix = T.unsafe(nil)); end
+
+    sig { params(string: ::String, prefix: ::String).returns(T::Hash[::String, ::Integer]) }
+    def parse_string(string, prefix = T.unsafe(nil)); end
+  end
+end
+
+Spoom::Sorbet::Metrics::MetricsFileParser::DEFAULT_PREFIX = T.let(T.unsafe(nil), String)
+Spoom::Sorbet::SEGFAULT_CODE = T.let(T.unsafe(nil), Integer)
+
+module Spoom::Sorbet::Sigils
+  class << self
+    sig { params(path: T.any(::Pathname, ::String), new_strictness: ::String).returns(T::Boolean) }
+    def change_sigil_in_file(path, new_strictness); end
+
+    sig { params(path_list: T::Array[::String], new_strictness: ::String).returns(T::Array[::String]) }
+    def change_sigil_in_files(path_list, new_strictness); end
+
+    sig { params(path: T.any(::Pathname, ::String)).returns(T.nilable(::String)) }
+    def file_strictness(path); end
+
+    sig { params(strictness: ::String).returns(::String) }
+    def sigil_string(strictness); end
+
+    sig { params(content: ::String).returns(T.nilable(::String)) }
+    def strictness_in_content(content); end
+
+    sig { params(content: ::String, new_strictness: ::String).returns(::String) }
+    def update_sigil(content, new_strictness); end
+
+    sig { params(strictness: ::String).returns(T::Boolean) }
+    def valid_strictness?(strictness); end
+  end
+end
+
+Spoom::Sorbet::Sigils::SIGIL_REGEXP = T.let(T.unsafe(nil), Regexp)
+Spoom::Sorbet::Sigils::STRICTNESS_FALSE = T.let(T.unsafe(nil), String)
+Spoom::Sorbet::Sigils::STRICTNESS_IGNORE = T.let(T.unsafe(nil), String)
+Spoom::Sorbet::Sigils::STRICTNESS_INTERNAL = T.let(T.unsafe(nil), String)
+Spoom::Sorbet::Sigils::STRICTNESS_STRICT = T.let(T.unsafe(nil), String)
+Spoom::Sorbet::Sigils::STRICTNESS_STRONG = T.let(T.unsafe(nil), String)
+Spoom::Sorbet::Sigils::STRICTNESS_TRUE = T.let(T.unsafe(nil), String)
+Spoom::Sorbet::Sigils::VALID_STRICTNESS = T.let(T.unsafe(nil), Array)
+
+module Spoom::Sorbet::Translate
+  class << self
+    sig { params(ruby_contents: ::String, file: ::String).returns(::String) }
+    def rbs_comments_to_sorbet_sigs(ruby_contents, file:); end
+
+    sig { params(ruby_contents: ::String, file: ::String).returns(::String) }
+    def sorbet_assertions_to_rbs_comments(ruby_contents, file:); end
+
+    sig { params(ruby_contents: ::String, file: ::String, positional_names: T::Boolean).returns(::String) }
+    def sorbet_sigs_to_rbs_comments(ruby_contents, file:, positional_names: T.unsafe(nil)); end
+
+    sig { params(ruby_contents: ::String, file: ::String).returns(::String) }
+    def strip_sorbet_sigs(ruby_contents, file:); end
+  end
+end
+
+class Spoom::Sorbet::Translate::Error < ::Spoom::Error; end
+
+class Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs < ::Spoom::Sorbet::Translate::Translator
+  include ::Spoom::RBS::ExtractRBSComments
+
+  sig { override.params(node: ::Prism::CallNode).void }
+  def visit_call_node(node); end
+
+  sig { override.params(node: ::Prism::ClassNode).void }
+  def visit_class_node(node); end
+
+  sig { override.params(node: ::Prism::DefNode).void }
+  def visit_def_node(node); end
+
+  sig { override.params(node: ::Prism::ModuleNode).void }
+  def visit_module_node(node); end
+
+  sig { override.params(node: ::Prism::SingletonClassNode).void }
+  def visit_singleton_class_node(node); end
+
+  private
+
+  sig do
+    params(
+      node: T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode),
+      constant_regex: ::Regexp
+    ).returns(T::Boolean)
+  end
+  def already_extends?(node, constant_regex); end
+
+  sig { params(node: T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode)).void }
+  def apply_class_annotations(node); end
+
+  sig { params(annotations: T::Array[::Spoom::RBS::Annotations], sig: ::RBI::Sig).void }
+  def apply_member_annotations(annotations, sig); end
+
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_attr(node); end
+end
+
+class Spoom::Sorbet::Translate::SorbetAssertionsToRBSComments < ::Spoom::Sorbet::Translate::Translator
+  sig { override.params(node: ::Prism::CallNode).void }
+  def visit_call_node(node); end
+
+  private
+
+  sig { params(node: ::Prism::Node).returns(T::Boolean) }
+  def at_end_of_line?(node); end
+
+  sig { params(call: ::Prism::CallNode).void }
+  def build_rbs_annotation(call); end
+
+  sig { params(assign: ::Prism::Node, value: ::Prism::Node).returns(::String) }
+  def dedent_value(assign, value); end
+
+  sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
+  def t?(node); end
+
+  sig { params(node: ::Prism::CallNode).returns(T::Boolean) }
+  def t_annotation?(node); end
+end
+
+Spoom::Sorbet::Translate::SorbetAssertionsToRBSComments::LINE_BREAK = T.let(T.unsafe(nil), Integer)
+
+class Spoom::Sorbet::Translate::SorbetSigsToRBSComments < ::Spoom::Sorbet::Translate::Translator
+  sig { params(ruby_contents: ::String, file: ::String, positional_names: T::Boolean).void }
+  def initialize(ruby_contents, file:, positional_names:); end
+
+  sig { override.params(node: ::Prism::CallNode).void }
+  def visit_call_node(node); end
+
+  sig { override.params(node: ::Prism::ClassNode).void }
+  def visit_class_node(node); end
+
+  sig { override.params(node: ::Prism::ConstantWriteNode).void }
+  def visit_constant_write_node(node); end
+
+  sig { override.params(node: ::Prism::DefNode).void }
+  def visit_def_node(node); end
+
+  sig { override.params(node: ::Prism::ModuleNode).void }
+  def visit_module_node(node); end
+
+  sig { override.params(node: ::Prism::SingletonClassNode).void }
+  def visit_singleton_class_node(node); end
+
+  private
+
+  sig { params(sigs: T::Array[[::Prism::CallNode, ::RBI::Sig]]).void }
+  def apply_member_annotations(sigs); end
+
+  sig { params(node: ::Prism::ConstantWriteNode).returns(::String) }
+  def build_type_member_string(node); end
+
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_attr(node); end
+
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_class_annotation(node); end
+
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_extend(node); end
+
+  sig do
+    params(
+      node: T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode),
+      block: T.proc.void
+    ).void
+  end
+  def visit_scope(node, &block); end
+
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_sig(node); end
+end
+
+class Spoom::Sorbet::Translate::StripSorbetSigs < ::Spoom::Sorbet::Translate::Translator
+  sig { override.params(node: ::Prism::CallNode).void }
+  def visit_call_node(node); end
+end
+
+class Spoom::Sorbet::Translate::Translator < ::Spoom::Visitor
+  abstract!
+
+  sig { params(ruby_contents: ::String, file: ::String).void }
+  def initialize(ruby_contents, file:); end
+
+  sig { returns(::String) }
+  def rewrite; end
+
+  private
+
+  sig { params(offset: ::Integer).returns(::Integer) }
+  def adjust_to_line_end(offset); end
+
+  sig { params(offset: ::Integer).returns(::Integer) }
+  def adjust_to_line_start(offset); end
+
+  sig { params(offset: ::Integer).returns(::Integer) }
+  def adjust_to_new_line(offset); end
+
+  sig { params(node: ::Prism::CallNode).returns(T::Boolean) }
+  def sorbet_sig?(node); end
+end
+
+module Spoom::Source; end
+
+class Spoom::Source::Delete < ::Spoom::Source::Edit
+  sig { params(from: ::Integer, to: ::Integer).void }
+  def initialize(from, to); end
+
+  sig { override.params(bytes: T::Array[T.untyped]).void }
+  def apply(bytes); end
+
+  sig { returns(::Integer) }
+  def from; end
+
+  sig { override.returns([::Integer, ::Integer]) }
+  def range; end
+
+  def to; end
+
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+class Spoom::Source::Edit
+  abstract!
+
+  sig { abstract.params(bytes: T::Array[::Integer]).void }
+  def apply(bytes); end
+
+  sig { abstract.returns([::Integer, ::Integer]) }
+  def range; end
+end
+
+class Spoom::Source::Insert < ::Spoom::Source::Edit
+  sig { params(position: ::Integer, text: ::String).void }
+  def initialize(position, text); end
+
+  sig { override.params(bytes: T::Array[::Integer]).void }
+  def apply(bytes); end
+
+  sig { returns(::Integer) }
+  def position; end
+
+  sig { override.returns([::Integer, ::Integer]) }
+  def range; end
+
+  sig { returns(::String) }
+  def text; end
+
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+class Spoom::Source::PositionError < ::Spoom::Error; end
+
+class Spoom::Source::Replace < ::Spoom::Source::Edit
+  sig { params(from: ::Integer, to: ::Integer, text: ::String).void }
+  def initialize(from, to, text); end
+
+  sig { override.params(bytes: T::Array[::Integer]).void }
+  def apply(bytes); end
+
+  sig { returns(::Integer) }
+  def from; end
+
+  sig { override.returns([::Integer, ::Integer]) }
+  def range; end
+
+  sig { returns(::String) }
+  def text; end
+
+  def to; end
+
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+class Spoom::Source::Rewriter
+  sig { void }
+  def initialize; end
+
+  sig { params(other: ::Spoom::Source::Edit).void }
+  def <<(other); end
+
+  sig { params(bytes: T::Array[::Integer]).void }
+  def rewrite!(bytes); end
+end
+
+class Spoom::Timeline
+  sig { params(context: ::Spoom::Context, from: ::Time, to: ::Time).void }
+  def initialize(context, from, to); end
+
+  sig { params(dates: T::Array[::Time]).returns(T::Array[::Spoom::Git::Commit]) }
+  def commits_for_dates(dates); end
+
+  sig { returns(T::Array[::Time]) }
+  def months; end
+
+  sig { returns(T::Array[::Spoom::Git::Commit]) }
+  def ticks; end
+end
+
+Spoom::VERSION = T.let(T.unsafe(nil), String)
+
+class Spoom::Visitor < ::Prism::Visitor
+  sig { override.params(node: ::Prism::AliasGlobalVariableNode).void }
+  def visit_alias_global_variable_node(node); end
+
+  sig { override.params(node: ::Prism::AliasMethodNode).void }
+  def visit_alias_method_node(node); end
+
+  sig { override.params(node: ::Prism::AlternationPatternNode).void }
+  def visit_alternation_pattern_node(node); end
+
+  sig { override.params(node: ::Prism::AndNode).void }
+  def visit_and_node(node); end
+
+  sig { override.params(node: ::Prism::ArgumentsNode).void }
+  def visit_arguments_node(node); end
+
+  sig { override.params(node: ::Prism::ArrayNode).void }
+  def visit_array_node(node); end
+
+  sig { override.params(node: ::Prism::ArrayPatternNode).void }
+  def visit_array_pattern_node(node); end
+
+  sig { override.params(node: ::Prism::AssocNode).void }
+  def visit_assoc_node(node); end
+
+  sig { override.params(node: ::Prism::AssocSplatNode).void }
+  def visit_assoc_splat_node(node); end
+
+  sig { override.params(node: ::Prism::BackReferenceReadNode).void }
+  def visit_back_reference_read_node(node); end
+
+  sig { override.params(node: ::Prism::BeginNode).void }
+  def visit_begin_node(node); end
+
+  sig { override.params(node: ::Prism::BlockArgumentNode).void }
+  def visit_block_argument_node(node); end
+
+  sig { override.params(node: ::Prism::BlockLocalVariableNode).void }
+  def visit_block_local_variable_node(node); end
+
+  sig { override.params(node: ::Prism::BlockNode).void }
+  def visit_block_node(node); end
+
+  sig { override.params(node: ::Prism::BlockParameterNode).void }
+  def visit_block_parameter_node(node); end
+
+  sig { override.params(node: ::Prism::BlockParametersNode).void }
+  def visit_block_parameters_node(node); end
+
+  sig { override.params(node: ::Prism::BreakNode).void }
+  def visit_break_node(node); end
+
+  sig { override.params(node: ::Prism::CallAndWriteNode).void }
+  def visit_call_and_write_node(node); end
+
+  sig { override.params(node: ::Prism::CallNode).void }
+  def visit_call_node(node); end
+
+  sig { override.params(node: ::Prism::CallOperatorWriteNode).void }
+  def visit_call_operator_write_node(node); end
+
+  sig { override.params(node: ::Prism::CallOrWriteNode).void }
+  def visit_call_or_write_node(node); end
+
+  sig { override.params(node: ::Prism::CallTargetNode).void }
+  def visit_call_target_node(node); end
+
+  sig { override.params(node: ::Prism::CapturePatternNode).void }
+  def visit_capture_pattern_node(node); end
+
+  sig { override.params(node: ::Prism::CaseMatchNode).void }
+  def visit_case_match_node(node); end
+
+  sig { override.params(node: ::Prism::CaseNode).void }
+  def visit_case_node(node); end
+
+  sig { override.params(node: ::Prism::Node).void }
+  def visit_child_nodes(node); end
+
+  sig { override.params(node: ::Prism::ClassNode).void }
+  def visit_class_node(node); end
+
+  sig { override.params(node: ::Prism::ClassVariableAndWriteNode).void }
+  def visit_class_variable_and_write_node(node); end
+
+  sig { override.params(node: ::Prism::ClassVariableOperatorWriteNode).void }
+  def visit_class_variable_operator_write_node(node); end
+
+  sig { override.params(node: ::Prism::ClassVariableOrWriteNode).void }
+  def visit_class_variable_or_write_node(node); end
+
+  sig { override.params(node: ::Prism::ClassVariableReadNode).void }
+  def visit_class_variable_read_node(node); end
+
+  sig { override.params(node: ::Prism::ClassVariableTargetNode).void }
+  def visit_class_variable_target_node(node); end
+
+  sig { override.params(node: ::Prism::ClassVariableWriteNode).void }
+  def visit_class_variable_write_node(node); end
+
+  sig { override.params(node: ::Prism::ConstantAndWriteNode).void }
+  def visit_constant_and_write_node(node); end
+
+  sig { override.params(node: ::Prism::ConstantOperatorWriteNode).void }
+  def visit_constant_operator_write_node(node); end
+
+  sig { override.params(node: ::Prism::ConstantOrWriteNode).void }
+  def visit_constant_or_write_node(node); end
+
+  sig { override.params(node: ::Prism::ConstantPathAndWriteNode).void }
+  def visit_constant_path_and_write_node(node); end
+
+  sig { override.params(node: ::Prism::ConstantPathNode).void }
+  def visit_constant_path_node(node); end
+
+  sig { override.params(node: ::Prism::ConstantPathOperatorWriteNode).void }
+  def visit_constant_path_operator_write_node(node); end
+
+  sig { override.params(node: ::Prism::ConstantPathOrWriteNode).void }
+  def visit_constant_path_or_write_node(node); end
+
+  sig { override.params(node: ::Prism::ConstantPathTargetNode).void }
+  def visit_constant_path_target_node(node); end
+
+  sig { override.params(node: ::Prism::ConstantPathWriteNode).void }
+  def visit_constant_path_write_node(node); end
+
+  sig { override.params(node: ::Prism::ConstantReadNode).void }
+  def visit_constant_read_node(node); end
+
+  sig { override.params(node: ::Prism::ConstantTargetNode).void }
+  def visit_constant_target_node(node); end
+
+  sig { override.params(node: ::Prism::ConstantWriteNode).void }
+  def visit_constant_write_node(node); end
+
+  sig { override.params(node: ::Prism::DefNode).void }
+  def visit_def_node(node); end
+
+  sig { override.params(node: ::Prism::DefinedNode).void }
+  def visit_defined_node(node); end
+
+  sig { override.params(node: ::Prism::ElseNode).void }
+  def visit_else_node(node); end
+
+  sig { override.params(node: ::Prism::EmbeddedStatementsNode).void }
+  def visit_embedded_statements_node(node); end
+
+  sig { override.params(node: ::Prism::EmbeddedVariableNode).void }
+  def visit_embedded_variable_node(node); end
+
+  sig { override.params(node: ::Prism::EnsureNode).void }
+  def visit_ensure_node(node); end
+
+  sig { override.params(node: ::Prism::FalseNode).void }
+  def visit_false_node(node); end
+
+  sig { override.params(node: ::Prism::FindPatternNode).void }
+  def visit_find_pattern_node(node); end
+
+  sig { override.params(node: ::Prism::FlipFlopNode).void }
+  def visit_flip_flop_node(node); end
+
+  sig { override.params(node: ::Prism::FloatNode).void }
+  def visit_float_node(node); end
+
+  sig { override.params(node: ::Prism::ForNode).void }
+  def visit_for_node(node); end
+
+  sig { override.params(node: ::Prism::ForwardingArgumentsNode).void }
+  def visit_forwarding_arguments_node(node); end
+
+  sig { override.params(node: ::Prism::ForwardingParameterNode).void }
+  def visit_forwarding_parameter_node(node); end
+
+  sig { override.params(node: ::Prism::ForwardingSuperNode).void }
+  def visit_forwarding_super_node(node); end
+
+  sig { override.params(node: ::Prism::GlobalVariableAndWriteNode).void }
+  def visit_global_variable_and_write_node(node); end
+
+  sig { override.params(node: ::Prism::GlobalVariableOperatorWriteNode).void }
+  def visit_global_variable_operator_write_node(node); end
+
+  sig { override.params(node: ::Prism::GlobalVariableOrWriteNode).void }
+  def visit_global_variable_or_write_node(node); end
+
+  sig { override.params(node: ::Prism::GlobalVariableReadNode).void }
+  def visit_global_variable_read_node(node); end
+
+  sig { override.params(node: ::Prism::GlobalVariableTargetNode).void }
+  def visit_global_variable_target_node(node); end
+
+  sig { override.params(node: ::Prism::GlobalVariableWriteNode).void }
+  def visit_global_variable_write_node(node); end
+
+  sig { override.params(node: ::Prism::HashNode).void }
+  def visit_hash_node(node); end
+
+  sig { override.params(node: ::Prism::HashPatternNode).void }
+  def visit_hash_pattern_node(node); end
+
+  sig { override.params(node: ::Prism::IfNode).void }
+  def visit_if_node(node); end
+
+  sig { override.params(node: ::Prism::ImaginaryNode).void }
+  def visit_imaginary_node(node); end
+
+  sig { override.params(node: ::Prism::ImplicitNode).void }
+  def visit_implicit_node(node); end
+
+  sig { override.params(node: ::Prism::ImplicitRestNode).void }
+  def visit_implicit_rest_node(node); end
+
+  sig { override.params(node: ::Prism::InNode).void }
+  def visit_in_node(node); end
+
+  sig { override.params(node: ::Prism::IndexAndWriteNode).void }
+  def visit_index_and_write_node(node); end
+
+  sig { override.params(node: ::Prism::IndexOperatorWriteNode).void }
+  def visit_index_operator_write_node(node); end
+
+  sig { override.params(node: ::Prism::IndexOrWriteNode).void }
+  def visit_index_or_write_node(node); end
+
+  sig { override.params(node: ::Prism::IndexTargetNode).void }
+  def visit_index_target_node(node); end
+
+  sig { override.params(node: ::Prism::InstanceVariableAndWriteNode).void }
+  def visit_instance_variable_and_write_node(node); end
+
+  sig { override.params(node: ::Prism::InstanceVariableOperatorWriteNode).void }
+  def visit_instance_variable_operator_write_node(node); end
+
+  sig { override.params(node: ::Prism::InstanceVariableOrWriteNode).void }
+  def visit_instance_variable_or_write_node(node); end
+
+  sig { override.params(node: ::Prism::InstanceVariableReadNode).void }
+  def visit_instance_variable_read_node(node); end
+
+  sig { override.params(node: ::Prism::InstanceVariableTargetNode).void }
+  def visit_instance_variable_target_node(node); end
+
+  sig { override.params(node: ::Prism::InstanceVariableWriteNode).void }
+  def visit_instance_variable_write_node(node); end
+
+  sig { override.params(node: ::Prism::IntegerNode).void }
+  def visit_integer_node(node); end
+
+  sig { override.params(node: ::Prism::InterpolatedMatchLastLineNode).void }
+  def visit_interpolated_match_last_line_node(node); end
+
+  sig { override.params(node: ::Prism::InterpolatedRegularExpressionNode).void }
+  def visit_interpolated_regular_expression_node(node); end
+
+  sig { override.params(node: ::Prism::InterpolatedStringNode).void }
+  def visit_interpolated_string_node(node); end
+
+  sig { override.params(node: ::Prism::InterpolatedSymbolNode).void }
+  def visit_interpolated_symbol_node(node); end
+
+  sig { override.params(node: ::Prism::InterpolatedXStringNode).void }
+  def visit_interpolated_x_string_node(node); end
+
+  sig { override.params(node: ::Prism::KeywordHashNode).void }
+  def visit_keyword_hash_node(node); end
+
+  sig { override.params(node: ::Prism::KeywordRestParameterNode).void }
+  def visit_keyword_rest_parameter_node(node); end
+
+  sig { override.params(node: ::Prism::LambdaNode).void }
+  def visit_lambda_node(node); end
+
+  sig { override.params(node: ::Prism::LocalVariableAndWriteNode).void }
+  def visit_local_variable_and_write_node(node); end
+
+  sig { override.params(node: ::Prism::LocalVariableOperatorWriteNode).void }
+  def visit_local_variable_operator_write_node(node); end
+
+  sig { override.params(node: ::Prism::LocalVariableOrWriteNode).void }
+  def visit_local_variable_or_write_node(node); end
+
+  sig { override.params(node: ::Prism::LocalVariableReadNode).void }
+  def visit_local_variable_read_node(node); end
+
+  sig { override.params(node: ::Prism::LocalVariableTargetNode).void }
+  def visit_local_variable_target_node(node); end
+
+  sig { override.params(node: ::Prism::LocalVariableWriteNode).void }
+  def visit_local_variable_write_node(node); end
+
+  sig { override.params(node: ::Prism::MatchLastLineNode).void }
+  def visit_match_last_line_node(node); end
+
+  sig { override.params(node: ::Prism::MatchPredicateNode).void }
+  def visit_match_predicate_node(node); end
+
+  sig { override.params(node: ::Prism::MatchRequiredNode).void }
+  def visit_match_required_node(node); end
+
+  sig { override.params(node: ::Prism::MatchWriteNode).void }
+  def visit_match_write_node(node); end
+
+  sig { override.params(node: ::Prism::MissingNode).void }
+  def visit_missing_node(node); end
+
+  sig { override.params(node: ::Prism::ModuleNode).void }
+  def visit_module_node(node); end
+
+  sig { override.params(node: ::Prism::MultiTargetNode).void }
+  def visit_multi_target_node(node); end
+
+  sig { override.params(node: ::Prism::MultiWriteNode).void }
+  def visit_multi_write_node(node); end
+
+  sig { override.params(node: ::Prism::NextNode).void }
+  def visit_next_node(node); end
+
+  sig { override.params(node: ::Prism::NilNode).void }
+  def visit_nil_node(node); end
+
+  sig { override.params(node: ::Prism::NoKeywordsParameterNode).void }
+  def visit_no_keywords_parameter_node(node); end
+
+  sig { override.params(node: ::Prism::NumberedParametersNode).void }
+  def visit_numbered_parameters_node(node); end
+
+  sig { override.params(node: ::Prism::NumberedReferenceReadNode).void }
+  def visit_numbered_reference_read_node(node); end
+
+  sig { override.params(node: ::Prism::OptionalKeywordParameterNode).void }
+  def visit_optional_keyword_parameter_node(node); end
+
+  sig { override.params(node: ::Prism::OptionalParameterNode).void }
+  def visit_optional_parameter_node(node); end
+
+  sig { override.params(node: ::Prism::OrNode).void }
+  def visit_or_node(node); end
+
+  sig { override.params(node: ::Prism::ParametersNode).void }
+  def visit_parameters_node(node); end
+
+  sig { override.params(node: ::Prism::ParenthesesNode).void }
+  def visit_parentheses_node(node); end
+
+  sig { override.params(node: ::Prism::PinnedExpressionNode).void }
+  def visit_pinned_expression_node(node); end
+
+  sig { override.params(node: ::Prism::PinnedVariableNode).void }
+  def visit_pinned_variable_node(node); end
+
+  sig { override.params(node: ::Prism::PostExecutionNode).void }
+  def visit_post_execution_node(node); end
+
+  sig { override.params(node: ::Prism::PreExecutionNode).void }
+  def visit_pre_execution_node(node); end
+
+  sig { override.params(node: ::Prism::ProgramNode).void }
+  def visit_program_node(node); end
+
+  sig { override.params(node: ::Prism::RangeNode).void }
+  def visit_range_node(node); end
+
+  sig { override.params(node: ::Prism::RationalNode).void }
+  def visit_rational_node(node); end
+
+  sig { override.params(node: ::Prism::RedoNode).void }
+  def visit_redo_node(node); end
+
+  sig { override.params(node: ::Prism::RegularExpressionNode).void }
+  def visit_regular_expression_node(node); end
+
+  sig { override.params(node: ::Prism::RequiredKeywordParameterNode).void }
+  def visit_required_keyword_parameter_node(node); end
+
+  sig { override.params(node: ::Prism::RequiredParameterNode).void }
+  def visit_required_parameter_node(node); end
+
+  sig { override.params(node: ::Prism::RescueModifierNode).void }
+  def visit_rescue_modifier_node(node); end
+
+  sig { override.params(node: ::Prism::RescueNode).void }
+  def visit_rescue_node(node); end
+
+  sig { override.params(node: ::Prism::RestParameterNode).void }
+  def visit_rest_parameter_node(node); end
+
+  sig { override.params(node: ::Prism::RetryNode).void }
+  def visit_retry_node(node); end
+
+  sig { override.params(node: ::Prism::ReturnNode).void }
+  def visit_return_node(node); end
+
+  sig { override.params(node: ::Prism::SelfNode).void }
+  def visit_self_node(node); end
+
+  sig { override.params(node: ::Prism::SingletonClassNode).void }
+  def visit_singleton_class_node(node); end
+
+  sig { override.params(node: ::Prism::SourceEncodingNode).void }
+  def visit_source_encoding_node(node); end
+
+  sig { override.params(node: ::Prism::SourceFileNode).void }
+  def visit_source_file_node(node); end
+
+  sig { override.params(node: ::Prism::SourceLineNode).void }
+  def visit_source_line_node(node); end
+
+  sig { override.params(node: ::Prism::SplatNode).void }
+  def visit_splat_node(node); end
+
+  sig { override.params(node: ::Prism::StatementsNode).void }
+  def visit_statements_node(node); end
+
+  sig { override.params(node: ::Prism::StringNode).void }
+  def visit_string_node(node); end
+
+  sig { override.params(node: ::Prism::SuperNode).void }
+  def visit_super_node(node); end
+
+  sig { override.params(node: ::Prism::SymbolNode).void }
+  def visit_symbol_node(node); end
+
+  sig { override.params(node: ::Prism::TrueNode).void }
+  def visit_true_node(node); end
+
+  sig { override.params(node: ::Prism::UndefNode).void }
+  def visit_undef_node(node); end
+
+  sig { override.params(node: ::Prism::UnlessNode).void }
+  def visit_unless_node(node); end
+
+  sig { override.params(node: ::Prism::UntilNode).void }
+  def visit_until_node(node); end
+
+  sig { override.params(node: ::Prism::WhenNode).void }
+  def visit_when_node(node); end
+
+  sig { override.params(node: ::Prism::WhileNode).void }
+  def visit_while_node(node); end
+
+  sig { override.params(node: ::Prism::XStringNode).void }
+  def visit_x_string_node(node); end
+
+  sig { override.params(node: ::Prism::YieldNode).void }
+  def visit_yield_node(node); end
+end