muina 0.2.7

data/sorbet/rbi/gems/mutant@0.10.32.rbi

@@ -0,0 +1,4154 @@
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `mutant` gem.
+# Please instead update this file by running `bin/tapioca sync`.
+
+# typed: true
+
+module Mutant
+  class << self
+    def traverse(action, values); end
+  end
+end
+
+module Mutant::AST
+  class << self
+    def find_last_path(node, &predicate); end
+
+    private
+
+    def walk(node, stack, &block); end
+  end
+end
+
+class Mutant::AST::FindMetaclassContaining
+  include ::Mutant::Procto
+  include ::Unparser::Equalizer::Methods
+  include ::Mutant::AST::NodePredicates
+  extend ::Mutant::Procto::ClassMethods
+
+  def call; end
+
+  private
+
+  def include_exact?(haystack, needle); end
+  def metaclass_of?(sclass); end
+  def transparently_contains?(body); end
+end
+
+Mutant::AST::FindMetaclassContaining::SCLASS_BODY_INDEX = T.let(T.unsafe(nil), Integer)
+module Mutant::AST::Meta; end
+
+class Mutant::AST::Meta::Const
+  include ::Mutant::AST::NodePredicates
+  include ::Unparser::Equalizer::Methods
+  include ::Mutant::AST::NamedChildren
+  include ::Mutant::AST::NamedChildren::InstanceMethods
+  extend ::Mutant::AST::NamedChildren::ClassMethods
+
+  def base; end
+  def name; end
+  def possible_top_level?; end
+
+  private
+
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+class Mutant::AST::Meta::Optarg
+  include ::Unparser::Equalizer::Methods
+  include ::Mutant::AST::NamedChildren
+  include ::Mutant::AST::NamedChildren::InstanceMethods
+  extend ::Mutant::AST::NamedChildren::ClassMethods
+
+  def default_value; end
+  def name; end
+  def used?; end
+
+  private
+
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+Mutant::AST::Meta::Optarg::UNDERSCORE = T.let(T.unsafe(nil), String)
+
+class Mutant::AST::Meta::Resbody
+  include ::Unparser::Equalizer::Methods
+  include ::Mutant::AST::NamedChildren
+  include ::Mutant::AST::NamedChildren::InstanceMethods
+  extend ::Mutant::AST::NamedChildren::ClassMethods
+
+  def assignment; end
+  def body; end
+  def captures; end
+
+  private
+
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+class Mutant::AST::Meta::Send
+  include ::Mutant::AST::NodePredicates
+  include ::Unparser::Equalizer::Methods
+  include ::Mutant::AST::NamedChildren
+  include ::Mutant::AST::NamedChildren::InstanceMethods
+  extend ::Mutant::AST::NamedChildren::ClassMethods
+
+  def arguments; end
+  def attribute_assignment?; end
+  def binary_method_operator?; end
+  def proc?; end
+  def receiver; end
+  def receiver_possible_top_level_const?; end
+  def selector; end
+
+  private
+
+  def naked_proc?; end
+  def proc_new?; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+Mutant::AST::Meta::Send::ATTRIBUTE_ASSIGNMENT_SELECTOR_SUFFIX = T.let(T.unsafe(nil), String)
+
+class Mutant::AST::Meta::Symbol
+  include ::Unparser::Equalizer::Methods
+  include ::Mutant::AST::NamedChildren
+  include ::Mutant::AST::NamedChildren::InstanceMethods
+  extend ::Mutant::AST::NamedChildren::ClassMethods
+
+  def name; end
+
+  private
+
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+module Mutant::AST::NamedChildren
+  include ::Mutant::AST::NamedChildren::InstanceMethods
+
+  mixes_in_class_methods ::Mutant::AST::NamedChildren::ClassMethods
+
+  class << self
+    def included(host); end
+  end
+end
+
+module Mutant::AST::NamedChildren::ClassMethods
+  private
+
+  def children(*names); end
+  def define_named_child(name, index); end
+  def define_private_method(name, &block); end
+  def define_remaining_children(names); end
+end
+
+module Mutant::AST::NamedChildren::InstanceMethods
+  private
+
+  def children; end
+end
+
+module Mutant::AST::NodePredicates
+  private
+
+  def n___ENCODING__?(node); end
+  def n___FILE__?(node); end
+  def n___LINE__?(node); end
+  def n_alias?(node); end
+  def n_and?(node); end
+  def n_and_asgn?(node); end
+  def n_arg?(node); end
+  def n_arg_expr?(node); end
+  def n_args?(node); end
+  def n_array?(node); end
+  def n_array_pattern?(node); end
+  def n_array_pattern_with_tail?(node); end
+  def n_back_ref?(node); end
+  def n_begin?(node); end
+  def n_block?(node); end
+  def n_block_pass?(node); end
+  def n_blockarg?(node); end
+  def n_blockarg_expr?(node); end
+  def n_break?(node); end
+  def n_case?(node); end
+  def n_case_match?(node); end
+  def n_casgn?(node); end
+  def n_cbase?(node); end
+  def n_class?(node); end
+  def n_complex?(node); end
+  def n_const?(node); end
+  def n_const_pattern?(node); end
+  def n_csend?(node); end
+  def n_cvar?(node); end
+  def n_cvasgn?(node); end
+  def n_def?(node); end
+  def n_defined?(node); end
+  def n_defs?(node); end
+  def n_dstr?(node); end
+  def n_dsym?(node); end
+  def n_eflipflop?(node); end
+  def n_empty?(node); end
+  def n_empty_else?(node); end
+  def n_ensure?(node); end
+  def n_erange?(node); end
+  def n_false?(node); end
+  def n_find_pattern?(node); end
+  def n_float?(node); end
+  def n_for?(node); end
+  def n_forward_arg?(node); end
+  def n_forward_args?(node); end
+  def n_forwarded_args?(node); end
+  def n_gvar?(node); end
+  def n_gvasgn?(node); end
+  def n_hash?(node); end
+  def n_hash_pattern?(node); end
+  def n_ident?(node); end
+  def n_if?(node); end
+  def n_if_guard?(node); end
+  def n_iflipflop?(node); end
+  def n_in_match?(node); end
+  def n_in_pattern?(node); end
+  def n_index?(node); end
+  def n_indexasgn?(node); end
+  def n_int?(node); end
+  def n_irange?(node); end
+  def n_ivar?(node); end
+  def n_ivasgn?(node); end
+  def n_kwarg?(node); end
+  def n_kwargs?(node); end
+  def n_kwbegin?(node); end
+  def n_kwnilarg?(node); end
+  def n_kwoptarg?(node); end
+  def n_kwrestarg?(node); end
+  def n_kwsplat?(node); end
+  def n_lambda?(node); end
+  def n_lvar?(node); end
+  def n_lvasgn?(node); end
+  def n_masgn?(node); end
+  def n_match_alt?(node); end
+  def n_match_as?(node); end
+  def n_match_current_line?(node); end
+  def n_match_nil_pattern?(node); end
+  def n_match_pattern?(node); end
+  def n_match_pattern_p?(node); end
+  def n_match_rest?(node); end
+  def n_match_var?(node); end
+  def n_match_with_lvasgn?(node); end
+  def n_match_with_trailing_comma?(node); end
+  def n_mlhs?(node); end
+  def n_module?(node); end
+  def n_next?(node); end
+  def n_nil?(node); end
+  def n_nth_ref?(node); end
+  def n_numargs?(node); end
+  def n_numblock?(node); end
+  def n_objc_kwarg?(node); end
+  def n_objc_restarg?(node); end
+  def n_objc_varargs?(node); end
+  def n_op_asgn?(node); end
+  def n_optarg?(node); end
+  def n_or?(node); end
+  def n_or_asgn?(node); end
+  def n_pair?(node); end
+  def n_pin?(node); end
+  def n_postexe?(node); end
+  def n_preexe?(node); end
+  def n_procarg0?(node); end
+  def n_rational?(node); end
+  def n_redo?(node); end
+  def n_regexp?(node); end
+  def n_regexp_alnum_posixclass?(node); end
+  def n_regexp_alpha_posixclass?(node); end
+  def n_regexp_alpha_property?(node); end
+  def n_regexp_alternation_escape?(node); end
+  def n_regexp_alternation_meta?(node); end
+  def n_regexp_arabic_property?(node); end
+  def n_regexp_ascii_posixclass?(node); end
+  def n_regexp_atomic_group?(node); end
+  def n_regexp_backslash_escape?(node); end
+  def n_regexp_backspace_escape?(node); end
+  def n_regexp_bell_escape?(node); end
+  def n_regexp_blank_posixclass?(node); end
+  def n_regexp_bol_anchor?(node); end
+  def n_regexp_bol_escape?(node); end
+  def n_regexp_bos_anchor?(node); end
+  def n_regexp_capture_group?(node); end
+  def n_regexp_carriage_escape?(node); end
+  def n_regexp_character_set?(node); end
+  def n_regexp_cntrl_posixclass?(node); end
+  def n_regexp_codepoint_escape?(node); end
+  def n_regexp_codepoint_list_escape?(node); end
+  def n_regexp_comment_free_space?(node); end
+  def n_regexp_comment_group?(node); end
+  def n_regexp_condition_conditional?(node); end
+  def n_regexp_control_escape?(node); end
+  def n_regexp_digit_posixclass?(node); end
+  def n_regexp_digit_type?(node); end
+  def n_regexp_dot_escape?(node); end
+  def n_regexp_dot_meta?(node); end
+  def n_regexp_eol_anchor?(node); end
+  def n_regexp_eol_escape?(node); end
+  def n_regexp_eos_anchor?(node); end
+  def n_regexp_eos_ob_eol_anchor?(node); end
+  def n_regexp_escape_escape?(node); end
+  def n_regexp_form_feed_escape?(node); end
+  def n_regexp_graph_posixclass?(node); end
+  def n_regexp_greedy_interval?(node); end
+  def n_regexp_greedy_one_or_more?(node); end
+  def n_regexp_greedy_zero_or_more?(node); end
+  def n_regexp_greedy_zero_or_one?(node); end
+  def n_regexp_group_close_escape?(node); end
+  def n_regexp_group_open_escape?(node); end
+  def n_regexp_han_property?(node); end
+  def n_regexp_hangul_property?(node); end
+  def n_regexp_hex_escape?(node); end
+  def n_regexp_hex_type?(node); end
+  def n_regexp_hiragana_property?(node); end
+  def n_regexp_intersection_set?(node); end
+  def n_regexp_interval_close_escape?(node); end
+  def n_regexp_interval_open_escape?(node); end
+  def n_regexp_katakana_property?(node); end
+  def n_regexp_latin_property?(node); end
+  def n_regexp_letter_property?(node); end
+  def n_regexp_linebreak_type?(node); end
+  def n_regexp_literal_escape?(node); end
+  def n_regexp_literal_literal?(node); end
+  def n_regexp_lookahead_assertion?(node); end
+  def n_regexp_lookbehind_assertion?(node); end
+  def n_regexp_lower_posixclass?(node); end
+  def n_regexp_mark_keep?(node); end
+  def n_regexp_match_start_anchor?(node); end
+  def n_regexp_meta_sequence_escape?(node); end
+  def n_regexp_name_call_backref?(node); end
+  def n_regexp_named_group?(node); end
+  def n_regexp_newline_escape?(node); end
+  def n_regexp_nlookahead_assertion?(node); end
+  def n_regexp_nlookbehind_assertion?(node); end
+  def n_regexp_nondigit_type?(node); end
+  def n_regexp_nonhex_type?(node); end
+  def n_regexp_nonspace_type?(node); end
+  def n_regexp_nonword_boundary_anchor?(node); end
+  def n_regexp_nonword_type?(node); end
+  def n_regexp_number_backref?(node); end
+  def n_regexp_octal_escape?(node); end
+  def n_regexp_one_or_more_escape?(node); end
+  def n_regexp_open_conditional?(node); end
+  def n_regexp_options_group?(node); end
+  def n_regexp_options_switch_group?(node); end
+  def n_regexp_passive_group?(node); end
+  def n_regexp_possessive_interval?(node); end
+  def n_regexp_possessive_one_or_more?(node); end
+  def n_regexp_possessive_zero_or_more?(node); end
+  def n_regexp_possessive_zero_or_one?(node); end
+  def n_regexp_print_nonposixclass?(node); end
+  def n_regexp_print_nonproperty?(node); end
+  def n_regexp_print_posixclass?(node); end
+  def n_regexp_print_property?(node); end
+  def n_regexp_punct_posixclass?(node); end
+  def n_regexp_range_set?(node); end
+  def n_regexp_reluctant_interval?(node); end
+  def n_regexp_reluctant_one_or_more?(node); end
+  def n_regexp_reluctant_zero_or_more?(node); end
+  def n_regexp_root_expression?(node); end
+  def n_regexp_sequence_expression?(node); end
+  def n_regexp_set_close_escape?(node); end
+  def n_regexp_set_open_escape?(node); end
+  def n_regexp_space_posixclass?(node); end
+  def n_regexp_space_type?(node); end
+  def n_regexp_tab_escape?(node); end
+  def n_regexp_upper_posixclass?(node); end
+  def n_regexp_vertical_tab_escape?(node); end
+  def n_regexp_whitespace_free_space?(node); end
+  def n_regexp_word_boundary_anchor?(node); end
+  def n_regexp_word_posixclass?(node); end
+  def n_regexp_word_type?(node); end
+  def n_regexp_xdigit_posixclass?(node); end
+  def n_regexp_xgrapheme_type?(node); end
+  def n_regexp_zero_or_more_escape?(node); end
+  def n_regexp_zero_or_one_escape?(node); end
+  def n_regopt?(node); end
+  def n_resbody?(node); end
+  def n_rescue?(node); end
+  def n_restarg?(node); end
+  def n_restarg_expr?(node); end
+  def n_retry?(node); end
+  def n_return?(node); end
+  def n_sclass?(node); end
+  def n_self?(node); end
+  def n_send?(node); end
+  def n_shadowarg?(node); end
+  def n_splat?(node); end
+  def n_str?(node); end
+  def n_super?(node); end
+  def n_sym?(node); end
+  def n_true?(node); end
+  def n_undef?(node); end
+  def n_unless_guard?(node); end
+  def n_until?(node); end
+  def n_until_post?(node); end
+  def n_when?(node); end
+  def n_while?(node); end
+  def n_while_post?(node); end
+  def n_xstr?(node); end
+  def n_yield?(node); end
+  def n_zsuper?(node); end
+end
+
+module Mutant::AST::Nodes
+  extend ::Mutant::AST::Sexp
+end
+
+Mutant::AST::Nodes::N_EMPTY = T.let(T.unsafe(nil), Parser::AST::Node)
+Mutant::AST::Nodes::N_EMPTY_SUPER = T.let(T.unsafe(nil), Parser::AST::Node)
+Mutant::AST::Nodes::N_FALSE = T.let(T.unsafe(nil), Parser::AST::Node)
+Mutant::AST::Nodes::N_INFINITY = T.let(T.unsafe(nil), Parser::AST::Node)
+Mutant::AST::Nodes::N_NAN = T.let(T.unsafe(nil), Parser::AST::Node)
+Mutant::AST::Nodes::N_NEGATIVE_INFINITY = T.let(T.unsafe(nil), Parser::AST::Node)
+Mutant::AST::Nodes::N_NIL = T.let(T.unsafe(nil), Parser::AST::Node)
+Mutant::AST::Nodes::N_RAISE = T.let(T.unsafe(nil), Parser::AST::Node)
+Mutant::AST::Nodes::N_SELF = T.let(T.unsafe(nil), Parser::AST::Node)
+Mutant::AST::Nodes::N_TRUE = T.let(T.unsafe(nil), Parser::AST::Node)
+Mutant::AST::Nodes::N_ZSUPER = T.let(T.unsafe(nil), Parser::AST::Node)
+
+module Mutant::AST::Regexp
+  class << self
+    def expand_regexp_ast(node); end
+    def parse(regexp); end
+    def to_ast(expression); end
+    def to_expression(node); end
+  end
+end
+
+class Mutant::AST::Regexp::Transformer
+  include ::Unparser::AbstractType
+  extend ::Unparser::AbstractType::AbstractMethodDeclarations
+
+  class << self
+    def lookup(type); end
+    def new(*args, &block); end
+    def to_ast(expression); end
+    def to_expression(node); end
+
+    private
+
+    def register(type); end
+  end
+end
+
+class Mutant::AST::Regexp::Transformer::ASTToExpression
+  extend ::Mutant::Procto::ClassMethods
+  include ::Unparser::Adamantium::InstanceMethods
+  include ::Unparser::AbstractType
+  include ::Mutant::Procto
+  include ::Unparser::Equalizer::Methods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+  extend ::Unparser::AbstractType::AbstractMethodDeclarations
+  include ::Unparser::Adamantium
+
+  def call; end
+  def transform(*_arg0); end
+
+  private
+
+  def subexpressions; end
+
+  class << self
+    def new(*args, &block); end
+  end
+end
+
+class Mutant::AST::Regexp::Transformer::Direct < ::Mutant::AST::Regexp::Transformer; end
+
+class Mutant::AST::Regexp::Transformer::Direct::ASTToExpression < ::Mutant::AST::Regexp::Transformer::ASTToExpression
+  include ::Mutant::AST::Regexp::Transformer::LookupTable
+
+  private
+
+  def transform; end
+end
+
+Mutant::AST::Regexp::Transformer::Direct::ASTToExpression::TABLE = T.let(T.unsafe(nil), Mutant::AST::Regexp::Transformer::LookupTable::Table)
+
+class Mutant::AST::Regexp::Transformer::Direct::ExpressionToAST < ::Mutant::AST::Regexp::Transformer::ExpressionToAST
+  def call; end
+end
+
+class Mutant::AST::Regexp::Transformer::ExpressionToAST
+  extend ::Mutant::Procto::ClassMethods
+  include ::Unparser::Adamantium::InstanceMethods
+  include ::Unparser::AbstractType
+  include ::Mutant::AST::Sexp
+  include ::Mutant::Procto
+  include ::Unparser::Equalizer::Methods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+  extend ::Unparser::AbstractType::AbstractMethodDeclarations
+  include ::Unparser::Adamantium
+
+  private
+
+  def ast(*children); end
+  def children; end
+  def quantify(node); end
+  def type; end
+
+  class << self
+    def new(*args, &block); end
+  end
+end
+
+Mutant::AST::Regexp::Transformer::ExpressionToAST::PREFIX = T.let(T.unsafe(nil), Symbol)
+
+module Mutant::AST::Regexp::Transformer::LookupTable
+  private
+
+  def expression_class; end
+  def expression_token; end
+end
+
+class Mutant::AST::Regexp::Transformer::LookupTable::Mapping
+  include ::Unparser::Equalizer::Methods
+end
+
+class Mutant::AST::Regexp::Transformer::LookupTable::Table
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+
+  def lookup(type); end
+  def types; end
+
+  class << self
+    def create(*rows); end
+  end
+end
+
+class Mutant::AST::Regexp::Transformer::NamedGroup < ::Mutant::AST::Regexp::Transformer; end
+
+class Mutant::AST::Regexp::Transformer::NamedGroup::ASTToExpression < ::Mutant::AST::Regexp::Transformer::ASTToExpression
+  include ::Mutant::AST::NamedChildren
+  include ::Mutant::AST::NamedChildren::InstanceMethods
+  extend ::Mutant::AST::NamedChildren::ClassMethods
+
+  private
+
+  def name; end
+  def named_group; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+  def subexpressions; end
+  def transform; end
+end
+
+class Mutant::AST::Regexp::Transformer::NamedGroup::ExpressionToAST < ::Mutant::AST::Regexp::Transformer::ExpressionToAST
+  def call; end
+end
+
+class Mutant::AST::Regexp::Transformer::OptionsGroup < ::Mutant::AST::Regexp::Transformer; end
+
+class Mutant::AST::Regexp::Transformer::OptionsGroup::ASTToExpression < ::Mutant::AST::Regexp::Transformer::ASTToExpression
+  include ::Mutant::AST::NamedChildren
+  include ::Mutant::AST::NamedChildren::InstanceMethods
+  extend ::Mutant::AST::NamedChildren::ClassMethods
+
+  private
+
+  def option_changes; end
+  def options_group; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+  def subexpressions; end
+  def text; end
+  def transform; end
+  def type; end
+end
+
+class Mutant::AST::Regexp::Transformer::OptionsGroup::ExpressionToAST < ::Mutant::AST::Regexp::Transformer::ExpressionToAST
+  def call; end
+end
+
+class Mutant::AST::Regexp::Transformer::Quantifier < ::Mutant::AST::Regexp::Transformer; end
+
+class Mutant::AST::Regexp::Transformer::Quantifier::ASTToExpression < ::Mutant::AST::Regexp::Transformer::ASTToExpression
+  include ::Mutant::AST::NamedChildren
+  include ::Mutant::AST::NamedChildren::InstanceMethods
+  extend ::Mutant::AST::NamedChildren::ClassMethods
+
+  private
+
+  def interval_text; end
+  def max; end
+  def min; end
+  def mode; end
+  def quantifier; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+  def subject; end
+  def suffix; end
+  def text; end
+  def transform; end
+  def type; end
+end
+
+Mutant::AST::Regexp::Transformer::Quantifier::ASTToExpression::QUANTIFIER_MAP = T.let(T.unsafe(nil), Hash)
+
+class Mutant::AST::Regexp::Transformer::Quantifier::ASTToExpression::Quantifier
+  include ::Unparser::Equalizer::Methods
+end
+
+class Mutant::AST::Regexp::Transformer::Quantifier::ExpressionToAST < ::Mutant::AST::Regexp::Transformer::ExpressionToAST
+  def call; end
+
+  private
+
+  def type; end
+end
+
+Mutant::AST::Regexp::Transformer::REGISTRY = T.let(T.unsafe(nil), Mutant::Registry)
+class Mutant::AST::Regexp::Transformer::Recursive < ::Mutant::AST::Regexp::Transformer; end
+
+class Mutant::AST::Regexp::Transformer::Recursive::ASTToExpression < ::Mutant::AST::Regexp::Transformer::ASTToExpression
+  include ::Mutant::AST::Regexp::Transformer::LookupTable
+
+  private
+
+  def transform; end
+end
+
+Mutant::AST::Regexp::Transformer::Recursive::ASTToExpression::TABLE = T.let(T.unsafe(nil), Mutant::AST::Regexp::Transformer::LookupTable::Table)
+
+class Mutant::AST::Regexp::Transformer::Recursive::ExpressionToAST < ::Mutant::AST::Regexp::Transformer::ExpressionToAST
+  def call; end
+end
+
+class Mutant::AST::Regexp::Transformer::Root < ::Mutant::AST::Regexp::Transformer; end
+
+class Mutant::AST::Regexp::Transformer::Root::ASTToExpression < ::Mutant::AST::Regexp::Transformer::ASTToExpression
+  private
+
+  def transform; end
+end
+
+class Mutant::AST::Regexp::Transformer::Root::ExpressionToAST < ::Mutant::AST::Regexp::Transformer::Recursive::ExpressionToAST; end
+class Mutant::AST::Regexp::Transformer::Text < ::Mutant::AST::Regexp::Transformer; end
+
+class Mutant::AST::Regexp::Transformer::Text::ASTToExpression < ::Mutant::AST::Regexp::Transformer::ASTToExpression
+  include ::Mutant::AST::Regexp::Transformer::LookupTable
+
+  private
+
+  def transform; end
+end
+
+Mutant::AST::Regexp::Transformer::Text::ASTToExpression::TABLE = T.let(T.unsafe(nil), Mutant::AST::Regexp::Transformer::LookupTable::Table)
+
+class Mutant::AST::Regexp::Transformer::Text::ExpressionToAST < ::Mutant::AST::Regexp::Transformer::ExpressionToAST
+  def call; end
+end
+
+module Mutant::AST::Sexp
+  private
+
+  def n_not(node); end
+  def s(type, *children); end
+end
+
+module Mutant::AST::Types; end
+Mutant::AST::Types::ALL = T.let(T.unsafe(nil), Set)
+Mutant::AST::Types::ASSIGNABLE_VARIABLES = T.let(T.unsafe(nil), Set)
+Mutant::AST::Types::BINARY_METHOD_OPERATORS = T.let(T.unsafe(nil), Set)
+Mutant::AST::Types::BLACKLIST = T.let(T.unsafe(nil), Set)
+Mutant::AST::Types::GENERATED = T.let(T.unsafe(nil), Set)
+Mutant::AST::Types::INDEX_OPERATORS = T.let(T.unsafe(nil), Set)
+Mutant::AST::Types::METHOD_OPERATORS = T.let(T.unsafe(nil), Set)
+Mutant::AST::Types::NOT_STANDALONE = T.let(T.unsafe(nil), Set)
+Mutant::AST::Types::OP_ASSIGN = T.let(T.unsafe(nil), Set)
+Mutant::AST::Types::REGEXP = T.let(T.unsafe(nil), Set)
+Mutant::AST::Types::UNARY_METHOD_OPERATORS = T.let(T.unsafe(nil), Set)
+Mutant::AbstractType = Unparser::AbstractType
+Mutant::Adamantium = Unparser::Adamantium
+Mutant::Anima = Unparser::Anima
+
+module Mutant::Bootstrap
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+
+  def config; end
+  def parser; end
+  def world; end
+
+  class << self
+    def anima; end
+    def call(world, config); end
+
+    private
+
+    def expression(reporter, expression_parser, scope); end
+    def infect(env); end
+    def load_hooks(env); end
+    def matchable_scopes(world, config); end
+    def scope_name(reporter, scope); end
+    def semantics_warning(reporter, format, options); end
+    def start_subject(env, subjects); end
+  end
+end
+
+Mutant::Bootstrap::CLASS_NAME_RAISED_EXCEPTION = T.let(T.unsafe(nil), String)
+Mutant::Bootstrap::CLASS_NAME_TYPE_MISMATCH_FORMAT = T.let(T.unsafe(nil), String)
+Mutant::Bootstrap::SEMANTICS_MESSAGE_FORMAT = T.let(T.unsafe(nil), String)
+
+module Mutant::CLI
+  class << self
+    def parse(world:, **attributes); end
+  end
+end
+
+class Mutant::CLI::Command
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::AbstractType
+  extend ::Unparser::AbstractType::AbstractMethodDeclarations
+
+  def arguments; end
+  def call; end
+  def full_name; end
+  def main; end
+  def parent; end
+  def world; end
+  def zombie?; end
+
+  private
+
+  def add_global_options(parser); end
+  def add_subcommands(parser); end
+  def add_summary(parser); end
+  def banner; end
+  def capture_main(&block); end
+  def execute; end
+  def fail_message(message); end
+  def find_command(name); end
+  def format_subcommands; end
+  def parse; end
+  def parse_remaining(remaining); end
+  def parse_remaining_arguments(remaining); end
+  def parse_subcommand(arguments); end
+  def parser; end
+  def print(message); end
+  def subcommands; end
+  def with_help(message); end
+
+  class << self
+    def anima; end
+    def command_name; end
+    def new(*args, &block); end
+    def parse(**attributes); end
+    def short_description; end
+  end
+end
+
+class Mutant::CLI::Command::Environment < ::Mutant::CLI::Command
+  def initialize(attributes); end
+
+  private
+
+  def add(attribute, value); end
+  def add_environment_options(parser); end
+  def add_integration_options(parser); end
+  def add_matcher(attribute, value); end
+  def add_matcher_options(parser); end
+  def add_runner_options(parser); end
+  def bootstrap; end
+  def expand(file_config); end
+  def matcher(**attributes); end
+  def parse_remaining_arguments(arguments); end
+  def set(**attributes); end
+end
+
+Mutant::CLI::Command::Environment::NAME = T.let(T.unsafe(nil), String)
+Mutant::CLI::Command::Environment::OPTIONS = T.let(T.unsafe(nil), Array)
+
+class Mutant::CLI::Command::Environment::Run < ::Mutant::CLI::Command::Environment
+  def zombie?; end
+
+  private
+
+  def action; end
+  def from_result(result); end
+  def soft_fail(result); end
+  def unlicensed(message); end
+end
+
+Mutant::CLI::Command::Environment::Run::NAME = T.let(T.unsafe(nil), String)
+Mutant::CLI::Command::Environment::Run::SHORT_DESCRIPTION = T.let(T.unsafe(nil), String)
+Mutant::CLI::Command::Environment::Run::SLEEP = T.let(T.unsafe(nil), Integer)
+Mutant::CLI::Command::Environment::Run::SUBCOMMANDS = T.let(T.unsafe(nil), Array)
+Mutant::CLI::Command::Environment::Run::UNLICENSED = T.let(T.unsafe(nil), Array)
+Mutant::CLI::Command::Environment::SHORT_DESCRIPTION = T.let(T.unsafe(nil), String)
+Mutant::CLI::Command::Environment::SUBCOMMANDS = T.let(T.unsafe(nil), Array)
+
+class Mutant::CLI::Command::Environment::Show < ::Mutant::CLI::Command::Environment
+  private
+
+  def action; end
+  def report_env(env); end
+end
+
+Mutant::CLI::Command::Environment::Show::NAME = T.let(T.unsafe(nil), String)
+Mutant::CLI::Command::Environment::Show::SHORT_DESCRIPTION = T.let(T.unsafe(nil), String)
+Mutant::CLI::Command::Environment::Show::SUBCOMMANDS = T.let(T.unsafe(nil), Array)
+class Mutant::CLI::Command::Environment::Subject < ::Mutant::CLI::Command::Environment; end
+
+class Mutant::CLI::Command::Environment::Subject::List < ::Mutant::CLI::Command::Environment::Subject
+  private
+
+  def action; end
+  def list_subjects(env); end
+end
+
+Mutant::CLI::Command::Environment::Subject::List::NAME = T.let(T.unsafe(nil), String)
+Mutant::CLI::Command::Environment::Subject::List::SHORT_DESCRIPTION = T.let(T.unsafe(nil), String)
+Mutant::CLI::Command::Environment::Subject::List::SUBCOMMANDS = T.let(T.unsafe(nil), Array)
+Mutant::CLI::Command::Environment::Subject::NAME = T.let(T.unsafe(nil), String)
+Mutant::CLI::Command::Environment::Subject::SHORT_DESCRIPTION = T.let(T.unsafe(nil), String)
+Mutant::CLI::Command::Environment::Subject::SUBCOMMANDS = T.let(T.unsafe(nil), Array)
+class Mutant::CLI::Command::Environment::Test < ::Mutant::CLI::Command::Environment; end
+
+class Mutant::CLI::Command::Environment::Test::List < ::Mutant::CLI::Command::Environment::Test
+  private
+
+  def action; end
+  def list_tests(env); end
+end
+
+Mutant::CLI::Command::Environment::Test::List::NAME = T.let(T.unsafe(nil), String)
+Mutant::CLI::Command::Environment::Test::List::SHORT_DESCRIPTION = T.let(T.unsafe(nil), String)
+Mutant::CLI::Command::Environment::Test::List::SUBCOMMANDS = T.let(T.unsafe(nil), Array)
+Mutant::CLI::Command::Environment::Test::NAME = T.let(T.unsafe(nil), String)
+Mutant::CLI::Command::Environment::Test::SHORT_DESCRIPTION = T.let(T.unsafe(nil), String)
+Mutant::CLI::Command::Environment::Test::SUBCOMMANDS = T.let(T.unsafe(nil), Array)
+
+class Mutant::CLI::Command::FailParse < ::Mutant::CLI::Command
+  def call; end
+end
+
+Mutant::CLI::Command::OPTIONS = T.let(T.unsafe(nil), Array)
+
+class Mutant::CLI::Command::OptionParser < ::OptionParser
+  def add_officious; end
+end
+
+class Mutant::CLI::Command::Root < ::Mutant::CLI::Command; end
+Mutant::CLI::Command::Root::NAME = T.let(T.unsafe(nil), String)
+Mutant::CLI::Command::Root::SHORT_DESCRIPTION = T.let(T.unsafe(nil), String)
+Mutant::CLI::Command::Root::SUBCOMMANDS = T.let(T.unsafe(nil), Array)
+Mutant::CLI::Command::SUBCOMMANDS = T.let(T.unsafe(nil), Array)
+
+class Mutant::CLI::Command::Subscription < ::Mutant::CLI::Command
+  private
+
+  def license; end
+end
+
+Mutant::CLI::Command::Subscription::NAME = T.let(T.unsafe(nil), String)
+Mutant::CLI::Command::Subscription::SHORT_DESCRIPTION = T.let(T.unsafe(nil), String)
+Mutant::CLI::Command::Subscription::SUBCOMMANDS = T.let(T.unsafe(nil), Array)
+
+class Mutant::CLI::Command::Subscription::Show < ::Mutant::CLI::Command::Subscription
+  private
+
+  def execute; end
+  def licensed(subscription); end
+  def unlicensed(message); end
+end
+
+Mutant::CLI::Command::Subscription::Show::NAME = T.let(T.unsafe(nil), String)
+Mutant::CLI::Command::Subscription::Show::SHORT_DESCRIPTION = T.let(T.unsafe(nil), String)
+Mutant::CLI::Command::Subscription::Show::SUBCOMMANDS = T.let(T.unsafe(nil), Array)
+
+class Mutant::CLI::Command::Subscription::Test < ::Mutant::CLI::Command::Subscription
+  private
+
+  def execute; end
+end
+
+Mutant::CLI::Command::Subscription::Test::NAME = T.let(T.unsafe(nil), String)
+Mutant::CLI::Command::Subscription::Test::SHORT_DESCRIPTION = T.let(T.unsafe(nil), String)
+Mutant::CLI::Command::Subscription::Test::SUBCOMMANDS = T.let(T.unsafe(nil), Array)
+Mutant::Concord = Unparser::Concord
+
+class Mutant::Config
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+
+  def coverage_criteria; end
+  def expand_defaults; end
+  def expression_parser; end
+  def fail_fast; end
+  def fail_fast?; end
+  def hooks; end
+  def includes; end
+  def integration; end
+  def isolation; end
+  def jobs; end
+  def matcher; end
+  def merge(other); end
+  def mutation_timeout; end
+  def reporter; end
+  def requires; end
+  def zombie; end
+  def zombie?; end
+
+  class << self
+    def anima; end
+    def env; end
+    def load_config_file(world); end
+
+    private
+
+    def load_contents(path); end
+  end
+end
+
+Mutant::Config::CANDIDATES = T.let(T.unsafe(nil), Array)
+
+class Mutant::Config::CoverageCriteria
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+
+  def merge(other); end
+  def process_abort; end
+  def test_result; end
+  def timeout; end
+
+  private
+
+  def overwrite(other, attribute_name); end
+
+  class << self
+    def anima; end
+  end
+end
+
+Mutant::Config::CoverageCriteria::DEFAULT = T.let(T.unsafe(nil), Mutant::Config::CoverageCriteria)
+Mutant::Config::CoverageCriteria::EMPTY = T.let(T.unsafe(nil), Mutant::Config::CoverageCriteria)
+Mutant::Config::CoverageCriteria::TRANSFORM = T.let(T.unsafe(nil), Mutant::Transform::Sequence)
+Mutant::Config::DEFAULT = T.let(T.unsafe(nil), Mutant::Config)
+Mutant::Config::MORE_THAN_ONE_CONFIG_FILE = T.let(T.unsafe(nil), String)
+Mutant::Config::PATHNAME_ARRAY = T.let(T.unsafe(nil), Mutant::Transform::Array)
+Mutant::Config::TRANSFORM = T.let(T.unsafe(nil), Mutant::Transform::Sequence)
+
+class Mutant::Context
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+  extend ::Mutant::AST::Sexp
+
+  def identification; end
+  def match_expressions(&block); end
+  def nesting(&block); end
+  def root(node); end
+  def scope; end
+  def unqualified_name; end
+
+  private
+
+  def name_nesting(&block); end
+
+  class << self
+    def wrap(scope, node); end
+  end
+end
+
+Mutant::Context::NAMESPACE_DELIMITER = T.let(T.unsafe(nil), String)
+Mutant::EMPTY_ARRAY = T.let(T.unsafe(nil), Array)
+Mutant::EMPTY_HASH = T.let(T.unsafe(nil), Hash)
+Mutant::EMPTY_STRING = T.let(T.unsafe(nil), String)
+Mutant::Either = Unparser::Either
+
+class Mutant::Env
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+
+  def amount_mutations(&block); end
+  def amount_selected_tests(&block); end
+  def amount_subjects(&block); end
+  def amount_total_tests(&block); end
+  def config; end
+  def cover_index(mutation_index); end
+  def hooks; end
+  def integration; end
+  def matchable_scopes; end
+  def mutations; end
+  def parser; end
+  def selected_tests(&block); end
+  def selections(&block); end
+  def selector; end
+  def subjects; end
+  def test_subject_ratio(&block); end
+  def warn(message); end
+  def world; end
+
+  private
+
+  def run_mutation_tests(mutation, tests); end
+  def timer; end
+
+  class << self
+    def anima; end
+    def empty(world, config); end
+  end
+end
+
+Mutant::Env::SEMANTICS_MESSAGE = T.let(T.unsafe(nil), String)
+Mutant::Equalizer = Unparser::Equalizer
+
+class Mutant::Expression
+  def match_length(other); end
+  def prefix?(other); end
+
+  class << self
+    def new(*_arg0); end
+    def try_parse(input); end
+
+    private
+
+    def from_match(match); end
+  end
+end
+
+class Mutant::Expression::Method < ::Mutant::Expression
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+  extend ::Mutant::AST::Sexp
+
+  def initialize(*_arg0); end
+
+  def matcher; end
+  def syntax; end
+
+  private
+
+  def method_name; end
+  def scope; end
+  def scope_name; end
+  def scope_symbol; end
+
+  class << self
+    def anima; end
+    def try_parse(input); end
+
+    private
+
+    def valid_method_name?(name); end
+  end
+end
+
+Mutant::Expression::Method::MATCHERS = T.let(T.unsafe(nil), Hash)
+Mutant::Expression::Method::METHOD_NAME_PATTERN = T.let(T.unsafe(nil), Regexp)
+Mutant::Expression::Method::REGEXP = T.let(T.unsafe(nil), Regexp)
+
+class Mutant::Expression::Methods < ::Mutant::Expression
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+
+  def initialize(*_arg0); end
+
+  def match_length(expression); end
+  def matcher; end
+  def syntax; end
+
+  private
+
+  def scope; end
+  def scope_name; end
+  def scope_symbol; end
+
+  class << self
+    def anima; end
+  end
+end
+
+Mutant::Expression::Methods::MATCHERS = T.let(T.unsafe(nil), Hash)
+Mutant::Expression::Methods::REGEXP = T.let(T.unsafe(nil), Regexp)
+
+class Mutant::Expression::Namespace < ::Mutant::Expression
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::AbstractType
+  extend ::Unparser::AbstractType::AbstractMethodDeclarations
+
+  private
+
+  def scope_name; end
+
+  class << self
+    def anima; end
+    def new(*args, &block); end
+  end
+end
+
+class Mutant::Expression::Namespace::Exact < ::Mutant::Expression::Namespace
+  def matcher; end
+  def syntax; end
+
+  private
+
+  def find_scope; end
+end
+
+Mutant::Expression::Namespace::Exact::MATCHER = Mutant::Matcher::Scope
+Mutant::Expression::Namespace::Exact::REGEXP = T.let(T.unsafe(nil), Regexp)
+
+class Mutant::Expression::Namespace::Recursive < ::Mutant::Expression::Namespace
+  def initialize(*_arg0); end
+
+  def match_length(expression); end
+  def matcher; end
+  def syntax; end
+end
+
+Mutant::Expression::Namespace::Recursive::REGEXP = T.let(T.unsafe(nil), Regexp)
+
+class Mutant::Expression::Parser
+  include ::Unparser::Equalizer::Methods
+
+  def call(input); end
+
+  private
+
+  def expressions(input); end
+end
+
+Mutant::Expression::SCOPE_NAME_PATTERN = T.let(T.unsafe(nil), Regexp)
+Mutant::Expression::SCOPE_SYMBOL_PATTERN = T.let(T.unsafe(nil), String)
+
+class Mutant::Hooks
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+
+  def merge(other); end
+  def run(name, payload); end
+
+  class << self
+    def assert_name(name); end
+    def empty; end
+    def load_config(config); end
+    def load_pathname(pathname); end
+  end
+end
+
+class Mutant::Hooks::Builder
+  def initialize; end
+
+  def register(name, &block); end
+  def to_hooks; end
+end
+
+Mutant::Hooks::DEFAULTS = T.let(T.unsafe(nil), Hash)
+Mutant::Hooks::MESSAGE = T.let(T.unsafe(nil), String)
+class Mutant::Hooks::UnknownHook < ::RuntimeError; end
+
+class Mutant::Integration
+  extend ::Unparser::AbstractType::AbstractMethodDeclarations
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  include ::Unparser::AbstractType
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+  include ::Unparser::Anima::InstanceMethods
+
+  def all_tests(*_arg0); end
+  def call(*_arg0); end
+  def expression_parser; end
+  def setup; end
+  def world; end
+
+  private
+
+  def timer; end
+
+  class << self
+    def anima; end
+    def new(*args, &block); end
+    def setup(env); end
+
+    private
+
+    def attempt_const_get(env); end
+    def attempt_require(env); end
+  end
+end
+
+Mutant::Integration::CONST_MESSAGE = T.let(T.unsafe(nil), String)
+Mutant::Integration::INTEGRATION_MISSING = T.let(T.unsafe(nil), String)
+Mutant::Integration::LOAD_MESSAGE = T.let(T.unsafe(nil), String)
+
+class Mutant::Integration::Null < ::Mutant::Integration
+  def all_tests; end
+  def call(_tests); end
+end
+
+class Mutant::Isolation
+  include ::Unparser::AbstractType
+  extend ::Unparser::AbstractType::AbstractMethodDeclarations
+
+  def call(*_arg0); end
+
+  class << self
+    def new(*args, &block); end
+  end
+end
+
+class Mutant::Isolation::Exception
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+
+  def backtrace; end
+  def message; end
+  def original_class; end
+
+  class << self
+    def anima; end
+  end
+end
+
+class Mutant::Isolation::Fork < ::Mutant::Isolation
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+
+  def call(timeout, &block); end
+end
+
+Mutant::Isolation::Fork::ATTRIBUTES = T.let(T.unsafe(nil), Array)
+
+class Mutant::Isolation::Fork::Child
+  extend ::Unparser::Adamantium::ClassMethods
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Mutant::Procto::ClassMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  include ::Mutant::Procto
+
+  def block; end
+  def call; end
+  def deadline; end
+  def log_pipe; end
+  def result_pipe; end
+  def world; end
+
+  class << self
+    def anima; end
+  end
+end
+
+class Mutant::Isolation::Fork::Parent
+  include ::Mutant::Procto
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+  extend ::Mutant::Procto::ClassMethods
+
+  def block; end
+  def call; end
+  def deadline; end
+  def log_pipe; end
+  def result_pipe; end
+  def world; end
+
+  private
+
+  def add_result(result); end
+  def handle_status(status); end
+  def load_result(result_fragments); end
+  def peek_child; end
+  def read_child_result; end
+  def read_fragment(target, fragments); end
+  def read_targets(targets); end
+  def result; end
+  def start_child; end
+  def terminate_graceful; end
+  def terminate_ungraceful; end
+
+  class << self
+    def anima; end
+  end
+end
+
+class Mutant::Isolation::Fork::Pipe
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+
+  def child; end
+  def parent; end
+  def reader; end
+  def writer; end
+
+  class << self
+    def anima; end
+    def with(io); end
+  end
+end
+
+Mutant::Isolation::Fork::READ_SIZE = T.let(T.unsafe(nil), Integer)
+
+class Mutant::Isolation::None < ::Mutant::Isolation
+  def call(_timeout); end
+end
+
+class Mutant::Isolation::Result
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+
+  def exception; end
+  def log; end
+  def process_status; end
+  def timeout; end
+  def valid_value?; end
+  def value; end
+
+  class << self
+    def anima; end
+  end
+end
+
+module Mutant::License
+  class << self
+    def call(world); end
+
+    private
+
+    def check_for_rubygems_mutant_license(message); end
+    def license_path(world); end
+    def load_mutant_license(world); end
+  end
+end
+
+Mutant::License::NAME = T.let(T.unsafe(nil), String)
+
+class Mutant::License::Subscription
+  include ::Unparser::Equalizer::Methods
+
+  def description; end
+
+  private
+
+  def failure(expected, actual); end
+  def failure_message(expected, actual); end
+  def subscription_name; end
+  def success; end
+
+  class << self
+    def load(world, value); end
+  end
+end
+
+class Mutant::License::Subscription::Commercial < ::Mutant::License::Subscription
+  def call(world); end
+
+  private
+
+  def candidates(world); end
+  def capture(world, command); end
+  def commit_author(world); end
+  def git_author(world); end
+
+  class << self
+    def from_json(value); end
+  end
+end
+
+class Mutant::License::Subscription::Commercial::Author
+  include ::Unparser::Equalizer::Methods
+
+  def to_s; end
+end
+
+Mutant::License::Subscription::FAILURE_FORMAT = T.let(T.unsafe(nil), String)
+Mutant::License::Subscription::FORMAT = T.let(T.unsafe(nil), String)
+
+class Mutant::License::Subscription::Opensource < ::Mutant::License::Subscription
+  def call(world); end
+
+  private
+
+  def check_subscription(actual); end
+  def parse_remotes(input); end
+
+  class << self
+    def from_json(value); end
+  end
+end
+
+class Mutant::License::Subscription::Opensource::Repository
+  include ::Unparser::Equalizer::Methods
+
+  def to_s; end
+
+  class << self
+    def parse(input); end
+
+    private
+
+    def parse_remote(input); end
+    def parse_url(input); end
+  end
+end
+
+Mutant::License::Subscription::Opensource::Repository::GIT_HTTPS_REGEXP = T.let(T.unsafe(nil), Regexp)
+Mutant::License::Subscription::Opensource::Repository::GIT_SSH_REGEXP = T.let(T.unsafe(nil), Regexp)
+Mutant::License::Subscription::Opensource::Repository::REMOTE_REGEXP = T.let(T.unsafe(nil), Regexp)
+Mutant::License::VERSION = T.let(T.unsafe(nil), Array)
+
+class Mutant::Loader
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+
+  def binding; end
+  def call; end
+  def kernel; end
+  def source; end
+  def subject; end
+
+  class << self
+    def anima; end
+    def call(*arguments); end
+  end
+end
+
+Mutant::Loader::FROZEN_STRING_FORMAT = T.let(T.unsafe(nil), String)
+
+class Mutant::Loader::Result
+  include ::Singleton
+  extend ::Singleton::SingletonClassMethods
+
+  class << self
+    def instance; end
+  end
+end
+
+class Mutant::Loader::Result::Success < ::Mutant::Loader::Result
+  class << self
+    def instance; end
+  end
+end
+
+class Mutant::Loader::Result::VoidValue < ::Mutant::Loader::Result
+  class << self
+    def instance; end
+  end
+end
+
+Mutant::Loader::VOID_VALUE_REGEXP = T.let(T.unsafe(nil), Regexp)
+
+class Mutant::Matcher
+  include ::Unparser::AbstractType
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::AbstractType::AbstractMethodDeclarations
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+
+  def call(*_arg0); end
+
+  class << self
+    def from_config(config); end
+    def ignore_subject?(config, subject); end
+    def new(*args, &block); end
+
+    private
+
+    def allowed_subject?(config, subject); end
+    def select_subject?(config, subject); end
+  end
+end
+
+class Mutant::Matcher::Chain < ::Mutant::Matcher
+  include ::Unparser::Equalizer::Methods
+
+  def call(env); end
+end
+
+class Mutant::Matcher::Config
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+
+  def add(attribute, value); end
+  def ignore; end
+  def inspect(&block); end
+  def merge(other); end
+  def start_expressions; end
+  def subject_filters; end
+  def subjects; end
+
+  private
+
+  def format_attribute(attribute_name); end
+  def inspect_attributes; end
+  def present_attributes; end
+
+  class << self
+    def anima; end
+  end
+end
+
+Mutant::Matcher::Config::ATTRIBUTE_DELIMITER = T.let(T.unsafe(nil), String)
+Mutant::Matcher::Config::ATTRIBUTE_FORMAT = T.let(T.unsafe(nil), String)
+Mutant::Matcher::Config::DEFAULT = T.let(T.unsafe(nil), Mutant::Matcher::Config)
+Mutant::Matcher::Config::EMPTY_ATTRIBUTES = T.let(T.unsafe(nil), String)
+Mutant::Matcher::Config::ENUM_DELIMITER = T.let(T.unsafe(nil), String)
+Mutant::Matcher::Config::INSPECT_FORMAT = T.let(T.unsafe(nil), String)
+Mutant::Matcher::Config::LOADER = T.let(T.unsafe(nil), Mutant::Transform::Sequence)
+Mutant::Matcher::Config::PRESENTATIONS = T.let(T.unsafe(nil), Hash)
+
+class Mutant::Matcher::Filter < ::Mutant::Matcher
+  include ::Unparser::Equalizer::Methods
+
+  def call(env); end
+end
+
+class Mutant::Matcher::Method < ::Mutant::Matcher
+  include ::Unparser::Equalizer::Methods
+
+  def call(env); end
+
+  class << self
+    def new(*args, &block); end
+  end
+end
+
+Mutant::Matcher::Method::CLOSURE_WARNING_FORMAT = T.let(T.unsafe(nil), String)
+
+class Mutant::Matcher::Method::Evaluator
+  extend ::Unparser::AbstractType::AbstractMethodDeclarations
+  include ::Mutant::Procto
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  include ::Unparser::AbstractType
+  extend ::Mutant::Procto::ClassMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+  include ::Mutant::AST::NodePredicates
+
+  def call; end
+
+  private
+
+  def ast; end
+  def context; end
+  def matched_node_path(&block); end
+  def method_name; end
+  def skip?; end
+  def source_line; end
+  def source_location; end
+  def source_path(&block); end
+  def subject(&block); end
+
+  class << self
+    def new(*args, &block); end
+  end
+end
+
+class Mutant::Matcher::Method::Instance < ::Mutant::Matcher::Method
+  class << self
+    def new(scope, target_method); end
+
+    private
+
+    def memoized_method?(scope, method_name); end
+  end
+end
+
+class Mutant::Matcher::Method::Instance::Evaluator < ::Mutant::Matcher::Method::Evaluator
+  private
+
+  def match?(node); end
+end
+
+class Mutant::Matcher::Method::Instance::Evaluator::Memoized < ::Mutant::Matcher::Method::Instance::Evaluator
+  private
+
+  def source_location; end
+end
+
+Mutant::Matcher::Method::Instance::Evaluator::Memoized::SUBJECT_CLASS = Mutant::Subject::Method::Instance::Memoized
+Mutant::Matcher::Method::Instance::Evaluator::NAME_INDEX = T.let(T.unsafe(nil), Integer)
+Mutant::Matcher::Method::Instance::Evaluator::SUBJECT_CLASS = Mutant::Subject::Method::Instance
+
+class Mutant::Matcher::Method::Metaclass < ::Mutant::Matcher::Method
+  class << self
+    def new(scope, method_name); end
+  end
+end
+
+class Mutant::Matcher::Method::Metaclass::Evaluator < ::Mutant::Matcher::Method::Evaluator
+  private
+
+  def line?(node); end
+  def match?(node); end
+  def metaclass_containing(node); end
+  def metaclass_receiver?(node); end
+  def metaclass_target?(node); end
+  def name?(node); end
+  def sclass_const_name?(node); end
+end
+
+Mutant::Matcher::Method::Metaclass::Evaluator::CONST_NAME_INDEX = T.let(T.unsafe(nil), Integer)
+Mutant::Matcher::Method::Metaclass::Evaluator::NAME_INDEX = T.let(T.unsafe(nil), Integer)
+Mutant::Matcher::Method::Metaclass::Evaluator::RECEIVER_WARNING = T.let(T.unsafe(nil), String)
+Mutant::Matcher::Method::Metaclass::Evaluator::SCLASS_RECEIVER_INDEX = T.let(T.unsafe(nil), Integer)
+Mutant::Matcher::Method::Metaclass::Evaluator::SUBJECT_CLASS = Mutant::Subject::Method::Metaclass
+Mutant::Matcher::Method::SOURCE_LOCATION_WARNING_FORMAT = T.let(T.unsafe(nil), String)
+
+class Mutant::Matcher::Method::Singleton < ::Mutant::Matcher::Method
+  class << self
+    def new(scope, method_name); end
+  end
+end
+
+class Mutant::Matcher::Method::Singleton::Evaluator < ::Mutant::Matcher::Method::Evaluator
+  private
+
+  def line?(node); end
+  def match?(node); end
+  def name?(node); end
+  def receiver?(node); end
+  def receiver_name?(node); end
+end
+
+Mutant::Matcher::Method::Singleton::Evaluator::NAME_INDEX = T.let(T.unsafe(nil), Integer)
+Mutant::Matcher::Method::Singleton::Evaluator::RECEIVER_INDEX = T.let(T.unsafe(nil), Integer)
+Mutant::Matcher::Method::Singleton::Evaluator::RECEIVER_WARNING = T.let(T.unsafe(nil), String)
+Mutant::Matcher::Method::Singleton::Evaluator::SUBJECT_CLASS = Mutant::Subject::Method::Singleton
+
+class Mutant::Matcher::Methods < ::Mutant::Matcher
+  include ::Unparser::Equalizer::Methods
+
+  def call(env); end
+
+  private
+
+  def candidate_names; end
+  def candidate_scope(*_arg0); end
+  def matcher; end
+  def methods(&block); end
+
+  class << self
+    def new(*args, &block); end
+  end
+end
+
+Mutant::Matcher::Methods::CANDIDATE_NAMES = T.let(T.unsafe(nil), Array)
+
+class Mutant::Matcher::Methods::Instance < ::Mutant::Matcher::Methods
+  private
+
+  def access(method_name); end
+  def candidate_scope; end
+end
+
+Mutant::Matcher::Methods::Instance::MATCHER = Mutant::Matcher::Method::Instance
+
+class Mutant::Matcher::Methods::Metaclass < ::Mutant::Matcher::Methods
+  private
+
+  def access(method_name); end
+  def candidate_scope; end
+end
+
+Mutant::Matcher::Methods::Metaclass::MATCHER = Mutant::Matcher::Method::Metaclass
+
+class Mutant::Matcher::Methods::Singleton < ::Mutant::Matcher::Methods
+  private
+
+  def access(method_name); end
+  def candidate_scope; end
+end
+
+Mutant::Matcher::Methods::Singleton::MATCHER = Mutant::Matcher::Method::Singleton
+
+class Mutant::Matcher::Namespace < ::Mutant::Matcher
+  include ::Unparser::Equalizer::Methods
+
+  def call(env); end
+
+  private
+
+  def match?(scope); end
+  def matched_scopes(env); end
+end
+
+class Mutant::Matcher::Null < ::Mutant::Matcher
+  include ::Unparser::Equalizer::Methods
+
+  def call(_env); end
+end
+
+class Mutant::Matcher::Scope < ::Mutant::Matcher
+  include ::Unparser::Equalizer::Methods
+
+  def call(env); end
+
+  private
+
+  def effective_matchers; end
+end
+
+Mutant::Matcher::Scope::MATCHERS = T.let(T.unsafe(nil), Array)
+
+class Mutant::Matcher::Static
+  include ::Unparser::Equalizer::Methods
+
+  def call(_env); end
+end
+
+class Mutant::Mutation
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  include ::Unparser::AbstractType
+  include ::Unparser::Equalizer::Methods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+  extend ::Unparser::AbstractType::AbstractMethodDeclarations
+
+  def code(&block); end
+  def identification(&block); end
+  def insert(kernel); end
+  def monkeypatch(&block); end
+  def original_source; end
+  def source(&block); end
+
+  private
+
+  def sha1; end
+
+  class << self
+    def new(*args, &block); end
+    def success?(test_result); end
+  end
+end
+
+Mutant::Mutation::CODE_DELIMITER = T.let(T.unsafe(nil), String)
+Mutant::Mutation::CODE_RANGE = T.let(T.unsafe(nil), Range)
+class Mutant::Mutation::Evil < ::Mutant::Mutation; end
+Mutant::Mutation::Evil::SYMBOL = T.let(T.unsafe(nil), String)
+class Mutant::Mutation::Neutral < ::Mutant::Mutation; end
+Mutant::Mutation::Neutral::SYMBOL = T.let(T.unsafe(nil), String)
+Mutant::Mutation::Neutral::TEST_PASS_SUCCESS = T.let(T.unsafe(nil), TrueClass)
+class Mutant::Mutation::Noop < ::Mutant::Mutation::Neutral; end
+Mutant::Mutation::Noop::SYMBOL = T.let(T.unsafe(nil), String)
+Mutant::Mutation::Noop::TEST_PASS_SUCCESS = T.let(T.unsafe(nil), TrueClass)
+
+class Mutant::Mutator
+  extend ::Unparser::Adamantium::ClassMethods
+  include ::Unparser::AbstractType
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Mutant::Procto::ClassMethods
+  extend ::Unparser::AbstractType::AbstractMethodDeclarations
+  extend ::Unparser::Adamantium::ModuleMethods
+  include ::Mutant::Procto
+
+  def initialize(_input, _parent = T.unsafe(nil)); end
+
+  def call; end
+  def output; end
+
+  private
+
+  def dispatch(*_arg0); end
+  def dup_input; end
+  def emit(object); end
+  def new?(object); end
+  def run(mutator); end
+
+  class << self
+    def mutate(node, parent = T.unsafe(nil)); end
+    def new(*args, &block); end
+
+    private
+
+    def handle(*types); end
+  end
+end
+
+class Mutant::Mutator::Node < ::Mutant::Mutator
+  include ::Unparser::Constants
+  include ::Mutant::AST::Nodes
+  include ::Mutant::AST::Sexp
+  include ::Mutant::AST::NodePredicates
+  include ::Mutant::AST::NamedChildren
+  include ::Mutant::AST::NamedChildren::InstanceMethods
+  extend ::Mutant::AST::NamedChildren::ClassMethods
+
+  protected
+
+  def node; end
+
+  private
+
+  def children_indices(range); end
+  def delete_child(index); end
+  def dup_node; end
+  def emit_child_update(index, node); end
+  def emit_nil; end
+  def emit_propagation(node); end
+  def emit_singletons; end
+  def emit_type(*children); end
+  def left_op_assignment?; end
+  def mutate_child(index, &block); end
+  def mutate_single_child; end
+  def parent_node; end
+  def parent_type; end
+
+  class << self
+    def new(*args, &block); end
+
+    private
+
+    def define_named_child(name, index); end
+  end
+end
+
+class Mutant::Mutator::Node::AndAsgn < ::Mutant::Mutator::Node
+  def emit_left(node); end
+  def emit_left_mutations(&block); end
+  def emit_right(node); end
+  def emit_right_mutations(&block); end
+
+  private
+
+  def dispatch; end
+  def left; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+  def right; end
+end
+
+class Mutant::Mutator::Node::Argument < ::Mutant::Mutator::Node
+  def emit_name(node); end
+  def emit_name_mutations(&block); end
+
+  private
+
+  def dispatch; end
+  def emit_name_mutation; end
+  def name; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+  def skip?; end
+end
+
+class Mutant::Mutator::Node::Argument::Optional < ::Mutant::Mutator::Node::Argument
+  def emit_default(node); end
+  def emit_default_mutations(&block); end
+  def emit_name(node); end
+  def emit_name_mutations(&block); end
+
+  private
+
+  def default; end
+  def dispatch; end
+  def emit_required_mutation; end
+  def name; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+Mutant::Mutator::Node::Argument::Optional::TYPE_MAP = T.let(T.unsafe(nil), Hash)
+Mutant::Mutator::Node::Argument::UNDERSCORE = T.let(T.unsafe(nil), String)
+
+class Mutant::Mutator::Node::Arguments < ::Mutant::Mutator::Node
+  private
+
+  def dispatch; end
+  def emit_argument_mutations; end
+  def emit_argument_presence; end
+  def emit_mlhs_expansion; end
+  def invalid_argument_replacement?(mutant, index); end
+  def mlhs_childs_with_index; end
+end
+
+class Mutant::Mutator::Node::Begin < ::Mutant::Mutator::Node
+  private
+
+  def dispatch; end
+end
+
+class Mutant::Mutator::Node::Binary < ::Mutant::Mutator::Node
+  def emit_left(node); end
+  def emit_left_mutations(&block); end
+  def emit_right(node); end
+  def emit_right_mutations(&block); end
+
+  private
+
+  def dispatch; end
+  def emit_left_negation; end
+  def emit_operator_mutations; end
+  def emit_promotions; end
+  def left; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+  def right; end
+end
+
+Mutant::Mutator::Node::Binary::INVERSE = T.let(T.unsafe(nil), Hash)
+
+class Mutant::Mutator::Node::Block < ::Mutant::Mutator::Node
+  def emit_arguments(node); end
+  def emit_arguments_mutations(&block); end
+  def emit_body(node); end
+  def emit_body_mutations(&block); end
+  def emit_send(node); end
+  def emit_send_mutations(&block); end
+
+  private
+
+  def arguments; end
+  def body; end
+  def body_has_control?; end
+  def dispatch; end
+  def mutate_body; end
+  def mutate_body_receiver; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+  def send; end
+  def unconditional_loop?; end
+  def valid_send_mutation?(node); end
+end
+
+class Mutant::Mutator::Node::BlockPass < ::Mutant::Mutator::Node
+  def emit_argument(node); end
+  def emit_argument_mutations(&block); end
+
+  private
+
+  def argument; end
+  def dispatch; end
+  def emit_symbol_to_proc_mutations; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+class Mutant::Mutator::Node::Break < ::Mutant::Mutator::Node::Generic
+  private
+
+  def dispatch; end
+end
+
+class Mutant::Mutator::Node::Case < ::Mutant::Mutator::Node
+  def emit_condition(node); end
+  def emit_condition_mutations(&block); end
+
+  private
+
+  def condition; end
+  def dispatch; end
+  def emit_else_mutations; end
+  def emit_when_mutations; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+class Mutant::Mutator::Node::Class < ::Mutant::Mutator::Node
+  def emit_body(node); end
+  def emit_body_mutations(&block); end
+  def emit_klass(node); end
+  def emit_klass_mutations(&block); end
+  def emit_parent(node); end
+  def emit_parent_mutations(&block); end
+
+  private
+
+  def body; end
+  def dispatch; end
+  def klass; end
+  def parent; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+class Mutant::Mutator::Node::ConditionalLoop < ::Mutant::Mutator::Node
+  def emit_body(node); end
+  def emit_body_mutations(&block); end
+  def emit_condition(node); end
+  def emit_condition_mutations(&block); end
+
+  private
+
+  def body; end
+  def condition; end
+  def dispatch; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+class Mutant::Mutator::Node::Const < ::Mutant::Mutator::Node
+  private
+
+  def dispatch; end
+end
+
+class Mutant::Mutator::Node::Define < ::Mutant::Mutator::Node
+  private
+
+  def dispatch; end
+  def emit_body_prepend(node); end
+  def emit_optarg_body_assignments; end
+end
+
+class Mutant::Mutator::Node::Define::Instance < ::Mutant::Mutator::Node::Define
+  def emit_arguments(node); end
+  def emit_arguments_mutations(&block); end
+  def emit_body(node); end
+  def emit_body_mutations(&block); end
+  def emit_name(node); end
+  def emit_name_mutations(&block); end
+
+  private
+
+  def arguments; end
+  def body; end
+  def name; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+class Mutant::Mutator::Node::Define::Singleton < ::Mutant::Mutator::Node::Define
+  def emit_arguments(node); end
+  def emit_arguments_mutations(&block); end
+  def emit_body(node); end
+  def emit_body_mutations(&block); end
+  def emit_name(node); end
+  def emit_name_mutations(&block); end
+  def emit_subject(node); end
+  def emit_subject_mutations(&block); end
+
+  private
+
+  def arguments; end
+  def body; end
+  def name; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+  def subject; end
+end
+
+class Mutant::Mutator::Node::Defined < ::Mutant::Mutator::Node
+  def emit_expression(node); end
+  def emit_expression_mutations(&block); end
+
+  private
+
+  def dispatch; end
+  def emit_instance_variable_mutation; end
+  def expression; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+class Mutant::Mutator::Node::DynamicLiteral < ::Mutant::Mutator::Node
+  private
+
+  def dispatch; end
+end
+
+class Mutant::Mutator::Node::Generic < ::Mutant::Mutator::Node
+  private
+
+  def dispatch; end
+end
+
+class Mutant::Mutator::Node::If < ::Mutant::Mutator::Node
+  def emit_condition(node); end
+  def emit_condition_mutations(&block); end
+  def emit_else_branch(node); end
+  def emit_else_branch_mutations(&block); end
+  def emit_if_branch(node); end
+  def emit_if_branch_mutations(&block); end
+
+  private
+
+  def condition; end
+  def dispatch; end
+  def else_branch; end
+  def if_branch; end
+  def mutate_condition; end
+  def mutate_else_branch; end
+  def mutate_if_branch; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+class Mutant::Mutator::Node::Index < ::Mutant::Mutator::Node
+  def emit_receiver(node); end
+  def emit_receiver_mutations(&block); end
+
+  private
+
+  def dispatch; end
+  def emit_drop_mutation; end
+  def emit_send_forms; end
+  def indices; end
+  def mutate_indices; end
+  def receiver; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+class Mutant::Mutator::Node::Index::Assign < ::Mutant::Mutator::Node::Index
+  private
+
+  def dispatch; end
+  def emit_index_read; end
+  def index_range; end
+end
+
+Mutant::Mutator::Node::Index::Assign::REGULAR_RANGE = T.let(T.unsafe(nil), Range)
+Mutant::Mutator::Node::Index::NO_VALUE_RANGE = T.let(T.unsafe(nil), Range)
+
+class Mutant::Mutator::Node::Index::Read < ::Mutant::Mutator::Node::Index
+  private
+
+  def index_range; end
+end
+
+Mutant::Mutator::Node::Index::SEND_REPLACEMENTS = T.let(T.unsafe(nil), Array)
+
+class Mutant::Mutator::Node::Kwargs < ::Mutant::Mutator::Node
+  private
+
+  def dispatch; end
+  def emit_argument_mutations; end
+  def emit_argument_presence; end
+  def forbid_argument?(node); end
+end
+
+Mutant::Mutator::Node::Kwargs::DISALLOW = T.let(T.unsafe(nil), Array)
+
+class Mutant::Mutator::Node::Kwbegin < ::Mutant::Mutator::Node::Generic
+  private
+
+  def dispatch; end
+end
+
+class Mutant::Mutator::Node::Literal < ::Mutant::Mutator::Node
+  private
+
+  def emit_values; end
+
+  class << self
+    def new(*args, &block); end
+  end
+end
+
+class Mutant::Mutator::Node::Literal::Array < ::Mutant::Mutator::Node::Literal
+  def emit_first(node); end
+  def emit_first_mutations(&block); end
+
+  private
+
+  def dispatch; end
+  def first; end
+  def mutate_body; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+class Mutant::Mutator::Node::Literal::Boolean < ::Mutant::Mutator::Node::Literal
+  private
+
+  def dispatch; end
+end
+
+Mutant::Mutator::Node::Literal::Boolean::MAP = T.let(T.unsafe(nil), Hash)
+
+class Mutant::Mutator::Node::Literal::Float < ::Mutant::Mutator::Node::Literal
+  private
+
+  def dispatch; end
+  def emit_special_cases; end
+  def values; end
+end
+
+Mutant::Mutator::Node::Literal::Float::SPECIAL = T.let(T.unsafe(nil), Array)
+
+class Mutant::Mutator::Node::Literal::Hash < ::Mutant::Mutator::Node::Literal
+  private
+
+  def dispatch; end
+  def mutate_body; end
+end
+
+class Mutant::Mutator::Node::Literal::Hash::Pair < ::Mutant::Mutator::Node
+  def emit_key(node); end
+  def emit_key_mutations(&block); end
+  def emit_value(node); end
+  def emit_value_mutations(&block); end
+
+  private
+
+  def dispatch; end
+  def key; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+  def value; end
+end
+
+class Mutant::Mutator::Node::Literal::Integer < ::Mutant::Mutator::Node::Literal
+  def emit_value(node); end
+  def emit_value_mutations(&block); end
+
+  private
+
+  def dispatch; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+  def value; end
+  def values; end
+end
+
+class Mutant::Mutator::Node::Literal::Nil < ::Mutant::Mutator::Node::Literal
+  private
+
+  def dispatch; end
+end
+
+class Mutant::Mutator::Node::Literal::Range < ::Mutant::Mutator::Node::Literal
+  def emit_lower_bound(node); end
+  def emit_lower_bound_mutations(&block); end
+  def emit_upper_bound(node); end
+  def emit_upper_bound_mutations(&block); end
+
+  private
+
+  def dispatch; end
+  def emit_inverse; end
+  def lower_bound; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+  def upper_bound; end
+end
+
+Mutant::Mutator::Node::Literal::Range::MAP = T.let(T.unsafe(nil), Hash)
+
+class Mutant::Mutator::Node::Literal::Regex < ::Mutant::Mutator::Node::Literal
+  private
+
+  def dispatch; end
+  def mutate_body; end
+  def options; end
+end
+
+Mutant::Mutator::Node::Literal::Regex::NULL_REGEXP_SOURCE = T.let(T.unsafe(nil), String)
+
+class Mutant::Mutator::Node::Literal::String < ::Mutant::Mutator::Node::Literal
+  private
+
+  def dispatch; end
+end
+
+class Mutant::Mutator::Node::Literal::Symbol < ::Mutant::Mutator::Node::Literal
+  def emit_value(node); end
+  def emit_value_mutations(&block); end
+
+  private
+
+  def dispatch; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+  def value; end
+end
+
+class Mutant::Mutator::Node::MLHS < ::Mutant::Mutator::Node
+  private
+
+  def dispatch; end
+end
+
+class Mutant::Mutator::Node::MatchCurrentLine < ::Mutant::Mutator::Node
+  def emit_regexp(node); end
+  def emit_regexp_mutations(&block); end
+
+  private
+
+  def dispatch; end
+  def regexp; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+class Mutant::Mutator::Node::Module < ::Mutant::Mutator::Node
+  def emit_body(node); end
+  def emit_body_mutations(&block); end
+  def emit_klass(node); end
+  def emit_klass_mutations(&block); end
+
+  private
+
+  def body; end
+  def dispatch; end
+  def klass; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+class Mutant::Mutator::Node::MultipleAssignment < ::Mutant::Mutator::Node
+  def emit_left(node); end
+  def emit_left_mutations(&block); end
+  def emit_right(node); end
+  def emit_right_mutations(&block); end
+
+  private
+
+  def dispatch; end
+  def left; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+  def right; end
+end
+
+module Mutant::Mutator::Node::NamedValue; end
+
+class Mutant::Mutator::Node::NamedValue::Access < ::Mutant::Mutator::Node
+  private
+
+  def dispatch; end
+end
+
+class Mutant::Mutator::Node::NamedValue::Access::Ivar < ::Mutant::Mutator::Node::NamedValue::Access
+  def emit_name(node); end
+  def emit_name_mutations(&block); end
+
+  private
+
+  def attribute_name; end
+  def dispatch; end
+  def emit_attribute_read; end
+  def name; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+Mutant::Mutator::Node::NamedValue::Access::Ivar::NAME_RANGE = T.let(T.unsafe(nil), Range)
+
+class Mutant::Mutator::Node::NamedValue::ConstantAssignment < ::Mutant::Mutator::Node
+  def emit_cbase(node); end
+  def emit_cbase_mutations(&block); end
+  def emit_name(node); end
+  def emit_name_mutations(&block); end
+  def emit_value(node); end
+  def emit_value_mutations(&block); end
+
+  private
+
+  def cbase; end
+  def dispatch; end
+  def emit_remove_const; end
+  def mutate_name; end
+  def name; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+  def value; end
+end
+
+class Mutant::Mutator::Node::NamedValue::VariableAssignment < ::Mutant::Mutator::Node
+  def emit_name(node); end
+  def emit_name_mutations(&block); end
+  def emit_value(node); end
+  def emit_value_mutations(&block); end
+
+  private
+
+  def dispatch; end
+  def mutate_name; end
+  def name; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+  def value; end
+end
+
+Mutant::Mutator::Node::NamedValue::VariableAssignment::MAP = T.let(T.unsafe(nil), Hash)
+
+class Mutant::Mutator::Node::Next < ::Mutant::Mutator::Node::Generic
+  private
+
+  def dispatch; end
+end
+
+class Mutant::Mutator::Node::Noop < ::Mutant::Mutator::Node
+  private
+
+  def dispatch; end
+end
+
+class Mutant::Mutator::Node::NthRef < ::Mutant::Mutator::Node
+  def emit_number(node); end
+  def emit_number_mutations(&block); end
+
+  private
+
+  def dispatch; end
+  def number; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+class Mutant::Mutator::Node::OpAsgn < ::Mutant::Mutator::Node
+  def emit_left(node); end
+  def emit_left_mutations(&block); end
+  def emit_operation(node); end
+  def emit_operation_mutations(&block); end
+  def emit_right(node); end
+  def emit_right_mutations(&block); end
+
+  private
+
+  def dispatch; end
+  def emit_left_promotion; end
+  def left; end
+  def left_mutations; end
+  def operation; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+  def right; end
+end
+
+class Mutant::Mutator::Node::OrAsgn < ::Mutant::Mutator::Node
+  def emit_left(node); end
+  def emit_left_mutations(&block); end
+  def emit_right(node); end
+  def emit_right_mutations(&block); end
+
+  private
+
+  def dispatch; end
+  def left; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+  def right; end
+end
+
+class Mutant::Mutator::Node::ProcargZero < ::Mutant::Mutator::Node
+  def emit_argument(node); end
+  def emit_argument_mutations(&block); end
+
+  private
+
+  def argument; end
+  def dispatch; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+module Mutant::Mutator::Node::Regexp; end
+
+class Mutant::Mutator::Node::Regexp::AlternationMeta < ::Mutant::Mutator::Node
+  private
+
+  def dispatch; end
+end
+
+class Mutant::Mutator::Node::Regexp::BeginningOfLineAnchor < ::Mutant::Mutator::Node
+  private
+
+  def dispatch; end
+end
+
+class Mutant::Mutator::Node::Regexp::CaptureGroup < ::Mutant::Mutator::Node
+  def emit_group(node); end
+  def emit_group_mutations(&block); end
+
+  private
+
+  def dispatch; end
+  def group; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+class Mutant::Mutator::Node::Regexp::CharacterType < ::Mutant::Mutator::Node
+  private
+
+  def dispatch; end
+end
+
+Mutant::Mutator::Node::Regexp::CharacterType::MAP = T.let(T.unsafe(nil), Hash)
+
+class Mutant::Mutator::Node::Regexp::EndOfLineAnchor < ::Mutant::Mutator::Node
+  private
+
+  def dispatch; end
+end
+
+class Mutant::Mutator::Node::Regexp::EndOfStringOrBeforeEndOfLineAnchor < ::Mutant::Mutator::Node
+  private
+
+  def dispatch; end
+end
+
+class Mutant::Mutator::Node::Regexp::NamedGroup < ::Mutant::Mutator::Node
+  def emit_group(node); end
+  def emit_group_mutations(&block); end
+  def emit_name(node); end
+  def emit_name_mutations(&block); end
+
+  private
+
+  def dispatch; end
+  def emit_name_underscore_mutation; end
+  def group; end
+  def name; end
+  def name_underscored?; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+class Mutant::Mutator::Node::Regexp::RootExpression < ::Mutant::Mutator::Node
+  private
+
+  def dispatch; end
+end
+
+class Mutant::Mutator::Node::Regexp::ZeroOrMore < ::Mutant::Mutator::Node
+  def emit_max(node); end
+  def emit_max_mutations(&block); end
+  def emit_min(node); end
+  def emit_min_mutations(&block); end
+  def emit_subject(node); end
+  def emit_subject_mutations(&block); end
+
+  private
+
+  def dispatch; end
+  def max; end
+  def min; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+  def subject; end
+end
+
+Mutant::Mutator::Node::Regexp::ZeroOrMore::MAP = T.let(T.unsafe(nil), Hash)
+
+class Mutant::Mutator::Node::Regopt < ::Mutant::Mutator::Node
+  private
+
+  def dispatch; end
+  def mutated_flags; end
+end
+
+Mutant::Mutator::Node::Regopt::MUTATED_FLAGS = T.let(T.unsafe(nil), Array)
+
+class Mutant::Mutator::Node::Resbody < ::Mutant::Mutator::Node
+  def emit_assignment(node); end
+  def emit_assignment_mutations(&block); end
+  def emit_body(node); end
+  def emit_body_mutations(&block); end
+  def emit_captures(node); end
+  def emit_captures_mutations(&block); end
+
+  private
+
+  def assignment; end
+  def body; end
+  def captures; end
+  def dispatch; end
+  def mutate_captures; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+class Mutant::Mutator::Node::Rescue < ::Mutant::Mutator::Node
+  def emit_body(node); end
+  def emit_body_mutations(&block); end
+  def emit_else_body(node); end
+  def emit_else_body_mutations(&block); end
+
+  private
+
+  def body; end
+  def dispatch; end
+  def else_body; end
+  def emit_concat(child); end
+  def mutate_body; end
+  def mutate_else_body; end
+  def mutate_rescue_bodies; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+Mutant::Mutator::Node::Rescue::RESCUE_INDICES = T.let(T.unsafe(nil), Range)
+
+class Mutant::Mutator::Node::Return < ::Mutant::Mutator::Node
+  def emit_value(node); end
+  def emit_value_mutations(&block); end
+
+  private
+
+  def dispatch; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+  def value; end
+end
+
+class Mutant::Mutator::Node::Sclass < ::Mutant::Mutator::Node
+  def emit_body(node); end
+  def emit_body_mutations(&block); end
+  def emit_expr(node); end
+  def emit_expr_mutations(&block); end
+
+  private
+
+  def body; end
+  def dispatch; end
+  def expr; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+class Mutant::Mutator::Node::Send < ::Mutant::Mutator::Node
+  include ::Mutant::AST::Types
+
+  def emit_receiver(node); end
+  def emit_receiver_mutations(&block); end
+  def emit_selector(node); end
+  def emit_selector_mutations(&block); end
+
+  private
+
+  def arguments; end
+  def dispatch; end
+  def emit_argument_propagation; end
+  def emit_array_mutation; end
+  def emit_const_get_mutation; end
+  def emit_dig_mutation; end
+  def emit_double_negation_mutation; end
+  def emit_end_with(regexp_nodes); end
+  def emit_explicit_self; end
+  def emit_implicit_self; end
+  def emit_integer_mutation; end
+  def emit_lambda_mutation; end
+  def emit_naked_receiver; end
+  def emit_predicate_mutations; end
+  def emit_receiver_selector_mutations; end
+  def emit_reduce_to_sum_mutation; end
+  def emit_selector_replacement; end
+  def emit_selector_specific_mutations; end
+  def emit_start_end_with_mutations; end
+  def emit_start_with(regexp_nodes); end
+  def emit_static_send; end
+  def meta(&block); end
+  def mutate_argument_index(index); end
+  def mutate_arguments; end
+  def mutate_receiver; end
+  def normal_dispatch; end
+  def possible_kernel_method?; end
+  def receiver; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+  def selector; end
+end
+
+class Mutant::Mutator::Node::Send::AttributeAssignment < ::Mutant::Mutator::Node::Send
+  private
+
+  def dispatch; end
+  def emit_attribute_read; end
+  def mutate_arguments; end
+end
+
+Mutant::Mutator::Node::Send::AttributeAssignment::ATTRIBUTE_RANGE = T.let(T.unsafe(nil), Range)
+
+class Mutant::Mutator::Node::Send::Binary < ::Mutant::Mutator::Node::Send
+  def emit_left(node); end
+  def emit_left_mutations(&block); end
+  def emit_operator(node); end
+  def emit_operator_mutations(&block); end
+  def emit_right(node); end
+  def emit_right_mutations(&block); end
+
+  private
+
+  def dispatch; end
+  def emit_not_equality_mutation(new_operator); end
+  def emit_not_equality_mutations; end
+  def left; end
+  def operator; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+  def right; end
+end
+
+class Mutant::Mutator::Node::Send::Conditional < ::Mutant::Mutator::Node::Send
+  private
+
+  def dispatch; end
+end
+
+Mutant::Mutator::Node::Send::RECEIVER_SELECTOR_REPLACEMENTS = T.let(T.unsafe(nil), Hash)
+Mutant::Mutator::Node::Send::REGEXP_END_WITH_NODES = T.let(T.unsafe(nil), Array)
+Mutant::Mutator::Node::Send::REGEXP_MATCH_METHODS = T.let(T.unsafe(nil), Array)
+Mutant::Mutator::Node::Send::REGEXP_START_WITH_NODES = T.let(T.unsafe(nil), Array)
+Mutant::Mutator::Node::Send::SELECTOR_REPLACEMENTS = T.let(T.unsafe(nil), Hash)
+
+class Mutant::Mutator::Node::Splat < ::Mutant::Mutator::Node
+  def emit_expression(node); end
+  def emit_expression_mutations(&block); end
+
+  private
+
+  def dispatch; end
+  def expression; end
+  def remaining_children; end
+  def remaining_children_indices; end
+  def remaining_children_with_index; end
+end
+
+class Mutant::Mutator::Node::Super < ::Mutant::Mutator::Node
+  private
+
+  def dispatch; end
+end
+
+Mutant::Mutator::Node::TAUTOLOGY = T.let(T.unsafe(nil), Proc)
+
+class Mutant::Mutator::Node::When < ::Mutant::Mutator::Node
+  private
+
+  def body; end
+  def body_index; end
+  def dispatch; end
+  def mutate_body; end
+  def mutate_conditions; end
+end
+
+class Mutant::Mutator::Node::Yield < ::Mutant::Mutator::Node::Generic
+  private
+
+  def dispatch; end
+end
+
+class Mutant::Mutator::Node::ZSuper < ::Mutant::Mutator::Node
+  private
+
+  def dispatch; end
+end
+
+Mutant::Mutator::REGISTRY = T.let(T.unsafe(nil), Mutant::Registry)
+class Mutant::Mutator::Util < ::Mutant::Mutator; end
+class Mutant::Mutator::Util::Array < ::Mutant::Mutator::Util; end
+
+class Mutant::Mutator::Util::Array::Element < ::Mutant::Mutator::Util
+  private
+
+  def dispatch; end
+end
+
+class Mutant::Mutator::Util::Array::Presence < ::Mutant::Mutator::Util
+  private
+
+  def dispatch; end
+end
+
+class Mutant::Mutator::Util::Symbol < ::Mutant::Mutator::Util
+  private
+
+  def dispatch; end
+end
+
+Mutant::Mutator::Util::Symbol::POSTFIX = T.let(T.unsafe(nil), String)
+
+module Mutant::Parallel
+  class << self
+    def async(world, config); end
+
+    private
+
+    def shared(klass, world, **attributes); end
+    def shared_state(world, config); end
+    def threads(world, config, workers); end
+    def workers(world, config, shared); end
+  end
+end
+
+class Mutant::Parallel::Config
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+
+  def block; end
+  def jobs; end
+  def process_name; end
+  def sink; end
+  def source; end
+  def thread_name; end
+
+  class << self
+    def anima; end
+  end
+end
+
+class Mutant::Parallel::Driver
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+
+  def wait_timeout(timeout); end
+
+  private
+
+  def finalize(status); end
+  def status; end
+  def threads; end
+  def var_active_jobs; end
+  def var_final; end
+  def var_running; end
+  def var_sink; end
+  def var_source; end
+  def workers; end
+
+  class << self
+    def anima; end
+  end
+end
+
+class Mutant::Parallel::Sink
+  include ::Unparser::AbstractType
+  extend ::Unparser::AbstractType::AbstractMethodDeclarations
+
+  def result(*_arg0); end
+  def status(*_arg0); end
+  def stop?(*_arg0); end
+
+  class << self
+    def new(*args, &block); end
+  end
+end
+
+class Mutant::Parallel::Source
+  include ::Unparser::AbstractType
+  extend ::Unparser::AbstractType::AbstractMethodDeclarations
+
+  def next(*_arg0); end
+  def next?(*_arg0); end
+
+  class << self
+    def new(*args, &block); end
+  end
+end
+
+class Mutant::Parallel::Source::Array
+  include ::Unparser::Equalizer::Methods
+
+  def initialize(*_arg0); end
+
+  def next; end
+  def next?; end
+end
+
+class Mutant::Parallel::Source::Job
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+
+  def index; end
+  def payload; end
+
+  class << self
+    def anima; end
+  end
+end
+
+class Mutant::Parallel::Source::NoJobError < ::RuntimeError; end
+
+class Mutant::Parallel::Status
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+
+  def active_jobs; end
+  def done; end
+  def done?; end
+  def payload; end
+
+  class << self
+    def anima; end
+  end
+end
+
+class Mutant::Parallel::Worker
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+
+  def call; end
+  def index; end
+  def join; end
+
+  private
+
+  def add_result(result); end
+  def connection; end
+  def finalize; end
+  def job_done(job); end
+  def job_start(job); end
+  def next_job; end
+  def pid; end
+  def process; end
+  def var_active_jobs; end
+  def var_final; end
+  def var_running; end
+  def var_sink; end
+  def var_source; end
+
+  class << self
+    def anima; end
+    def start(world:, block:, process_name:, **attributes); end
+  end
+end
+
+class Mutant::Parallel::Worker::Child
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+
+  def block; end
+  def call; end
+  def connection; end
+
+  class << self
+    def anima; end
+  end
+end
+
+class Mutant::Parser
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+
+  def initialize; end
+
+  def call(path); end
+end
+
+class Mutant::Pipe
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+
+  def reader; end
+  def to_reader; end
+  def to_writer; end
+  def writer; end
+
+  class << self
+    def anima; end
+    def from_io(io); end
+    def with(io); end
+  end
+end
+
+class Mutant::Pipe::Connection
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+
+  def call(payload); end
+  def marshal; end
+  def reader; end
+  def receive_value; end
+  def send_value(value); end
+  def writer; end
+
+  class << self
+    def anima; end
+    def from_pipes(marshal:, reader:, writer:); end
+  end
+end
+
+class Mutant::Pipe::Connection::Error < ::RuntimeError; end
+
+class Mutant::Pipe::Connection::Frame
+  include ::Unparser::Equalizer::Methods
+
+  def receive_value; end
+  def send_value(body); end
+
+  private
+
+  def read(bytes); end
+end
+
+Mutant::Pipe::Connection::Frame::HEADER_FORMAT = T.let(T.unsafe(nil), String)
+Mutant::Pipe::Connection::Frame::HEADER_SIZE = T.let(T.unsafe(nil), Integer)
+Mutant::Pipe::Connection::Frame::MAX_BYTES = T.let(T.unsafe(nil), Integer)
+
+module Mutant::Procto
+  mixes_in_class_methods ::Mutant::Procto::ClassMethods
+
+  class << self
+    def included(host); end
+  end
+end
+
+module Mutant::Procto::ClassMethods
+  def call(*arguments); end
+end
+
+module Mutant::Range
+  class << self
+    def overlap?(left, right); end
+  end
+end
+
+class Mutant::Registry
+  include ::Unparser::Equalizer::Methods
+
+  def initialize(default); end
+
+  def lookup(type); end
+  def register(type, klass); end
+end
+
+class Mutant::Registry::RegistryError < ::TypeError; end
+
+class Mutant::Reporter
+  include ::Unparser::AbstractType
+  extend ::Unparser::AbstractType::AbstractMethodDeclarations
+
+  def delay(*_arg0); end
+  def progress(*_arg0); end
+  def report(*_arg0); end
+  def start(*_arg0); end
+  def warn(*_arg0); end
+
+  class << self
+    def new(*args, &block); end
+  end
+end
+
+class Mutant::Reporter::CLI < ::Mutant::Reporter
+  include ::Unparser::Equalizer::Methods
+
+  def delay; end
+  def progress(status); end
+  def report(env); end
+  def start(env); end
+  def warn(message); end
+
+  private
+
+  def write(frame); end
+
+  class << self
+    def build(output); end
+  end
+end
+
+class Mutant::Reporter::CLI::Format
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::AbstractType
+  extend ::Unparser::AbstractType::AbstractMethodDeclarations
+
+  def delay; end
+  def progress(*_arg0); end
+  def start(*_arg0); end
+
+  private
+
+  def format(printer, object); end
+
+  class << self
+    def new(*args, &block); end
+  end
+end
+
+class Mutant::Reporter::CLI::Format::Output
+  include ::Unparser::Equalizer::Methods
+
+  def puts(*args, &block); end
+  def tty?; end
+  def write(*args, &block); end
+end
+
+class Mutant::Reporter::CLI::Format::Progressive < ::Mutant::Reporter::CLI::Format
+  def progress(status); end
+  def start(env); end
+
+  private
+
+  def new_buffer; end
+end
+
+Mutant::Reporter::CLI::Format::Progressive::REPORT_DELAY = T.let(T.unsafe(nil), Float)
+Mutant::Reporter::CLI::Format::Progressive::REPORT_FREQUENCY = T.let(T.unsafe(nil), Float)
+
+class Mutant::Reporter::CLI::Printer
+  extend ::Unparser::AbstractType::AbstractMethodDeclarations
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  include ::Unparser::AbstractType
+  extend ::Mutant::Procto::ClassMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+  include ::Mutant::Procto
+
+  def call; end
+  def run(*_arg0); end
+
+  private
+
+  def color?; end
+  def colorize(color, message); end
+  def info(string, *arguments); end
+  def puts(string); end
+  def status(string, *arguments); end
+  def status_color; end
+  def success?; end
+  def tty?; end
+  def visit(printer, object); end
+  def visit_collection(printer, collection); end
+
+  class << self
+    private
+
+    def define_delegator(name); end
+    def delegate(*names); end
+    def new(*args, &block); end
+  end
+end
+
+class Mutant::Reporter::CLI::Printer::Config < ::Mutant::Reporter::CLI::Printer
+  def run; end
+end
+
+class Mutant::Reporter::CLI::Printer::CoverageResult < ::Mutant::Reporter::CLI::Printer
+  def run; end
+end
+
+class Mutant::Reporter::CLI::Printer::Env < ::Mutant::Reporter::CLI::Printer
+  def run; end
+
+  private
+
+  def amount_mutations; end
+  def amount_selected_tests; end
+  def amount_subjects; end
+  def amount_total_tests; end
+  def config; end
+  def test_subject_ratio; end
+end
+
+Mutant::Reporter::CLI::Printer::Env::FORMATS = T.let(T.unsafe(nil), Array)
+
+class Mutant::Reporter::CLI::Printer::EnvProgress < ::Mutant::Reporter::CLI::Printer
+  def run; end
+
+  private
+
+  def amount_mutation_results; end
+  def amount_mutations_alive; end
+  def amount_mutations_killed; end
+  def amount_timeouts; end
+  def coverage; end
+  def coverage_percent; end
+  def env; end
+  def killtime; end
+  def mutations_per_second; end
+  def overhead; end
+  def overhead_percent; end
+  def runtime; end
+end
+
+Mutant::Reporter::CLI::Printer::EnvProgress::FORMATS = T.let(T.unsafe(nil), Array)
+
+class Mutant::Reporter::CLI::Printer::EnvResult < ::Mutant::Reporter::CLI::Printer
+  def run; end
+
+  private
+
+  def failed_subject_results; end
+end
+
+class Mutant::Reporter::CLI::Printer::IsolationResult < ::Mutant::Reporter::CLI::Printer
+  def run; end
+
+  private
+
+  def print_exception; end
+  def print_log_messages; end
+  def print_process_status; end
+  def print_timeout; end
+end
+
+Mutant::Reporter::CLI::Printer::IsolationResult::EXCEPTION_ERROR_MESSAGE = T.let(T.unsafe(nil), String)
+Mutant::Reporter::CLI::Printer::IsolationResult::PROCESS_ERROR_MESSAGE = T.let(T.unsafe(nil), String)
+Mutant::Reporter::CLI::Printer::IsolationResult::TIMEOUT_ERROR_MESSAGE = T.let(T.unsafe(nil), String)
+
+class Mutant::Reporter::CLI::Printer::MutationResult < ::Mutant::Reporter::CLI::Printer
+  def run; end
+
+  private
+
+  def evil_details; end
+  def isolation_result; end
+  def mutation; end
+  def neutral_details; end
+  def noop_details; end
+  def original_node; end
+  def print_details; end
+  def print_no_diff_message; end
+end
+
+Mutant::Reporter::CLI::Printer::MutationResult::MAP = T.let(T.unsafe(nil), Hash)
+Mutant::Reporter::CLI::Printer::MutationResult::NEUTRAL_MESSAGE = T.let(T.unsafe(nil), String)
+Mutant::Reporter::CLI::Printer::MutationResult::NOOP_MESSAGE = T.let(T.unsafe(nil), String)
+Mutant::Reporter::CLI::Printer::MutationResult::NO_DIFF_MESSAGE = T.let(T.unsafe(nil), String)
+Mutant::Reporter::CLI::Printer::MutationResult::SEPARATOR = T.let(T.unsafe(nil), String)
+Mutant::Reporter::CLI::Printer::NL = T.let(T.unsafe(nil), String)
+
+class Mutant::Reporter::CLI::Printer::StatusProgressive < ::Mutant::Reporter::CLI::Printer
+  def run; end
+
+  private
+
+  def amount_mutation_results; end
+  def amount_mutations; end
+  def amount_mutations_alive; end
+  def amount_mutations_killed; end
+  def killtime; end
+  def mutations_per_second; end
+  def object; end
+  def overhead; end
+  def runtime; end
+end
+
+Mutant::Reporter::CLI::Printer::StatusProgressive::FORMAT = T.let(T.unsafe(nil), String)
+
+class Mutant::Reporter::CLI::Printer::SubjectResult < ::Mutant::Reporter::CLI::Printer
+  def run; end
+
+  private
+
+  def subject; end
+  def tests; end
+  def uncovered_results; end
+end
+
+class Mutant::Reporter::Null < ::Mutant::Reporter
+  include ::Unparser::Equalizer::Methods
+
+  def progress(_object); end
+  def report(_object); end
+  def start(_object); end
+  def warn(_object); end
+end
+
+class Mutant::Reporter::Sequence < ::Mutant::Reporter
+  include ::Unparser::Equalizer::Methods
+
+  def delay; end
+  def progress(value); end
+  def report(value); end
+  def start(value); end
+  def warn(value); end
+end
+
+module Mutant::Repository; end
+
+class Mutant::Repository::Diff
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+
+  def to; end
+  def touches?(path, line_range); end
+  def world; end
+
+  private
+
+  def diff_index(root); end
+  def parse_line(root, line); end
+  def repository_root; end
+  def touched_paths(&block); end
+
+  class << self
+    def anima; end
+  end
+end
+
+class Mutant::Repository::Diff::Error < ::RuntimeError; end
+Mutant::Repository::Diff::FORMAT = T.let(T.unsafe(nil), Regexp)
+
+class Mutant::Repository::Diff::Path
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+
+  def path; end
+  def to; end
+  def touches?(line_range); end
+  def world; end
+
+  private
+
+  def diff_ranges(&block); end
+
+  class << self
+    def anima; end
+  end
+end
+
+Mutant::Repository::Diff::Path::DECIMAL = T.let(T.unsafe(nil), Regexp)
+Mutant::Repository::Diff::Path::REGEXP = T.let(T.unsafe(nil), Regexp)
+
+module Mutant::Repository::Diff::Ranges
+  class << self
+    def parse(diff); end
+
+    private
+
+    def mk_range(start, offset); end
+    def parse_ranges(line); end
+  end
+end
+
+Mutant::Repository::Diff::Ranges::DECIMAL = T.let(T.unsafe(nil), Regexp)
+Mutant::Repository::Diff::Ranges::REGEXP = T.let(T.unsafe(nil), Regexp)
+
+class Mutant::Repository::SubjectFilter
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+
+  def call(subject); end
+end
+
+module Mutant::RequireHighjack
+  class << self
+    def call(target, callback); end
+  end
+end
+
+module Mutant::Result
+  include ::Unparser::Adamantium::InstanceMethods
+  include ::Unparser::Adamantium
+
+  mixes_in_class_methods ::Mutant::Result::ClassMethods
+
+  def overhead; end
+
+  class << self
+    def included(host); end
+  end
+end
+
+module Mutant::Result::ClassMethods
+  def delegate(name, target); end
+  def sum(name, collection); end
+end
+
+class Mutant::Result::Coverage
+  extend ::Mutant::Result::ClassMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Mutant::Result
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+  include ::Unparser::Anima::InstanceMethods
+
+  def criteria_result; end
+  def killtime; end
+  def mutation_result; end
+  def runtime; end
+  def success?; end
+  def timeout?; end
+
+  class << self
+    def anima; end
+  end
+end
+
+class Mutant::Result::CoverageCriteria
+  extend ::Mutant::Result::ClassMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Mutant::Result
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+  include ::Unparser::Anima::InstanceMethods
+
+  def process_abort; end
+  def success?; end
+  def test_result; end
+  def timeout; end
+
+  class << self
+    def anima; end
+  end
+end
+
+module Mutant::Result::CoverageMetric
+  def coverage; end
+end
+
+Mutant::Result::CoverageMetric::FULL_COVERAGE = T.let(T.unsafe(nil), Rational)
+
+class Mutant::Result::Env
+  extend ::Mutant::Result::ClassMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Mutant::Result
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  include ::Mutant::Result::CoverageMetric
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+  include ::Unparser::Anima::InstanceMethods
+
+  def amount_mutation_results(&block); end
+  def amount_mutations; end
+  def amount_mutations_alive(&block); end
+  def amount_mutations_killed(&block); end
+  def amount_timeouts(&block); end
+  def env; end
+  def failed_subject_results; end
+  def killtime(&block); end
+  def runtime; end
+  def stop?; end
+  def subject_results; end
+  def success?(&block); end
+
+  class << self
+    def anima; end
+  end
+end
+
+class Mutant::Result::Mutation
+  extend ::Mutant::Result::ClassMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Mutant::Result
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+  include ::Unparser::Anima::InstanceMethods
+
+  def criteria_result(coverage_criteria); end
+  def isolation_result; end
+  def killtime; end
+  def mutation; end
+  def process_abort?; end
+  def runtime; end
+  def timeout?; end
+
+  private
+
+  def test_result_success?(&block); end
+
+  class << self
+    def anima; end
+  end
+end
+
+class Mutant::Result::MutationIndex
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+
+  def isolation_result; end
+  def mutation_index; end
+  def runtime; end
+
+  class << self
+    def anima; end
+  end
+end
+
+class Mutant::Result::Subject
+  extend ::Mutant::Result::ClassMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Mutant::Result
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  include ::Mutant::Result::CoverageMetric
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+  include ::Unparser::Anima::InstanceMethods
+
+  def amount_mutation_results; end
+  def amount_mutations; end
+  def amount_mutations_alive; end
+  def amount_mutations_killed; end
+  def amount_timeouts; end
+  def coverage_results; end
+  def killtime(&block); end
+  def runtime(&block); end
+  def subject; end
+  def success?; end
+  def tests; end
+  def uncovered_results(&block); end
+
+  private
+
+  def covered_results(&block); end
+
+  class << self
+    def anima; end
+  end
+end
+
+class Mutant::Result::Test
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+
+  def passed; end
+  def runtime; end
+
+  class << self
+    def anima; end
+  end
+end
+
+class Mutant::Result::Test::VoidValue < ::Mutant::Result::Test
+  include ::Singleton
+  extend ::Singleton::SingletonClassMethods
+
+  def initialize; end
+
+  class << self
+    def instance; end
+  end
+end
+
+module Mutant::Runner
+  class << self
+    def call(env); end
+
+    private
+
+    def mutation_test_config(env); end
+    def reporter(env); end
+    def run_driver(reporter, driver); end
+    def run_mutation_analysis(env); end
+  end
+end
+
+class Mutant::Runner::Sink
+  include ::Unparser::Equalizer::Methods
+
+  def initialize(*_arg0); end
+
+  def result(mutation_index_result); end
+  def status; end
+  def stop?; end
+
+  private
+
+  def coverage_result(mutation_result); end
+  def mutation_result(mutation_index_result); end
+  def previous_coverage_results(subject); end
+end
+
+Mutant::SCOPE_OPERATOR = T.let(T.unsafe(nil), String)
+
+class Mutant::Scope
+  include ::Unparser::Equalizer::Methods
+end
+
+class Mutant::Selector
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  include ::Unparser::AbstractType
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+  extend ::Unparser::AbstractType::AbstractMethodDeclarations
+
+  def call(*_arg0); end
+
+  class << self
+    def new(*args, &block); end
+  end
+end
+
+class Mutant::Selector::Expression < ::Mutant::Selector
+  include ::Unparser::Equalizer::Methods
+
+  def call(subject); end
+end
+
+class Mutant::Selector::Null < ::Mutant::Selector
+  include ::Unparser::Equalizer::Methods
+
+  def call(_subject); end
+end
+
+class Mutant::Subject
+  extend ::Unparser::AbstractType::AbstractMethodDeclarations
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  include ::Unparser::AbstractType
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+  include ::Enumerable
+
+  def context; end
+  def expression(*_arg0); end
+  def identification(&block); end
+  def match_expressions(*_arg0); end
+  def mutations(&block); end
+  def node; end
+  def prepare; end
+  def source(&block); end
+  def source_line; end
+  def source_lines(&block); end
+  def source_path; end
+
+  private
+
+  def neutral_mutation; end
+  def wrap_node(node); end
+
+  class << self
+    def anima; end
+    def new(*args, &block); end
+  end
+end
+
+class Mutant::Subject::Method < ::Mutant::Subject
+  def expression(&block); end
+  def match_expressions(&block); end
+  def name; end
+
+  private
+
+  def scope; end
+end
+
+class Mutant::Subject::Method::Instance < ::Mutant::Subject::Method
+  def prepare; end
+end
+
+class Mutant::Subject::Method::Instance::Memoized < ::Mutant::Subject::Method::Instance
+  include ::Mutant::AST::Sexp
+
+  def prepare; end
+
+  private
+
+  def wrap_node(mutant); end
+end
+
+Mutant::Subject::Method::Instance::NAME_INDEX = T.let(T.unsafe(nil), Integer)
+Mutant::Subject::Method::Instance::SYMBOL = T.let(T.unsafe(nil), String)
+
+class Mutant::Subject::Method::Metaclass < ::Mutant::Subject::Method
+  include ::Mutant::AST::Sexp
+
+  def prepare; end
+
+  private
+
+  def wrap_node(mutant); end
+end
+
+Mutant::Subject::Method::Metaclass::NAME_INDEX = T.let(T.unsafe(nil), Integer)
+Mutant::Subject::Method::Metaclass::SYMBOL = T.let(T.unsafe(nil), String)
+
+class Mutant::Subject::Method::Singleton < ::Mutant::Subject::Method
+  def prepare; end
+end
+
+Mutant::Subject::Method::Singleton::NAME_INDEX = T.let(T.unsafe(nil), Integer)
+Mutant::Subject::Method::Singleton::SYMBOL = T.let(T.unsafe(nil), String)
+
+class Mutant::Test
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+
+  def expressions; end
+  def id; end
+  def identification; end
+
+  class << self
+    def anima; end
+  end
+end
+
+class Mutant::Timer
+  include ::Unparser::Equalizer::Methods
+
+  def now; end
+end
+
+class Mutant::Timer::Deadline
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+
+  def initialize(*arguments); end
+
+  def allowed_time; end
+  def expired?; end
+  def status; end
+  def time_left; end
+  def timer; end
+
+  class << self
+    def anima; end
+  end
+end
+
+class Mutant::Timer::Deadline::None < ::Mutant::Timer::Deadline
+  def expired?; end
+  def time_left; end
+end
+
+class Mutant::Timer::Deadline::Status
+  include ::Unparser::Equalizer::Methods
+
+  def ok?; end
+end
+
+class Mutant::Transform
+  include ::Unparser::AbstractType
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::AbstractType::AbstractMethodDeclarations
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+
+  def call(*_arg0); end
+  def slug; end
+
+  private
+
+  def error(input:, cause: T.unsafe(nil), message: T.unsafe(nil)); end
+  def failure(value); end
+  def lift_error(error); end
+  def success(value); end
+  def wrap_error(error); end
+
+  class << self
+    def new(*args, &block); end
+  end
+end
+
+class Mutant::Transform::Array < ::Mutant::Transform
+  include ::Unparser::Equalizer::Methods
+
+  def call(input); end
+
+  private
+
+  def run(input); end
+end
+
+Mutant::Transform::Array::MESSAGE = T.let(T.unsafe(nil), String)
+Mutant::Transform::Array::PRIMITIVE = T.let(T.unsafe(nil), Mutant::Transform::Primitive)
+Mutant::Transform::BOOLEAN = T.let(T.unsafe(nil), Mutant::Transform::Boolean)
+
+class Mutant::Transform::Block < ::Mutant::Transform
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+
+  def block; end
+  def call(input); end
+  def name; end
+  def slug; end
+
+  class << self
+    def anima; end
+    def capture(name, &block); end
+  end
+end
+
+class Mutant::Transform::Boolean < ::Mutant::Transform
+  include ::Unparser::Equalizer::Methods
+
+  def call(input); end
+end
+
+Mutant::Transform::Boolean::MESSAGE = T.let(T.unsafe(nil), String)
+
+class Mutant::Transform::Error
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+
+  def cause; end
+  def compact_message(&block); end
+  def input; end
+  def message; end
+  def trace(&block); end
+  def transform; end
+
+  private
+
+  def path; end
+
+  class << self
+    def anima; end
+  end
+end
+
+Mutant::Transform::Error::COMPACT = T.let(T.unsafe(nil), String)
+
+class Mutant::Transform::Exception < ::Mutant::Transform
+  include ::Unparser::Equalizer::Methods
+
+  def call(input); end
+end
+
+Mutant::Transform::FLOAT = T.let(T.unsafe(nil), Mutant::Transform::Primitive)
+
+class Mutant::Transform::Hash < ::Mutant::Transform
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+
+  def call(input); end
+  def optional; end
+  def required; end
+
+  private
+
+  def allowed_keys(&block); end
+  def coerce_key(key, input); end
+  def reject_keys(input); end
+  def required_keys(&block); end
+  def transform(input); end
+  def transform_keys(keys, input); end
+  def transform_optional(input); end
+  def transform_required(input); end
+
+  class << self
+    def anima; end
+  end
+end
+
+Mutant::Transform::Hash::KEY_MESSAGE = T.let(T.unsafe(nil), String)
+
+class Mutant::Transform::Hash::Key < ::Mutant::Transform
+  include ::Unparser::Equalizer::Methods
+
+  def call(input); end
+  def slug(&block); end
+end
+
+Mutant::Transform::Hash::PRIMITIVE = T.let(T.unsafe(nil), Mutant::Transform::Primitive)
+
+class Mutant::Transform::Hash::Symbolize < ::Mutant::Transform
+  def call(input); end
+end
+
+Mutant::Transform::INTEGER = T.let(T.unsafe(nil), Mutant::Transform::Primitive)
+
+class Mutant::Transform::Index < ::Mutant::Transform
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+
+  def call(input); end
+  def slug(&block); end
+
+  private
+
+  def index; end
+  def transform; end
+
+  class << self
+    def anima; end
+    def wrap(cause, index); end
+  end
+end
+
+class Mutant::Transform::Named < ::Mutant::Transform
+  include ::Unparser::Equalizer::Methods
+
+  def call(input); end
+  def slug; end
+end
+
+class Mutant::Transform::Primitive < ::Mutant::Transform
+  include ::Unparser::Equalizer::Methods
+
+  def call(input); end
+  def slug(&block); end
+end
+
+Mutant::Transform::Primitive::MESSAGE = T.let(T.unsafe(nil), String)
+Mutant::Transform::STRING = T.let(T.unsafe(nil), Mutant::Transform::Primitive)
+Mutant::Transform::STRING_ARRAY = T.let(T.unsafe(nil), Mutant::Transform::Array)
+
+class Mutant::Transform::Sequence < ::Mutant::Transform
+  include ::Unparser::Equalizer::Methods
+
+  def call(input); end
+end
+
+module Mutant::Util
+  class << self
+    def one(array); end
+  end
+end
+
+class Mutant::Util::SizeError < ::IndexError; end
+Mutant::VERSION = T.let(T.unsafe(nil), String)
+
+class Mutant::Variable
+  def initialize(condition_variable:, mutex:, value: T.unsafe(nil)); end
+
+  def read; end
+  def take; end
+  def take_timeout(timeout); end
+  def try_put(value); end
+  def with; end
+
+  private
+
+  def empty?; end
+  def full?; end
+  def perform_put(value); end
+  def synchronize(&block); end
+  def wait(event); end
+  def wait_full; end
+  def wait_timeout(event, timeout); end
+end
+
+Mutant::Variable::EMPTY = T.let(T.unsafe(nil), T.untyped)
+
+class Mutant::Variable::IVar < ::Mutant::Variable
+  def populate_with; end
+  def put(value); end
+
+  private
+
+  def perform_take; end
+end
+
+class Mutant::Variable::IVar::Error < ::RuntimeError; end
+
+class Mutant::Variable::MVar < ::Mutant::Variable
+  def initialize(condition_variable:, mutex:, value: T.unsafe(nil)); end
+
+  def modify; end
+  def put(value); end
+
+  private
+
+  def perform_take; end
+end
+
+class Mutant::Variable::Result
+  include ::Unparser::Equalizer::Methods
+
+  def initialize(value); end
+
+  def timeout?; end
+  def value; end
+end
+
+class Mutant::Variable::Result::Timeout < ::Mutant::Variable::Result
+  class << self
+    def new; end
+  end
+end
+
+Mutant::Variable::Result::Timeout::INSTANCE = T.let(T.unsafe(nil), Mutant::Variable::Result::Timeout)
+class Mutant::Variable::Result::Value < ::Mutant::Variable::Result; end
+Mutant::Variable::TIMEOUT = T.let(T.unsafe(nil), T.untyped)
+
+module Mutant::Variable::Timer
+  class << self
+    def elapsed; end
+
+    private
+
+    def now; end
+  end
+end
+
+Mutant::WORLD = T.let(T.unsafe(nil), Mutant::World)
+
+class Mutant::World
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Unparser::Adamantium
+  include ::Unparser::Adamantium::InstanceMethods
+  extend ::Unparser::Adamantium::ModuleMethods
+  extend ::Unparser::Adamantium::ClassMethods
+
+  def capture_stdout(command); end
+  def condition_variable; end
+  def deadline(allowed_time); end
+  def gem; end
+  def gem_method; end
+  def inspect; end
+  def io; end
+  def json; end
+  def kernel; end
+  def load_path; end
+  def marshal; end
+  def mutex; end
+  def object_space; end
+  def open3; end
+  def pathname; end
+  def process; end
+  def stderr; end
+  def stdout; end
+  def thread; end
+  def timer; end
+
+  class << self
+    def anima; end
+  end
+end
+
+Mutant::World::INSPECT = T.let(T.unsafe(nil), String)
+
+class Mutant::Zombifier
+  include ::Unparser::Anima::InstanceMethods
+  include ::Unparser::Equalizer::Methods
+  include ::Mutant::AST::Sexp
+
+  def initialize(*_arg0); end
+
+  private
+
+  def call; end
+  def find(logical_name); end
+  def include?(logical_name); end
+  def includes; end
+  def kernel; end
+  def load_path; end
+  def namespace; end
+  def namespaced_node(source_path); end
+  def original; end
+  def pathname; end
+  def require(logical_name); end
+  def require_highjack; end
+  def root_require; end
+  def zombify(source_path); end
+
+  class << self
+    def anima; end
+    def call(*args); end
+  end
+end
+
+class Mutant::Zombifier::LoadError < ::LoadError; end