23s2s

✏️ Editing: node.rbs

# This file is generated by the templates/template.rb script and should not be
# modified manually. See templates/sig/prism/node.rbs.erb
# if you are looking to modify the template

module Prism
  class Node
    attr_reader source: Source
    attr_reader node_id: Integer
    attr_reader location: Location
    attr_reader flags: Integer

def newline?: () -> bool
    def static_literal?: () -> bool

def accept: (_Visitor) -> void
    def child_nodes: () -> Array[Prism::node?]
    def comment_targets: () -> Array[Prism::node | Location]
    def compact_child_nodes: () -> Array[Prism::node]
    def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node]
    def self.fields: () -> Array[Prism::Reflection::Field]
    def type: () -> Symbol
    def self.type: () -> Symbol

def source_lines: () -> Array[String]
    alias script_lines source_lines
    def slice: () -> String
    def slice_lines: () -> String
    def pretty_print: (untyped q) -> untyped
    def to_dot: () -> String
    def tunnel: (Integer line, Integer column) -> Array[Prism::node]
    def breadth_first_search: () { (Prism::node) -> bool } -> Prism::node?
    alias find breadth_first_search
    def breadth_first_search_all: () { (Prism::node) -> bool } -> Array[Prism::node]
    alias find_all breadth_first_search_all
    def newline!: (Array[untyped]) -> void

def save: (_Repository repository) -> void
    def save_location: (_Repository repository) -> void

def leading_comments: () -> Array[comment]
    def trailing_comments: () -> Array[comment]
    def comments: () -> Array[comment]

def start_offset: () -> Integer
    def start_character_offset: () -> Integer
    def start_code_units_offset: (Encoding encoding) -> Integer
    def cached_start_code_units_offset: (_CodeUnitsCache cache) -> Integer

def end_offset: () -> Integer
    def end_character_offset: () -> Integer
    def end_code_units_offset: (Encoding encoding) -> Integer
    def cached_end_code_units_offset: (_CodeUnitsCache cache) -> Integer

def start_line: () -> Integer
    def end_line: () -> Integer

def start_column: () -> Integer
    def start_character_column: () -> Integer
    def start_code_units_column: (Encoding encoding) -> Integer
    def cached_start_code_units_column: (_CodeUnitsCache cache) -> Integer

def end_column: () -> Integer
    def end_character_column: () -> Integer
    def end_code_units_column: (Encoding encoding) -> Integer
    def cached_end_code_units_column: (_CodeUnitsCache cache) -> Integer
  end

# Methods implemented by every subclass of Node
  interface _Node
    def deconstruct: () -> Array[Prism::node?]
    def inspect: () -> String
  end

type node = Node & _Node

interface _Repository
    def enter: (Integer node_id, Symbol field_name) -> void
  end

# Represents the use of the `alias` keyword to alias a global variable.
  #
  #     alias $foo $bar
  #     ^^^^^^^^^^^^^^^
  class AliasGlobalVariableNode < Node
    include _Node

def save_keyword_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode new_name, GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | SymbolNode | MissingNode old_name, Location keyword_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?new_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode, ?old_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | SymbolNode | MissingNode, ?keyword_loc: Location) -> AliasGlobalVariableNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, new_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode, old_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | SymbolNode | MissingNode, keyword_loc: Location }
    def keyword: () -> String
    def type: () -> :alias_global_variable_node
            | ...
    def self.type: () -> :alias_global_variable_node
  end

# Represents the use of the `alias` keyword to alias a method.
  #
  #     alias foo bar
  #     ^^^^^^^^^^^^^
  class AliasMethodNode < Node
    include _Node

attr_reader new_name: SymbolNode | InterpolatedSymbolNode
    attr_reader old_name: SymbolNode | InterpolatedSymbolNode | GlobalVariableReadNode | MissingNode
    attr_reader keyword_loc: Location

def save_keyword_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, SymbolNode | InterpolatedSymbolNode new_name, SymbolNode | InterpolatedSymbolNode | GlobalVariableReadNode | MissingNode old_name, Location keyword_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?new_name: SymbolNode | InterpolatedSymbolNode, ?old_name: SymbolNode | InterpolatedSymbolNode | GlobalVariableReadNode | MissingNode, ?keyword_loc: Location) -> AliasMethodNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, new_name: SymbolNode | InterpolatedSymbolNode, old_name: SymbolNode | InterpolatedSymbolNode | GlobalVariableReadNode | MissingNode, keyword_loc: Location }
    def keyword: () -> String
    def type: () -> :alias_method_node
            | ...
    def self.type: () -> :alias_method_node
  end

# Represents an alternation pattern in pattern matching.
  #
  #     foo => bar | baz
  #            ^^^^^^^^^
  class AlternationPatternNode < Node
    include _Node

attr_reader left: Prism::node
    attr_reader right: Prism::node
    attr_reader operator_loc: Location

def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node left, Prism::node right, Location operator_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node, ?right: Prism::node, ?operator_loc: Location) -> AlternationPatternNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node, right: Prism::node, operator_loc: Location }
    def operator: () -> String
    def type: () -> :alternation_pattern_node
            | ...
    def self.type: () -> :alternation_pattern_node
  end

# Represents the use of the `&&` operator or the `and` keyword.
  #
  #     left and right
  #     ^^^^^^^^^^^^^^
  class AndNode < Node
    include _Node

attr_reader left: Prism::node
    attr_reader right: Prism::node
    attr_reader operator_loc: Location

def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node left, Prism::node right, Location operator_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node, ?right: Prism::node, ?operator_loc: Location) -> AndNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node, right: Prism::node, operator_loc: Location }
    def operator: () -> String
    def type: () -> :and_node
            | ...
    def self.type: () -> :and_node
  end

# Represents a set of arguments to a method or a keyword.
  #
  #     return foo, bar, baz
  #            ^^^^^^^^^^^^^
  class ArgumentsNode < Node
    include _Node

def contains_forwarding?: () -> bool
    def contains_keywords?: () -> bool
    def contains_keyword_splat?: () -> bool
    def contains_splat?: () -> bool
    def contains_multiple_splats?: () -> bool

attr_reader arguments: Array[Prism::node]

def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[Prism::node] arguments) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?arguments: Array[Prism::node]) -> ArgumentsNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, arguments: Array[Prism::node] }
    def type: () -> :arguments_node
            | ...
    def self.type: () -> :arguments_node
  end

# Represents an array literal. This can be a regular array using brackets or a special array using % like %w or %i.
  #
  #     [1, 2, 3]
  #     ^^^^^^^^^
  class ArrayNode < Node
    include _Node

def contains_splat?: () -> bool

attr_reader elements: Array[Prism::node]
    attr_reader opening_loc: Location?
    attr_reader closing_loc: Location?

def save_opening_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[Prism::node] elements, Location? opening_loc, Location? closing_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?elements: Array[Prism::node], ?opening_loc: Location?, ?closing_loc: Location?) -> ArrayNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, elements: Array[Prism::node], opening_loc: Location?, closing_loc: Location? }
    def opening: () -> String?
    def closing: () -> String?
    def type: () -> :array_node
            | ...
    def self.type: () -> :array_node
  end

# Represents an array pattern in pattern matching.
  #
  #     foo in 1, 2
  #     ^^^^^^^^^^^
  #
  #     foo in [1, 2]
  #     ^^^^^^^^^^^^^
  #
  #     foo in *bar
  #     ^^^^^^^^^^^
  #
  #     foo in Bar[]
  #     ^^^^^^^^^^^^
  #
  #     foo in Bar[1, 2, 3]
  #     ^^^^^^^^^^^^^^^^^^^
  class ArrayPatternNode < Node
    include _Node

attr_reader constant: ConstantPathNode | ConstantReadNode | nil
    attr_reader requireds: Array[Prism::node]
    attr_reader rest: Prism::node?
    attr_reader posts: Array[Prism::node]
    attr_reader opening_loc: Location?
    attr_reader closing_loc: Location?

def save_opening_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, ConstantPathNode | ConstantReadNode | nil constant, Array[Prism::node] requireds, Prism::node? rest, Array[Prism::node] posts, Location? opening_loc, Location? closing_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantPathNode | ConstantReadNode | nil, ?requireds: Array[Prism::node], ?rest: Prism::node?, ?posts: Array[Prism::node], ?opening_loc: Location?, ?closing_loc: Location?) -> ArrayPatternNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantPathNode | ConstantReadNode | nil, requireds: Array[Prism::node], rest: Prism::node?, posts: Array[Prism::node], opening_loc: Location?, closing_loc: Location? }
    def opening: () -> String?
    def closing: () -> String?
    def type: () -> :array_pattern_node
            | ...
    def self.type: () -> :array_pattern_node
  end

# Represents a hash key/value pair.
  #
  #     { a => b }
  #       ^^^^^^
  class AssocNode < Node
    include _Node

attr_reader key: Prism::node
    attr_reader value: Prism::node
    attr_reader operator_loc: Location?

def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node key, Prism::node value, Location? operator_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?key: Prism::node, ?value: Prism::node, ?operator_loc: Location?) -> AssocNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, key: Prism::node, value: Prism::node, operator_loc: Location? }
    def operator: () -> String?
    def type: () -> :assoc_node
            | ...
    def self.type: () -> :assoc_node
  end

# Represents a splat in a hash literal.
  #
  #     { **foo }
  #       ^^^^^
  class AssocSplatNode < Node
    include _Node

attr_reader value: Prism::node?
    attr_reader operator_loc: Location

def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? value, Location operator_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node?, ?operator_loc: Location) -> AssocSplatNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node?, operator_loc: Location }
    def operator: () -> String
    def type: () -> :assoc_splat_node
            | ...
    def self.type: () -> :assoc_splat_node
  end

# Represents reading a reference to a field in the previous match.
  #
  #     $'
  #     ^^
  class BackReferenceReadNode < Node
    include _Node

attr_reader name: Symbol

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> BackReferenceReadNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
    def type: () -> :back_reference_read_node
            | ...
    def self.type: () -> :back_reference_read_node
  end

# Represents a begin statement.
  #
  #     begin
  #       foo
  #     end
  #     ^^^^^
  class BeginNode < Node
    include _Node

attr_reader begin_keyword_loc: Location?
    attr_reader statements: StatementsNode?
    attr_reader rescue_clause: RescueNode?
    attr_reader else_clause: ElseNode?
    attr_reader ensure_clause: EnsureNode?
    attr_reader end_keyword_loc: Location?

def save_begin_keyword_loc: (_Repository repository) -> void
    def save_end_keyword_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location? begin_keyword_loc, StatementsNode? statements, RescueNode? rescue_clause, ElseNode? else_clause, EnsureNode? ensure_clause, Location? end_keyword_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?begin_keyword_loc: Location?, ?statements: StatementsNode?, ?rescue_clause: RescueNode?, ?else_clause: ElseNode?, ?ensure_clause: EnsureNode?, ?end_keyword_loc: Location?) -> BeginNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, begin_keyword_loc: Location?, statements: StatementsNode?, rescue_clause: RescueNode?, else_clause: ElseNode?, ensure_clause: EnsureNode?, end_keyword_loc: Location? }
    def begin_keyword: () -> String?
    def end_keyword: () -> String?
    def type: () -> :begin_node
            | ...
    def self.type: () -> :begin_node
  end

# Represents a block argument using `&`.
  #
  #     bar(&args)
  #     ^^^^^^^^^^
  class BlockArgumentNode < Node
    include _Node

attr_reader expression: Prism::node?
    attr_reader operator_loc: Location

def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? expression, Location operator_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?expression: Prism::node?, ?operator_loc: Location) -> BlockArgumentNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, expression: Prism::node?, operator_loc: Location }
    def operator: () -> String
    def type: () -> :block_argument_node
            | ...
    def self.type: () -> :block_argument_node
  end

# Represents a block local variable.
  #
  #     a { |; b| }
  #            ^
  class BlockLocalVariableNode < Node
    include _Node

def repeated_parameter?: () -> bool

attr_reader name: Symbol

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> BlockLocalVariableNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
    def type: () -> :block_local_variable_node
            | ...
    def self.type: () -> :block_local_variable_node
  end

# Represents a block of ruby code.
  #
  #     [1, 2, 3].each { |i| puts x }
  #                    ^^^^^^^^^^^^^^
  class BlockNode < Node
    include _Node

attr_reader locals: Array[Symbol]
    attr_reader parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil
    attr_reader body: StatementsNode | BeginNode | nil
    attr_reader opening_loc: Location
    attr_reader closing_loc: Location

def save_opening_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[Symbol] locals, BlockParametersNode | NumberedParametersNode | ItParametersNode | nil parameters, StatementsNode | BeginNode | nil body, Location opening_loc, Location closing_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, ?body: StatementsNode | BeginNode | nil, ?opening_loc: Location, ?closing_loc: Location) -> BlockNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, body: StatementsNode | BeginNode | nil, opening_loc: Location, closing_loc: Location }
    def opening: () -> String
    def closing: () -> String
    def type: () -> :block_node
            | ...
    def self.type: () -> :block_node
  end

# Represents a block parameter of a method, block, or lambda definition.
  #
  #     def a(&b)
  #           ^^
  #     end
  class BlockParameterNode < Node
    include _Node

def repeated_parameter?: () -> bool

attr_reader name: Symbol?
    attr_reader name_loc: Location?
    attr_reader operator_loc: Location

def save_name_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol? name, Location? name_loc, Location operator_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location) -> BlockParameterNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol?, name_loc: Location?, operator_loc: Location }
    def operator: () -> String
    def type: () -> :block_parameter_node
            | ...
    def self.type: () -> :block_parameter_node
  end

# Represents a block's parameters declaration.
  #
  #     -> (a, b = 1; local) { }
  #        ^^^^^^^^^^^^^^^^^
  #
  #     foo do |a, b = 1; local|
  #            ^^^^^^^^^^^^^^^^^
  #     end
  class BlockParametersNode < Node
    include _Node

attr_reader parameters: ParametersNode?
    attr_reader locals: Array[BlockLocalVariableNode]
    attr_reader opening_loc: Location?
    attr_reader closing_loc: Location?

def save_opening_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, ParametersNode? parameters, Array[BlockLocalVariableNode] locals, Location? opening_loc, Location? closing_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?parameters: ParametersNode?, ?locals: Array[BlockLocalVariableNode], ?opening_loc: Location?, ?closing_loc: Location?) -> BlockParametersNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, parameters: ParametersNode?, locals: Array[BlockLocalVariableNode], opening_loc: Location?, closing_loc: Location? }
    def opening: () -> String?
    def closing: () -> String?
    def type: () -> :block_parameters_node
            | ...
    def self.type: () -> :block_parameters_node
  end

# Represents the use of the `break` keyword.
  #
  #     break foo
  #     ^^^^^^^^^
  class BreakNode < Node
    include _Node

attr_reader arguments: ArgumentsNode?
    attr_reader keyword_loc: Location

def save_keyword_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, ArgumentsNode? arguments, Location keyword_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?arguments: ArgumentsNode?, ?keyword_loc: Location) -> BreakNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, arguments: ArgumentsNode?, keyword_loc: Location }
    def keyword: () -> String
    def type: () -> :break_node
            | ...
    def self.type: () -> :break_node
  end

# Represents the use of the `&&=` operator on a call.
  #
  #     foo.bar &&= value
  #     ^^^^^^^^^^^^^^^^^
  class CallAndWriteNode < Node
    include _Node

def safe_navigation?: () -> bool
    def variable_call?: () -> bool
    def attribute_write?: () -> bool
    def ignore_visibility?: () -> bool

attr_reader receiver: Prism::node?
    attr_reader call_operator_loc: Location?
    attr_reader message_loc: Location?
    attr_reader read_name: Symbol
    attr_reader write_name: Symbol
    attr_reader operator_loc: Location
    attr_reader value: Prism::node

def save_call_operator_loc: (_Repository repository) -> void
    def save_message_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Location operator_loc, Prism::node value) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?operator_loc: Location, ?value: Prism::node) -> CallAndWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Prism::node }
    def call_operator: () -> String?
    def message: () -> String?
    def operator: () -> String
    def type: () -> :call_and_write_node
            | ...
    def self.type: () -> :call_and_write_node
  end

# Represents a method call, in all of the various forms that can take.
  #
  #     foo
  #     ^^^
  #
  #     foo()
  #     ^^^^^
  #
  #     +foo
  #     ^^^^
  #
  #     foo + bar
  #     ^^^^^^^^^
  #
  #     foo.bar
  #     ^^^^^^^
  #
  #     foo&.bar
  #     ^^^^^^^^
  class CallNode < Node
    include _Node

def safe_navigation?: () -> bool
    def variable_call?: () -> bool
    def attribute_write?: () -> bool
    def ignore_visibility?: () -> bool

attr_reader receiver: Prism::node?
    attr_reader call_operator_loc: Location?
    attr_reader name: Symbol
    attr_reader message_loc: Location?
    attr_reader opening_loc: Location?
    attr_reader arguments: ArgumentsNode?
    attr_reader closing_loc: Location?
    attr_reader equal_loc: Location?
    attr_reader block: BlockNode | BlockArgumentNode | nil

def save_call_operator_loc: (_Repository repository) -> void
    def save_message_loc: (_Repository repository) -> void
    def save_opening_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void
    def save_equal_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? receiver, Location? call_operator_loc, Symbol name, Location? message_loc, Location? opening_loc, ArgumentsNode? arguments, Location? closing_loc, Location? equal_loc, BlockNode | BlockArgumentNode | nil block) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?name: Symbol, ?message_loc: Location?, ?opening_loc: Location?, ?arguments: ArgumentsNode?, ?closing_loc: Location?, ?equal_loc: Location?, ?block: BlockNode | BlockArgumentNode | nil) -> CallNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, name: Symbol, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, equal_loc: Location?, block: BlockNode | BlockArgumentNode | nil }
    def call_operator: () -> String?
    def message: () -> String?
    def opening: () -> String?
    def closing: () -> String?
    def equal: () -> String?
    def type: () -> :call_node
            | ...
    def self.type: () -> :call_node
  end

# Represents the use of an assignment operator on a call.
  #
  #     foo.bar += baz
  #     ^^^^^^^^^^^^^^
  class CallOperatorWriteNode < Node
    include _Node

def safe_navigation?: () -> bool
    def variable_call?: () -> bool
    def attribute_write?: () -> bool
    def ignore_visibility?: () -> bool

attr_reader receiver: Prism::node?
    attr_reader call_operator_loc: Location?
    attr_reader message_loc: Location?
    attr_reader read_name: Symbol
    attr_reader write_name: Symbol
    attr_reader binary_operator: Symbol
    attr_reader binary_operator_loc: Location
    attr_reader value: Prism::node

def save_call_operator_loc: (_Repository repository) -> void
    def save_message_loc: (_Repository repository) -> void
    def save_binary_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Symbol binary_operator, Location binary_operator_loc, Prism::node value) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?binary_operator: Symbol, ?binary_operator_loc: Location, ?value: Prism::node) -> CallOperatorWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, binary_operator: Symbol, binary_operator_loc: Location, value: Prism::node }
    def call_operator: () -> String?
    def message: () -> String?
    def type: () -> :call_operator_write_node
            | ...
    def self.type: () -> :call_operator_write_node
  end

# Represents the use of the `||=` operator on a call.
  #
  #     foo.bar ||= value
  #     ^^^^^^^^^^^^^^^^^
  class CallOrWriteNode < Node
    include _Node

def safe_navigation?: () -> bool
    def variable_call?: () -> bool
    def attribute_write?: () -> bool
    def ignore_visibility?: () -> bool

def save_call_operator_loc: (_Repository repository) -> void
    def save_message_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Location operator_loc, Prism::node value) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?operator_loc: Location, ?value: Prism::node) -> CallOrWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Prism::node }
    def call_operator: () -> String?
    def message: () -> String?
    def operator: () -> String
    def type: () -> :call_or_write_node
            | ...
    def self.type: () -> :call_or_write_node
  end

# Represents assigning to a method call.
  #
  #     foo.bar, = 1
  #     ^^^^^^^
  #
  #     begin
  #     rescue => foo.bar
  #               ^^^^^^^
  #     end
  #
  #     for foo.bar in baz do end
  #         ^^^^^^^
  class CallTargetNode < Node
    include _Node

def safe_navigation?: () -> bool
    def variable_call?: () -> bool
    def attribute_write?: () -> bool
    def ignore_visibility?: () -> bool

attr_reader receiver: Prism::node
    attr_reader call_operator_loc: Location
    attr_reader name: Symbol
    attr_reader message_loc: Location

def save_call_operator_loc: (_Repository repository) -> void
    def save_message_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node receiver, Location call_operator_loc, Symbol name, Location message_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node, ?call_operator_loc: Location, ?name: Symbol, ?message_loc: Location) -> CallTargetNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node, call_operator_loc: Location, name: Symbol, message_loc: Location }
    def call_operator: () -> String
    def message: () -> String
    def type: () -> :call_target_node
            | ...
    def self.type: () -> :call_target_node
  end

# Represents assigning to a local variable in pattern matching.
  #
  #     foo => [bar => baz]
  #            ^^^^^^^^^^^^
  class CapturePatternNode < Node
    include _Node

attr_reader value: Prism::node
    attr_reader target: LocalVariableTargetNode
    attr_reader operator_loc: Location

def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node value, LocalVariableTargetNode target, Location operator_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?target: LocalVariableTargetNode, ?operator_loc: Location) -> CapturePatternNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node, target: LocalVariableTargetNode, operator_loc: Location }
    def operator: () -> String
    def type: () -> :capture_pattern_node
            | ...
    def self.type: () -> :capture_pattern_node
  end

# Represents the use of a case statement for pattern matching.
  #
  #     case true
  #     in false
  #     end
  #     ^^^^^^^^^
  class CaseMatchNode < Node
    include _Node

attr_reader predicate: Prism::node?
    attr_reader conditions: Array[InNode]
    attr_reader else_clause: ElseNode?
    attr_reader case_keyword_loc: Location
    attr_reader end_keyword_loc: Location

def save_case_keyword_loc: (_Repository repository) -> void
    def save_end_keyword_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? predicate, Array[InNode] conditions, ElseNode? else_clause, Location case_keyword_loc, Location end_keyword_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?predicate: Prism::node?, ?conditions: Array[InNode], ?else_clause: ElseNode?, ?case_keyword_loc: Location, ?end_keyword_loc: Location) -> CaseMatchNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, predicate: Prism::node?, conditions: Array[InNode], else_clause: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location }
    def case_keyword: () -> String
    def end_keyword: () -> String
    def type: () -> :case_match_node
            | ...
    def self.type: () -> :case_match_node
  end

# Represents the use of a case statement.
  #
  #     case true
  #     when false
  #     end
  #     ^^^^^^^^^^
  class CaseNode < Node
    include _Node

attr_reader predicate: Prism::node?
    attr_reader conditions: Array[WhenNode]
    attr_reader else_clause: ElseNode?
    attr_reader case_keyword_loc: Location
    attr_reader end_keyword_loc: Location

def save_case_keyword_loc: (_Repository repository) -> void
    def save_end_keyword_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? predicate, Array[WhenNode] conditions, ElseNode? else_clause, Location case_keyword_loc, Location end_keyword_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?predicate: Prism::node?, ?conditions: Array[WhenNode], ?else_clause: ElseNode?, ?case_keyword_loc: Location, ?end_keyword_loc: Location) -> CaseNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, predicate: Prism::node?, conditions: Array[WhenNode], else_clause: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location }
    def case_keyword: () -> String
    def end_keyword: () -> String
    def type: () -> :case_node
            | ...
    def self.type: () -> :case_node
  end

# Represents a class declaration involving the `class` keyword.
  #
  #     class Foo end
  #     ^^^^^^^^^^^^^
  class ClassNode < Node
    include _Node

attr_reader locals: Array[Symbol]
    attr_reader class_keyword_loc: Location
    attr_reader constant_path: ConstantReadNode | ConstantPathNode | CallNode
    attr_reader inheritance_operator_loc: Location?
    attr_reader superclass: Prism::node?
    attr_reader body: StatementsNode | BeginNode | nil
    attr_reader end_keyword_loc: Location
    attr_reader name: Symbol

def save_class_keyword_loc: (_Repository repository) -> void
    def save_inheritance_operator_loc: (_Repository repository) -> void
    def save_end_keyword_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[Symbol] locals, Location class_keyword_loc, ConstantReadNode | ConstantPathNode | CallNode constant_path, Location? inheritance_operator_loc, Prism::node? superclass, StatementsNode | BeginNode | nil body, Location end_keyword_loc, Symbol name) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?class_keyword_loc: Location, ?constant_path: ConstantReadNode | ConstantPathNode | CallNode, ?inheritance_operator_loc: Location?, ?superclass: Prism::node?, ?body: StatementsNode | BeginNode | nil, ?end_keyword_loc: Location, ?name: Symbol) -> ClassNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], class_keyword_loc: Location, constant_path: ConstantReadNode | ConstantPathNode | CallNode, inheritance_operator_loc: Location?, superclass: Prism::node?, body: StatementsNode | BeginNode | nil, end_keyword_loc: Location, name: Symbol }
    def class_keyword: () -> String
    def inheritance_operator: () -> String?
    def end_keyword: () -> String
    def type: () -> :class_node
            | ...
    def self.type: () -> :class_node
  end

# Represents the use of the `&&=` operator for assignment to a class variable.
  #
  #     @@target &&= value
  #     ^^^^^^^^^^^^^^^^^^
  class ClassVariableAndWriteNode < Node
    include _Node

attr_reader name: Symbol
    attr_reader name_loc: Location
    attr_reader operator_loc: Location
    attr_reader value: Prism::node

def save_name_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location operator_loc, Prism::node value) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ClassVariableAndWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
    def operator: () -> String
    def type: () -> :class_variable_and_write_node
            | ...
    def self.type: () -> :class_variable_and_write_node
  end

# Represents assigning to a class variable using an operator that isn't `=`.
  #
  #     @@target += value
  #     ^^^^^^^^^^^^^^^^^
  class ClassVariableOperatorWriteNode < Node
    include _Node

attr_reader name: Symbol
    attr_reader name_loc: Location
    attr_reader binary_operator_loc: Location
    attr_reader value: Prism::node
    attr_reader binary_operator: Symbol

def save_name_loc: (_Repository repository) -> void
    def save_binary_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> ClassVariableOperatorWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol }
    def type: () -> :class_variable_operator_write_node
            | ...
    def self.type: () -> :class_variable_operator_write_node
  end

# Represents the use of the `||=` operator for assignment to a class variable.
  #
  #     @@target ||= value
  #     ^^^^^^^^^^^^^^^^^^
  class ClassVariableOrWriteNode < Node
    include _Node

attr_reader name: Symbol
    attr_reader name_loc: Location
    attr_reader operator_loc: Location
    attr_reader value: Prism::node

def save_name_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location operator_loc, Prism::node value) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ClassVariableOrWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
    def operator: () -> String
    def type: () -> :class_variable_or_write_node
            | ...
    def self.type: () -> :class_variable_or_write_node
  end

# Represents referencing a class variable.
  #
  #     @@foo
  #     ^^^^^
  class ClassVariableReadNode < Node
    include _Node

attr_reader name: Symbol

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ClassVariableReadNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
    def type: () -> :class_variable_read_node
            | ...
    def self.type: () -> :class_variable_read_node
  end

# Represents writing to a class variable in a context that doesn't have an explicit value.
  #
  #     @@foo, @@bar = baz
  #     ^^^^^  ^^^^^
  class ClassVariableTargetNode < Node
    include _Node

attr_reader name: Symbol

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ClassVariableTargetNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
    def type: () -> :class_variable_target_node
            | ...
    def self.type: () -> :class_variable_target_node
  end

# Represents writing to a class variable.
  #
  #     @@foo = 1
  #     ^^^^^^^^^
  class ClassVariableWriteNode < Node
    include _Node

attr_reader name: Symbol
    attr_reader name_loc: Location
    attr_reader value: Prism::node
    attr_reader operator_loc: Location

def save_name_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Prism::node value, Location operator_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> ClassVariableWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location }
    def operator: () -> String
    def type: () -> :class_variable_write_node
            | ...
    def self.type: () -> :class_variable_write_node
  end

# Represents the use of the `&&=` operator for assignment to a constant.
  #
  #     Target &&= value
  #     ^^^^^^^^^^^^^^^^
  class ConstantAndWriteNode < Node
    include _Node

attr_reader name: Symbol
    attr_reader name_loc: Location
    attr_reader operator_loc: Location
    attr_reader value: Prism::node

def save_name_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location operator_loc, Prism::node value) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ConstantAndWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
    def operator: () -> String
    def type: () -> :constant_and_write_node
            | ...
    def self.type: () -> :constant_and_write_node
  end

# Represents assigning to a constant using an operator that isn't `=`.
  #
  #     Target += value
  #     ^^^^^^^^^^^^^^^
  class ConstantOperatorWriteNode < Node
    include _Node

attr_reader name: Symbol
    attr_reader name_loc: Location
    attr_reader binary_operator_loc: Location
    attr_reader value: Prism::node
    attr_reader binary_operator: Symbol

def save_name_loc: (_Repository repository) -> void
    def save_binary_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> ConstantOperatorWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol }
    def type: () -> :constant_operator_write_node
            | ...
    def self.type: () -> :constant_operator_write_node
  end

# Represents the use of the `||=` operator for assignment to a constant.
  #
  #     Target ||= value
  #     ^^^^^^^^^^^^^^^^
  class ConstantOrWriteNode < Node
    include _Node

attr_reader name: Symbol
    attr_reader name_loc: Location
    attr_reader operator_loc: Location
    attr_reader value: Prism::node

def save_name_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location operator_loc, Prism::node value) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ConstantOrWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
    def operator: () -> String
    def type: () -> :constant_or_write_node
            | ...
    def self.type: () -> :constant_or_write_node
  end

# Represents the use of the `&&=` operator for assignment to a constant path.
  #
  #     Parent::Child &&= value
  #     ^^^^^^^^^^^^^^^^^^^^^^^
  class ConstantPathAndWriteNode < Node
    include _Node

attr_reader target: ConstantPathNode
    attr_reader operator_loc: Location
    attr_reader value: Prism::node

def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, ConstantPathNode target, Location operator_loc, Prism::node value) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node) -> ConstantPathAndWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, operator_loc: Location, value: Prism::node }
    def operator: () -> String
    def type: () -> :constant_path_and_write_node
            | ...
    def self.type: () -> :constant_path_and_write_node
  end

# Represents accessing a constant through a path of `::` operators.
  #
  #     Foo::Bar
  #     ^^^^^^^^
  class ConstantPathNode < Node
    include _Node

attr_reader parent: Prism::node?
    attr_reader name: Symbol?
    attr_reader delimiter_loc: Location
    attr_reader name_loc: Location

def save_delimiter_loc: (_Repository repository) -> void
    def save_name_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? parent, Symbol? name, Location delimiter_loc, Location name_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?parent: Prism::node?, ?name: Symbol?, ?delimiter_loc: Location, ?name_loc: Location) -> ConstantPathNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, parent: Prism::node?, name: Symbol?, delimiter_loc: Location, name_loc: Location }
    def delimiter: () -> String
    def type: () -> :constant_path_node
            | ...
    def self.type: () -> :constant_path_node
  end

# Represents assigning to a constant path using an operator that isn't `=`.
  #
  #     Parent::Child += value
  #     ^^^^^^^^^^^^^^^^^^^^^^
  class ConstantPathOperatorWriteNode < Node
    include _Node

attr_reader target: ConstantPathNode
    attr_reader binary_operator_loc: Location
    attr_reader value: Prism::node
    attr_reader binary_operator: Symbol

def save_binary_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, ConstantPathNode target, Location binary_operator_loc, Prism::node value, Symbol binary_operator) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> ConstantPathOperatorWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol }
    def type: () -> :constant_path_operator_write_node
            | ...
    def self.type: () -> :constant_path_operator_write_node
  end

# Represents the use of the `||=` operator for assignment to a constant path.
  #
  #     Parent::Child ||= value
  #     ^^^^^^^^^^^^^^^^^^^^^^^
  class ConstantPathOrWriteNode < Node
    include _Node

attr_reader target: ConstantPathNode
    attr_reader operator_loc: Location
    attr_reader value: Prism::node

def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, ConstantPathNode target, Location operator_loc, Prism::node value) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node) -> ConstantPathOrWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, operator_loc: Location, value: Prism::node }
    def operator: () -> String
    def type: () -> :constant_path_or_write_node
            | ...
    def self.type: () -> :constant_path_or_write_node
  end

# Represents writing to a constant path in a context that doesn't have an explicit value.
  #
  #     Foo::Foo, Bar::Bar = baz
  #     ^^^^^^^^  ^^^^^^^^
  class ConstantPathTargetNode < Node
    include _Node

attr_reader parent: Prism::node?
    attr_reader name: Symbol?
    attr_reader delimiter_loc: Location
    attr_reader name_loc: Location

def save_delimiter_loc: (_Repository repository) -> void
    def save_name_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? parent, Symbol? name, Location delimiter_loc, Location name_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?parent: Prism::node?, ?name: Symbol?, ?delimiter_loc: Location, ?name_loc: Location) -> ConstantPathTargetNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, parent: Prism::node?, name: Symbol?, delimiter_loc: Location, name_loc: Location }
    def delimiter: () -> String
    def type: () -> :constant_path_target_node
            | ...
    def self.type: () -> :constant_path_target_node
  end

# Represents writing to a constant path.
  #
  #     ::Foo = 1
  #     ^^^^^^^^^
  #
  #     Foo::Bar = 1
  #     ^^^^^^^^^^^^
  #
  #     ::Foo::Bar = 1
  #     ^^^^^^^^^^^^^^
  class ConstantPathWriteNode < Node
    include _Node

attr_reader target: ConstantPathNode
    attr_reader operator_loc: Location
    attr_reader value: Prism::node

def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, ConstantPathNode target, Location operator_loc, Prism::node value) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node) -> ConstantPathWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, operator_loc: Location, value: Prism::node }
    def operator: () -> String
    def type: () -> :constant_path_write_node
            | ...
    def self.type: () -> :constant_path_write_node
  end

# Represents referencing a constant.
  #
  #     Foo
  #     ^^^
  class ConstantReadNode < Node
    include _Node

attr_reader name: Symbol

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ConstantReadNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
    def type: () -> :constant_read_node
            | ...
    def self.type: () -> :constant_read_node
  end

# Represents writing to a constant in a context that doesn't have an explicit value.
  #
  #     Foo, Bar = baz
  #     ^^^  ^^^
  class ConstantTargetNode < Node
    include _Node

attr_reader name: Symbol

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ConstantTargetNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
    def type: () -> :constant_target_node
            | ...
    def self.type: () -> :constant_target_node
  end

# Represents writing to a constant.
  #
  #     Foo = 1
  #     ^^^^^^^
  class ConstantWriteNode < Node
    include _Node

attr_reader name: Symbol
    attr_reader name_loc: Location
    attr_reader value: Prism::node
    attr_reader operator_loc: Location

def save_name_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Prism::node value, Location operator_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> ConstantWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location }
    def operator: () -> String
    def type: () -> :constant_write_node
            | ...
    def self.type: () -> :constant_write_node
  end

# Represents a method definition.
  #
  #     def method
  #     end
  #     ^^^^^^^^^^
  class DefNode < Node
    include _Node

attr_reader name: Symbol
    attr_reader name_loc: Location
    attr_reader receiver: Prism::node?
    attr_reader parameters: ParametersNode?
    attr_reader body: StatementsNode | BeginNode | nil
    attr_reader locals: Array[Symbol]
    attr_reader def_keyword_loc: Location
    attr_reader operator_loc: Location?
    attr_reader lparen_loc: Location?
    attr_reader rparen_loc: Location?
    attr_reader equal_loc: Location?
    attr_reader end_keyword_loc: Location?

def save_name_loc: (_Repository repository) -> void
    def save_def_keyword_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void
    def save_lparen_loc: (_Repository repository) -> void
    def save_rparen_loc: (_Repository repository) -> void
    def save_equal_loc: (_Repository repository) -> void
    def save_end_keyword_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Prism::node? receiver, ParametersNode? parameters, StatementsNode | BeginNode | nil body, Array[Symbol] locals, Location def_keyword_loc, Location? operator_loc, Location? lparen_loc, Location? rparen_loc, Location? equal_loc, Location? end_keyword_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?receiver: Prism::node?, ?parameters: ParametersNode?, ?body: StatementsNode | BeginNode | nil, ?locals: Array[Symbol], ?def_keyword_loc: Location, ?operator_loc: Location?, ?lparen_loc: Location?, ?rparen_loc: Location?, ?equal_loc: Location?, ?end_keyword_loc: Location?) -> DefNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, receiver: Prism::node?, parameters: ParametersNode?, body: StatementsNode | BeginNode | nil, locals: Array[Symbol], def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location? }
    def def_keyword: () -> String
    def operator: () -> String?
    def lparen: () -> String?
    def rparen: () -> String?
    def equal: () -> String?
    def end_keyword: () -> String?
    def type: () -> :def_node
            | ...
    def self.type: () -> :def_node
  end

# Represents the use of the `defined?` keyword.
  #
  #     defined?(a)
  #     ^^^^^^^^^^^
  class DefinedNode < Node
    include _Node

attr_reader lparen_loc: Location?
    attr_reader value: Prism::node
    attr_reader rparen_loc: Location?
    attr_reader keyword_loc: Location

def save_lparen_loc: (_Repository repository) -> void
    def save_rparen_loc: (_Repository repository) -> void
    def save_keyword_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location? lparen_loc, Prism::node value, Location? rparen_loc, Location keyword_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?lparen_loc: Location?, ?value: Prism::node, ?rparen_loc: Location?, ?keyword_loc: Location) -> DefinedNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, lparen_loc: Location?, value: Prism::node, rparen_loc: Location?, keyword_loc: Location }
    def lparen: () -> String?
    def rparen: () -> String?
    def keyword: () -> String
    def type: () -> :defined_node
            | ...
    def self.type: () -> :defined_node
  end

# Represents an `else` clause in a `case`, `if`, or `unless` statement.
  #
  #     if a then b else c end
  #                 ^^^^^^^^^^
  class ElseNode < Node
    include _Node

attr_reader else_keyword_loc: Location
    attr_reader statements: StatementsNode?
    attr_reader end_keyword_loc: Location?

def save_else_keyword_loc: (_Repository repository) -> void
    def save_end_keyword_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location else_keyword_loc, StatementsNode? statements, Location? end_keyword_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?else_keyword_loc: Location, ?statements: StatementsNode?, ?end_keyword_loc: Location?) -> ElseNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, else_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location? }
    def else_keyword: () -> String
    def end_keyword: () -> String?
    def type: () -> :else_node
            | ...
    def self.type: () -> :else_node
  end

# Represents an interpolated set of statements.
  #
  #     "foo #{bar}"
  #          ^^^^^^
  class EmbeddedStatementsNode < Node
    include _Node

attr_reader opening_loc: Location
    attr_reader statements: StatementsNode?
    attr_reader closing_loc: Location

def save_opening_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location opening_loc, StatementsNode? statements, Location closing_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?statements: StatementsNode?, ?closing_loc: Location) -> EmbeddedStatementsNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, statements: StatementsNode?, closing_loc: Location }
    def opening: () -> String
    def closing: () -> String
    def type: () -> :embedded_statements_node
            | ...
    def self.type: () -> :embedded_statements_node
  end

# Represents an interpolated variable.
  #
  #     "foo #@bar"
  #          ^^^^^
  class EmbeddedVariableNode < Node
    include _Node

attr_reader operator_loc: Location
    attr_reader variable: InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode

def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location operator_loc, InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode variable) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?operator_loc: Location, ?variable: InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode) -> EmbeddedVariableNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, operator_loc: Location, variable: InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode }
    def operator: () -> String
    def type: () -> :embedded_variable_node
            | ...
    def self.type: () -> :embedded_variable_node
  end

# Represents an `ensure` clause in a `begin` statement.
  #
  #     begin
  #       foo
  #     ensure
  #     ^^^^^^
  #       bar
  #     end
  class EnsureNode < Node
    include _Node

attr_reader ensure_keyword_loc: Location
    attr_reader statements: StatementsNode?
    attr_reader end_keyword_loc: Location

def save_ensure_keyword_loc: (_Repository repository) -> void
    def save_end_keyword_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location ensure_keyword_loc, StatementsNode? statements, Location end_keyword_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?ensure_keyword_loc: Location, ?statements: StatementsNode?, ?end_keyword_loc: Location) -> EnsureNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, ensure_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location }
    def ensure_keyword: () -> String
    def end_keyword: () -> String
    def type: () -> :ensure_node
            | ...
    def self.type: () -> :ensure_node
  end

# Represents the use of the literal `false` keyword.
  #
  #     false
  #     ^^^^^
  class FalseNode < Node
    include _Node

def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> FalseNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
    def type: () -> :false_node
            | ...
    def self.type: () -> :false_node
  end

# Represents a find pattern in pattern matching.
  #
  #     foo in *bar, baz, *qux
  #            ^^^^^^^^^^^^^^^
  #
  #     foo in [*bar, baz, *qux]
  #            ^^^^^^^^^^^^^^^^^
  #
  #     foo in Foo(*bar, baz, *qux)
  #            ^^^^^^^^^^^^^^^^^^^^
  #
  #     foo => *bar, baz, *qux
  #            ^^^^^^^^^^^^^^^
  class FindPatternNode < Node
    include _Node

attr_reader constant: ConstantPathNode | ConstantReadNode | nil
    attr_reader left: SplatNode
    attr_reader requireds: Array[Prism::node]
    attr_reader right: SplatNode | MissingNode
    attr_reader opening_loc: Location?
    attr_reader closing_loc: Location?

def save_opening_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, ConstantPathNode | ConstantReadNode | nil constant, SplatNode left, Array[Prism::node] requireds, SplatNode | MissingNode right, Location? opening_loc, Location? closing_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantPathNode | ConstantReadNode | nil, ?left: SplatNode, ?requireds: Array[Prism::node], ?right: SplatNode | MissingNode, ?opening_loc: Location?, ?closing_loc: Location?) -> FindPatternNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantPathNode | ConstantReadNode | nil, left: SplatNode, requireds: Array[Prism::node], right: SplatNode | MissingNode, opening_loc: Location?, closing_loc: Location? }
    def opening: () -> String?
    def closing: () -> String?
    def type: () -> :find_pattern_node
            | ...
    def self.type: () -> :find_pattern_node
  end

# Represents the use of the `..` or `...` operators to create flip flops.
  #
  #     baz if foo .. bar
  #            ^^^^^^^^^^
  class FlipFlopNode < Node
    include _Node

def exclude_end?: () -> bool

attr_reader left: Prism::node?
    attr_reader right: Prism::node?
    attr_reader operator_loc: Location

def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? left, Prism::node? right, Location operator_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node?, ?right: Prism::node?, ?operator_loc: Location) -> FlipFlopNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node?, right: Prism::node?, operator_loc: Location }
    def operator: () -> String
    def type: () -> :flip_flop_node
            | ...
    def self.type: () -> :flip_flop_node
  end

# Represents a floating point number literal.
  #
  #     1.0
  #     ^^^
  class FloatNode < Node
    include _Node

attr_reader value: Float

def initialize: (Source source, Integer node_id, Location location, Integer flags, Float value) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Float) -> FloatNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Float }
    def type: () -> :float_node
            | ...
    def self.type: () -> :float_node
  end

# Represents the use of the `for` keyword.
  #
  #     for i in a end
  #     ^^^^^^^^^^^^^^
  class ForNode < Node
    include _Node

attr_reader index: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode
    attr_reader collection: Prism::node
    attr_reader statements: StatementsNode?
    attr_reader for_keyword_loc: Location
    attr_reader in_keyword_loc: Location
    attr_reader do_keyword_loc: Location?
    attr_reader end_keyword_loc: Location

def save_for_keyword_loc: (_Repository repository) -> void
    def save_in_keyword_loc: (_Repository repository) -> void
    def save_do_keyword_loc: (_Repository repository) -> void
    def save_end_keyword_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode index, Prism::node collection, StatementsNode? statements, Location for_keyword_loc, Location in_keyword_loc, Location? do_keyword_loc, Location end_keyword_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?index: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode, ?collection: Prism::node, ?statements: StatementsNode?, ?for_keyword_loc: Location, ?in_keyword_loc: Location, ?do_keyword_loc: Location?, ?end_keyword_loc: Location) -> ForNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, index: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode, collection: Prism::node, statements: StatementsNode?, for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: Location?, end_keyword_loc: Location }
    def for_keyword: () -> String
    def in_keyword: () -> String
    def do_keyword: () -> String?
    def end_keyword: () -> String
    def type: () -> :for_node
            | ...
    def self.type: () -> :for_node
  end

# Represents forwarding all arguments to this method to another method.
  #
  #     def foo(...)
  #       bar(...)
  #           ^^^
  #     end
  class ForwardingArgumentsNode < Node
    include _Node

def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ForwardingArgumentsNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
    def type: () -> :forwarding_arguments_node
            | ...
    def self.type: () -> :forwarding_arguments_node
  end

# Represents the use of the forwarding parameter in a method, block, or lambda declaration.
  #
  #     def foo(...)
  #             ^^^
  #     end
  class ForwardingParameterNode < Node
    include _Node

def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ForwardingParameterNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
    def type: () -> :forwarding_parameter_node
            | ...
    def self.type: () -> :forwarding_parameter_node
  end

# Represents the use of the `super` keyword without parentheses or arguments, but which might have a block.
  #
  #     super
  #     ^^^^^
  #
  #     super { 123 }
  #     ^^^^^^^^^^^^^
  #
  # If it has any other arguments, it would be a `SuperNode` instead.
  class ForwardingSuperNode < Node
    include _Node

attr_reader block: BlockNode?

def initialize: (Source source, Integer node_id, Location location, Integer flags, BlockNode? block) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?block: BlockNode?) -> ForwardingSuperNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, block: BlockNode? }
    def type: () -> :forwarding_super_node
            | ...
    def self.type: () -> :forwarding_super_node
  end

# Represents the use of the `&&=` operator for assignment to a global variable.
  #
  #     $target &&= value
  #     ^^^^^^^^^^^^^^^^^
  class GlobalVariableAndWriteNode < Node
    include _Node

attr_reader name: Symbol
    attr_reader name_loc: Location
    attr_reader operator_loc: Location
    attr_reader value: Prism::node

def save_name_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location operator_loc, Prism::node value) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> GlobalVariableAndWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
    def operator: () -> String
    def type: () -> :global_variable_and_write_node
            | ...
    def self.type: () -> :global_variable_and_write_node
  end

# Represents assigning to a global variable using an operator that isn't `=`.
  #
  #     $target += value
  #     ^^^^^^^^^^^^^^^^
  class GlobalVariableOperatorWriteNode < Node
    include _Node

attr_reader name: Symbol
    attr_reader name_loc: Location
    attr_reader binary_operator_loc: Location
    attr_reader value: Prism::node
    attr_reader binary_operator: Symbol

def save_name_loc: (_Repository repository) -> void
    def save_binary_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> GlobalVariableOperatorWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol }
    def type: () -> :global_variable_operator_write_node
            | ...
    def self.type: () -> :global_variable_operator_write_node
  end

# Represents the use of the `||=` operator for assignment to a global variable.
  #
  #     $target ||= value
  #     ^^^^^^^^^^^^^^^^^
  class GlobalVariableOrWriteNode < Node
    include _Node

attr_reader name: Symbol
    attr_reader name_loc: Location
    attr_reader operator_loc: Location
    attr_reader value: Prism::node

def save_name_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location operator_loc, Prism::node value) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> GlobalVariableOrWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
    def operator: () -> String
    def type: () -> :global_variable_or_write_node
            | ...
    def self.type: () -> :global_variable_or_write_node
  end

# Represents referencing a global variable.
  #
  #     $foo
  #     ^^^^
  class GlobalVariableReadNode < Node
    include _Node

attr_reader name: Symbol

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> GlobalVariableReadNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
    def type: () -> :global_variable_read_node
            | ...
    def self.type: () -> :global_variable_read_node
  end

# Represents writing to a global variable in a context that doesn't have an explicit value.
  #
  #     $foo, $bar = baz
  #     ^^^^  ^^^^
  class GlobalVariableTargetNode < Node
    include _Node

attr_reader name: Symbol

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> GlobalVariableTargetNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
    def type: () -> :global_variable_target_node
            | ...
    def self.type: () -> :global_variable_target_node
  end

# Represents writing to a global variable.
  #
  #     $foo = 1
  #     ^^^^^^^^
  class GlobalVariableWriteNode < Node
    include _Node

attr_reader name: Symbol
    attr_reader name_loc: Location
    attr_reader value: Prism::node
    attr_reader operator_loc: Location

def save_name_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Prism::node value, Location operator_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> GlobalVariableWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location }
    def operator: () -> String
    def type: () -> :global_variable_write_node
            | ...
    def self.type: () -> :global_variable_write_node
  end

# Represents a hash literal.
  #
  #     { a => b }
  #     ^^^^^^^^^^
  class HashNode < Node
    include _Node

attr_reader opening_loc: Location
    attr_reader elements: Array[AssocNode | AssocSplatNode]
    attr_reader closing_loc: Location

def save_opening_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location opening_loc, Array[AssocNode | AssocSplatNode] elements, Location closing_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?elements: Array[AssocNode | AssocSplatNode], ?closing_loc: Location) -> HashNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, elements: Array[AssocNode | AssocSplatNode], closing_loc: Location }
    def opening: () -> String
    def closing: () -> String
    def type: () -> :hash_node
            | ...
    def self.type: () -> :hash_node
  end

# Represents a hash pattern in pattern matching.
  #
  #     foo => { a: 1, b: 2 }
  #            ^^^^^^^^^^^^^^
  #
  #     foo => { a: 1, b: 2, **c }
  #            ^^^^^^^^^^^^^^^^^^^
  #
  #     foo => Bar[a: 1, b: 2]
  #            ^^^^^^^^^^^^^^^
  #
  #     foo in { a: 1, b: 2 }
  #            ^^^^^^^^^^^^^^
  class HashPatternNode < Node
    include _Node

attr_reader constant: ConstantPathNode | ConstantReadNode | nil
    attr_reader elements: Array[AssocNode]
    attr_reader rest: AssocSplatNode | NoKeywordsParameterNode | nil
    attr_reader opening_loc: Location?
    attr_reader closing_loc: Location?

def save_opening_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, ConstantPathNode | ConstantReadNode | nil constant, Array[AssocNode] elements, AssocSplatNode | NoKeywordsParameterNode | nil rest, Location? opening_loc, Location? closing_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantPathNode | ConstantReadNode | nil, ?elements: Array[AssocNode], ?rest: AssocSplatNode | NoKeywordsParameterNode | nil, ?opening_loc: Location?, ?closing_loc: Location?) -> HashPatternNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantPathNode | ConstantReadNode | nil, elements: Array[AssocNode], rest: AssocSplatNode | NoKeywordsParameterNode | nil, opening_loc: Location?, closing_loc: Location? }
    def opening: () -> String?
    def closing: () -> String?
    def type: () -> :hash_pattern_node
            | ...
    def self.type: () -> :hash_pattern_node
  end

# Represents the use of the `if` keyword, either in the block form or the modifier form, or a ternary expression.
  #
  #     bar if foo
  #     ^^^^^^^^^^
  #
  #     if foo then bar end
  #     ^^^^^^^^^^^^^^^^^^^
  #
  #     foo ? bar : baz
  #     ^^^^^^^^^^^^^^^
  class IfNode < Node
    include _Node

attr_reader if_keyword_loc: Location?
    attr_reader predicate: Prism::node
    attr_reader then_keyword_loc: Location?
    attr_reader statements: StatementsNode?
    attr_reader subsequent: ElseNode | IfNode | nil
    attr_reader end_keyword_loc: Location?

def save_if_keyword_loc: (_Repository repository) -> void
    def save_then_keyword_loc: (_Repository repository) -> void
    def save_end_keyword_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location? if_keyword_loc, Prism::node predicate, Location? then_keyword_loc, StatementsNode? statements, ElseNode | IfNode | nil subsequent, Location? end_keyword_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?if_keyword_loc: Location?, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?subsequent: ElseNode | IfNode | nil, ?end_keyword_loc: Location?) -> IfNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, if_keyword_loc: Location?, predicate: Prism::node, then_keyword_loc: Location?, statements: StatementsNode?, subsequent: ElseNode | IfNode | nil, end_keyword_loc: Location? }
    def if_keyword: () -> String?
    def then_keyword: () -> String?
    def end_keyword: () -> String?
    def type: () -> :if_node
            | ...
    def self.type: () -> :if_node
  end

# Represents an imaginary number literal.
  #
  #     1.0i
  #     ^^^^
  class ImaginaryNode < Node
    include _Node

attr_reader numeric: FloatNode | IntegerNode | RationalNode

def initialize: (Source source, Integer node_id, Location location, Integer flags, FloatNode | IntegerNode | RationalNode numeric) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?numeric: FloatNode | IntegerNode | RationalNode) -> ImaginaryNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, numeric: FloatNode | IntegerNode | RationalNode }
    def type: () -> :imaginary_node
            | ...
    def self.type: () -> :imaginary_node
  end

# Represents a node that is implicitly being added to the tree but doesn't correspond directly to a node in the source.
  #
  #     { foo: }
  #       ^^^^
  #
  #     { Foo: }
  #       ^^^^
  #
  #     foo in { bar: }
  #              ^^^^
  class ImplicitNode < Node
    include _Node

attr_reader value: LocalVariableReadNode | CallNode | ConstantReadNode | LocalVariableTargetNode

def initialize: (Source source, Integer node_id, Location location, Integer flags, LocalVariableReadNode | CallNode | ConstantReadNode | LocalVariableTargetNode value) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: LocalVariableReadNode | CallNode | ConstantReadNode | LocalVariableTargetNode) -> ImplicitNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: LocalVariableReadNode | CallNode | ConstantReadNode | LocalVariableTargetNode }
    def type: () -> :implicit_node
            | ...
    def self.type: () -> :implicit_node
  end

# Represents using a trailing comma to indicate an implicit rest parameter.
  #
  #     foo { |bar,| }
  #               ^
  #
  #     foo in [bar,]
  #                ^
  #
  #     for foo, in bar do end
  #            ^
  #
  #     foo, = bar
  #        ^
  class ImplicitRestNode < Node
    include _Node

def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ImplicitRestNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
    def type: () -> :implicit_rest_node
            | ...
    def self.type: () -> :implicit_rest_node
  end

# Represents the use of the `in` keyword in a case statement.
  #
  #     case a; in b then c end
  #             ^^^^^^^^^^^
  class InNode < Node
    include _Node

attr_reader pattern: Prism::node
    attr_reader statements: StatementsNode?
    attr_reader in_loc: Location
    attr_reader then_loc: Location?

def save_in_loc: (_Repository repository) -> void
    def save_then_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node pattern, StatementsNode? statements, Location in_loc, Location? then_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?pattern: Prism::node, ?statements: StatementsNode?, ?in_loc: Location, ?then_loc: Location?) -> InNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, pattern: Prism::node, statements: StatementsNode?, in_loc: Location, then_loc: Location? }
    def in: () -> String
    def then: () -> String?
    def type: () -> :in_node
            | ...
    def self.type: () -> :in_node
  end

# Represents the use of the `&&=` operator on a call to the `[]` method.
  #
  #     foo.bar[baz] &&= value
  #     ^^^^^^^^^^^^^^^^^^^^^^
  class IndexAndWriteNode < Node
    include _Node

def safe_navigation?: () -> bool
    def variable_call?: () -> bool
    def attribute_write?: () -> bool
    def ignore_visibility?: () -> bool

attr_reader receiver: Prism::node?
    attr_reader call_operator_loc: Location?
    attr_reader opening_loc: Location
    attr_reader arguments: ArgumentsNode?
    attr_reader closing_loc: Location
    attr_reader block: BlockArgumentNode?
    attr_reader operator_loc: Location
    attr_reader value: Prism::node

def save_call_operator_loc: (_Repository repository) -> void
    def save_opening_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, BlockArgumentNode? block, Location operator_loc, Prism::node value) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: BlockArgumentNode?, ?operator_loc: Location, ?value: Prism::node) -> IndexAndWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode?, operator_loc: Location, value: Prism::node }
    def call_operator: () -> String?
    def opening: () -> String
    def closing: () -> String
    def operator: () -> String
    def type: () -> :index_and_write_node
            | ...
    def self.type: () -> :index_and_write_node
  end

# Represents the use of an assignment operator on a call to `[]`.
  #
  #     foo.bar[baz] += value
  #     ^^^^^^^^^^^^^^^^^^^^^
  class IndexOperatorWriteNode < Node
    include _Node

def safe_navigation?: () -> bool
    def variable_call?: () -> bool
    def attribute_write?: () -> bool
    def ignore_visibility?: () -> bool

attr_reader receiver: Prism::node?
    attr_reader call_operator_loc: Location?
    attr_reader opening_loc: Location
    attr_reader arguments: ArgumentsNode?
    attr_reader closing_loc: Location
    attr_reader block: BlockArgumentNode?
    attr_reader binary_operator: Symbol
    attr_reader binary_operator_loc: Location
    attr_reader value: Prism::node

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, BlockArgumentNode? block, Symbol binary_operator, Location binary_operator_loc, Prism::node value) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: BlockArgumentNode?, ?binary_operator: Symbol, ?binary_operator_loc: Location, ?value: Prism::node) -> IndexOperatorWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode?, binary_operator: Symbol, binary_operator_loc: Location, value: Prism::node }
    def call_operator: () -> String?
    def opening: () -> String
    def closing: () -> String
    def type: () -> :index_operator_write_node
            | ...
    def self.type: () -> :index_operator_write_node
  end

# Represents the use of the `||=` operator on a call to `[]`.
  #
  #     foo.bar[baz] ||= value
  #     ^^^^^^^^^^^^^^^^^^^^^^
  class IndexOrWriteNode < Node
    include _Node

def safe_navigation?: () -> bool
    def variable_call?: () -> bool
    def attribute_write?: () -> bool
    def ignore_visibility?: () -> bool

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, BlockArgumentNode? block, Location operator_loc, Prism::node value) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: BlockArgumentNode?, ?operator_loc: Location, ?value: Prism::node) -> IndexOrWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode?, operator_loc: Location, value: Prism::node }
    def call_operator: () -> String?
    def opening: () -> String
    def closing: () -> String
    def operator: () -> String
    def type: () -> :index_or_write_node
            | ...
    def self.type: () -> :index_or_write_node
  end

# Represents assigning to an index.
  #
  #     foo[bar], = 1
  #     ^^^^^^^^
  #
  #     begin
  #     rescue => foo[bar]
  #               ^^^^^^^^
  #     end
  #
  #     for foo[bar] in baz do end
  #         ^^^^^^^^
  class IndexTargetNode < Node
    include _Node

def safe_navigation?: () -> bool
    def variable_call?: () -> bool
    def attribute_write?: () -> bool
    def ignore_visibility?: () -> bool

attr_reader receiver: Prism::node
    attr_reader opening_loc: Location
    attr_reader arguments: ArgumentsNode?
    attr_reader closing_loc: Location
    attr_reader block: BlockArgumentNode?

def save_opening_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node receiver, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, BlockArgumentNode? block) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: BlockArgumentNode?) -> IndexTargetNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode? }
    def opening: () -> String
    def closing: () -> String
    def type: () -> :index_target_node
            | ...
    def self.type: () -> :index_target_node
  end

# Represents the use of the `&&=` operator for assignment to an instance variable.
  #
  #     @target &&= value
  #     ^^^^^^^^^^^^^^^^^
  class InstanceVariableAndWriteNode < Node
    include _Node

attr_reader name: Symbol
    attr_reader name_loc: Location
    attr_reader operator_loc: Location
    attr_reader value: Prism::node

def save_name_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location operator_loc, Prism::node value) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> InstanceVariableAndWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
    def operator: () -> String
    def type: () -> :instance_variable_and_write_node
            | ...
    def self.type: () -> :instance_variable_and_write_node
  end

# Represents assigning to an instance variable using an operator that isn't `=`.
  #
  #     @target += value
  #     ^^^^^^^^^^^^^^^^
  class InstanceVariableOperatorWriteNode < Node
    include _Node

attr_reader name: Symbol
    attr_reader name_loc: Location
    attr_reader binary_operator_loc: Location
    attr_reader value: Prism::node
    attr_reader binary_operator: Symbol

def save_name_loc: (_Repository repository) -> void
    def save_binary_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> InstanceVariableOperatorWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol }
    def type: () -> :instance_variable_operator_write_node
            | ...
    def self.type: () -> :instance_variable_operator_write_node
  end

# Represents the use of the `||=` operator for assignment to an instance variable.
  #
  #     @target ||= value
  #     ^^^^^^^^^^^^^^^^^
  class InstanceVariableOrWriteNode < Node
    include _Node

attr_reader name: Symbol
    attr_reader name_loc: Location
    attr_reader operator_loc: Location
    attr_reader value: Prism::node

def save_name_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location operator_loc, Prism::node value) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> InstanceVariableOrWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
    def operator: () -> String
    def type: () -> :instance_variable_or_write_node
            | ...
    def self.type: () -> :instance_variable_or_write_node
  end

# Represents referencing an instance variable.
  #
  #     @foo
  #     ^^^^
  class InstanceVariableReadNode < Node
    include _Node

attr_reader name: Symbol

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> InstanceVariableReadNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
    def type: () -> :instance_variable_read_node
            | ...
    def self.type: () -> :instance_variable_read_node
  end

# Represents writing to an instance variable in a context that doesn't have an explicit value.
  #
  #     @foo, @bar = baz
  #     ^^^^  ^^^^
  class InstanceVariableTargetNode < Node
    include _Node

attr_reader name: Symbol

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> InstanceVariableTargetNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
    def type: () -> :instance_variable_target_node
            | ...
    def self.type: () -> :instance_variable_target_node
  end

# Represents writing to an instance variable.
  #
  #     @foo = 1
  #     ^^^^^^^^
  class InstanceVariableWriteNode < Node
    include _Node

attr_reader name: Symbol
    attr_reader name_loc: Location
    attr_reader value: Prism::node
    attr_reader operator_loc: Location

def save_name_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Prism::node value, Location operator_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> InstanceVariableWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location }
    def operator: () -> String
    def type: () -> :instance_variable_write_node
            | ...
    def self.type: () -> :instance_variable_write_node
  end

# Represents an integer number literal.
  #
  #     1
  #     ^
  class IntegerNode < Node
    include _Node

def binary?: () -> bool
    def decimal?: () -> bool
    def octal?: () -> bool
    def hexadecimal?: () -> bool

attr_reader value: Integer

def initialize: (Source source, Integer node_id, Location location, Integer flags, Integer value) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Integer) -> IntegerNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Integer }
    def type: () -> :integer_node
            | ...
    def self.type: () -> :integer_node
  end

# Represents a regular expression literal that contains interpolation that is being used in the predicate of a conditional to implicitly match against the last line read by an IO object.
  #
  #     if /foo #{bar} baz/ then end
  #        ^^^^^^^^^^^^^^^^
  class InterpolatedMatchLastLineNode < Node
    include _Node

def ignore_case?: () -> bool
    def extended?: () -> bool
    def multi_line?: () -> bool
    def once?: () -> bool
    def euc_jp?: () -> bool
    def ascii_8bit?: () -> bool
    def windows_31j?: () -> bool
    def utf_8?: () -> bool
    def forced_utf8_encoding?: () -> bool
    def forced_binary_encoding?: () -> bool
    def forced_us_ascii_encoding?: () -> bool

attr_reader opening_loc: Location
    attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
    attr_reader closing_loc: Location

def save_opening_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] parts, Location closing_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location) -> InterpolatedMatchLastLineNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location }
    def opening: () -> String
    def closing: () -> String
    def type: () -> :interpolated_match_last_line_node
            | ...
    def self.type: () -> :interpolated_match_last_line_node
  end

# Represents a regular expression literal that contains interpolation.
  #
  #     /foo #{bar} baz/
  #     ^^^^^^^^^^^^^^^^
  class InterpolatedRegularExpressionNode < Node
    include _Node

attr_reader opening_loc: Location
    attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
    attr_reader closing_loc: Location

def save_opening_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] parts, Location closing_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location) -> InterpolatedRegularExpressionNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location }
    def opening: () -> String
    def closing: () -> String
    def type: () -> :interpolated_regular_expression_node
            | ...
    def self.type: () -> :interpolated_regular_expression_node
  end

# Represents a string literal that contains interpolation.
  #
  #     "foo #{bar} baz"
  #     ^^^^^^^^^^^^^^^^
  class InterpolatedStringNode < Node
    include _Node

def frozen?: () -> bool
    def mutable?: () -> bool

def save_opening_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location? opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode | XStringNode | InterpolatedXStringNode | SymbolNode | InterpolatedSymbolNode] parts, Location? closing_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode | XStringNode | InterpolatedXStringNode | SymbolNode | InterpolatedSymbolNode], ?closing_loc: Location?) -> InterpolatedStringNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode | XStringNode | InterpolatedXStringNode | SymbolNode | InterpolatedSymbolNode], closing_loc: Location? }
    def opening: () -> String?
    def closing: () -> String?
    def type: () -> :interpolated_string_node
            | ...
    def self.type: () -> :interpolated_string_node
  end

# Represents a symbol literal that contains interpolation.
  #
  #     :"foo #{bar} baz"
  #     ^^^^^^^^^^^^^^^^^
  class InterpolatedSymbolNode < Node
    include _Node

attr_reader opening_loc: Location?
    attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
    attr_reader closing_loc: Location?

def save_opening_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location? opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] parts, Location? closing_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location?) -> InterpolatedSymbolNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location? }
    def opening: () -> String?
    def closing: () -> String?
    def type: () -> :interpolated_symbol_node
            | ...
    def self.type: () -> :interpolated_symbol_node
  end

# Represents an xstring literal that contains interpolation.
  #
  #     `foo #{bar} baz`
  #     ^^^^^^^^^^^^^^^^
  class InterpolatedXStringNode < Node
    include _Node

attr_reader opening_loc: Location
    attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
    attr_reader closing_loc: Location

def save_opening_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] parts, Location closing_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location) -> InterpolatedXStringNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location }
    def opening: () -> String
    def closing: () -> String
    def type: () -> :interpolated_x_string_node
            | ...
    def self.type: () -> :interpolated_x_string_node
  end

# Represents reading from the implicit `it` local variable.
  #
  #     -> { it }
  #          ^^
  class ItLocalVariableReadNode < Node
    include _Node

def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ItLocalVariableReadNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
    def type: () -> :it_local_variable_read_node
            | ...
    def self.type: () -> :it_local_variable_read_node
  end

# Represents an implicit set of parameters through the use of the `it` keyword within a block or lambda.
  #
  #     -> { it + it }
  #     ^^^^^^^^^^^^^^
  class ItParametersNode < Node
    include _Node

def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ItParametersNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
    def type: () -> :it_parameters_node
            | ...
    def self.type: () -> :it_parameters_node
  end

# Represents a hash literal without opening and closing braces.
  #
  #     foo(a: b)
  #         ^^^^
  class KeywordHashNode < Node
    include _Node

def symbol_keys?: () -> bool

attr_reader elements: Array[AssocNode | AssocSplatNode]

def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[AssocNode | AssocSplatNode] elements) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?elements: Array[AssocNode | AssocSplatNode]) -> KeywordHashNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, elements: Array[AssocNode | AssocSplatNode] }
    def type: () -> :keyword_hash_node
            | ...
    def self.type: () -> :keyword_hash_node
  end

# Represents a keyword rest parameter to a method, block, or lambda definition.
  #
  #     def a(**b)
  #           ^^^
  #     end
  class KeywordRestParameterNode < Node
    include _Node

def repeated_parameter?: () -> bool

attr_reader name: Symbol?
    attr_reader name_loc: Location?
    attr_reader operator_loc: Location

def save_name_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol? name, Location? name_loc, Location operator_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location) -> KeywordRestParameterNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol?, name_loc: Location?, operator_loc: Location }
    def operator: () -> String
    def type: () -> :keyword_rest_parameter_node
            | ...
    def self.type: () -> :keyword_rest_parameter_node
  end

# Represents using a lambda literal (not the lambda method call).
  #
  #     ->(value) { value * 2 }
  #     ^^^^^^^^^^^^^^^^^^^^^^^
  class LambdaNode < Node
    include _Node

attr_reader locals: Array[Symbol]
    attr_reader operator_loc: Location
    attr_reader opening_loc: Location
    attr_reader closing_loc: Location
    attr_reader parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil
    attr_reader body: StatementsNode | BeginNode | nil

def save_operator_loc: (_Repository repository) -> void
    def save_opening_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[Symbol] locals, Location operator_loc, Location opening_loc, Location closing_loc, BlockParametersNode | NumberedParametersNode | ItParametersNode | nil parameters, StatementsNode | BeginNode | nil body) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?operator_loc: Location, ?opening_loc: Location, ?closing_loc: Location, ?parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, ?body: StatementsNode | BeginNode | nil) -> LambdaNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, body: StatementsNode | BeginNode | nil }
    def operator: () -> String
    def opening: () -> String
    def closing: () -> String
    def type: () -> :lambda_node
            | ...
    def self.type: () -> :lambda_node
  end

# Represents the use of the `&&=` operator for assignment to a local variable.
  #
  #     target &&= value
  #     ^^^^^^^^^^^^^^^^
  class LocalVariableAndWriteNode < Node
    include _Node

attr_reader name_loc: Location
    attr_reader operator_loc: Location
    attr_reader value: Prism::node
    attr_reader name: Symbol
    attr_reader depth: Integer

def save_name_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location name_loc, Location operator_loc, Prism::node value, Symbol name, Integer depth) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?depth: Integer) -> LocalVariableAndWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name_loc: Location, operator_loc: Location, value: Prism::node, name: Symbol, depth: Integer }
    def operator: () -> String
    def type: () -> :local_variable_and_write_node
            | ...
    def self.type: () -> :local_variable_and_write_node
  end

# Represents assigning to a local variable using an operator that isn't `=`.
  #
  #     target += value
  #     ^^^^^^^^^^^^^^^
  class LocalVariableOperatorWriteNode < Node
    include _Node

attr_reader name_loc: Location
    attr_reader binary_operator_loc: Location
    attr_reader value: Prism::node
    attr_reader name: Symbol
    attr_reader binary_operator: Symbol
    attr_reader depth: Integer

def save_name_loc: (_Repository repository) -> void
    def save_binary_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol name, Symbol binary_operator, Integer depth) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?binary_operator: Symbol, ?depth: Integer) -> LocalVariableOperatorWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name_loc: Location, binary_operator_loc: Location, value: Prism::node, name: Symbol, binary_operator: Symbol, depth: Integer }
    def type: () -> :local_variable_operator_write_node
            | ...
    def self.type: () -> :local_variable_operator_write_node
  end

# Represents the use of the `||=` operator for assignment to a local variable.
  #
  #     target ||= value
  #     ^^^^^^^^^^^^^^^^
  class LocalVariableOrWriteNode < Node
    include _Node

attr_reader name_loc: Location
    attr_reader operator_loc: Location
    attr_reader value: Prism::node
    attr_reader name: Symbol
    attr_reader depth: Integer

def save_name_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location name_loc, Location operator_loc, Prism::node value, Symbol name, Integer depth) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?depth: Integer) -> LocalVariableOrWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name_loc: Location, operator_loc: Location, value: Prism::node, name: Symbol, depth: Integer }
    def operator: () -> String
    def type: () -> :local_variable_or_write_node
            | ...
    def self.type: () -> :local_variable_or_write_node
  end

# Represents reading a local variable. Note that this requires that a local variable of the same name has already been written to in the same scope, otherwise it is parsed as a method call.
  #
  #     foo
  #     ^^^
  class LocalVariableReadNode < Node
    include _Node

attr_reader name: Symbol
    attr_reader depth: Integer

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Integer depth) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?depth: Integer) -> LocalVariableReadNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, depth: Integer }
    def type: () -> :local_variable_read_node
            | ...
    def self.type: () -> :local_variable_read_node
  end

# Represents writing to a local variable in a context that doesn't have an explicit value.
  #
  #     foo, bar = baz
  #     ^^^  ^^^
  #
  #     foo => baz
  #            ^^^
  class LocalVariableTargetNode < Node
    include _Node

attr_reader name: Symbol
    attr_reader depth: Integer

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Integer depth) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?depth: Integer) -> LocalVariableTargetNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, depth: Integer }
    def type: () -> :local_variable_target_node
            | ...
    def self.type: () -> :local_variable_target_node
  end

# Represents writing to a local variable.
  #
  #     foo = 1
  #     ^^^^^^^
  class LocalVariableWriteNode < Node
    include _Node

attr_reader name: Symbol
    attr_reader depth: Integer
    attr_reader name_loc: Location
    attr_reader value: Prism::node
    attr_reader operator_loc: Location

def save_name_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Integer depth, Location name_loc, Prism::node value, Location operator_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?depth: Integer, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> LocalVariableWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, depth: Integer, name_loc: Location, value: Prism::node, operator_loc: Location }
    def operator: () -> String
    def type: () -> :local_variable_write_node
            | ...
    def self.type: () -> :local_variable_write_node
  end

# Represents a regular expression literal used in the predicate of a conditional to implicitly match against the last line read by an IO object.
  #
  #     if /foo/i then end
  #        ^^^^^^
  class MatchLastLineNode < Node
    include _Node

attr_reader opening_loc: Location
    attr_reader content_loc: Location
    attr_reader closing_loc: Location
    attr_reader unescaped: String

def save_opening_loc: (_Repository repository) -> void
    def save_content_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location opening_loc, Location content_loc, Location closing_loc, String unescaped) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String) -> MatchLastLineNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String }
    def opening: () -> String
    def content: () -> String
    def closing: () -> String
    def type: () -> :match_last_line_node
            | ...
    def self.type: () -> :match_last_line_node
  end

# Represents the use of the modifier `in` operator.
  #
  #     foo in bar
  #     ^^^^^^^^^^
  class MatchPredicateNode < Node
    include _Node

attr_reader value: Prism::node
    attr_reader pattern: Prism::node
    attr_reader operator_loc: Location

def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node value, Prism::node pattern, Location operator_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?pattern: Prism::node, ?operator_loc: Location) -> MatchPredicateNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node, pattern: Prism::node, operator_loc: Location }
    def operator: () -> String
    def type: () -> :match_predicate_node
            | ...
    def self.type: () -> :match_predicate_node
  end

# Represents the use of the `=>` operator.
  #
  #     foo => bar
  #     ^^^^^^^^^^
  class MatchRequiredNode < Node
    include _Node

attr_reader value: Prism::node
    attr_reader pattern: Prism::node
    attr_reader operator_loc: Location

def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node value, Prism::node pattern, Location operator_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?pattern: Prism::node, ?operator_loc: Location) -> MatchRequiredNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node, pattern: Prism::node, operator_loc: Location }
    def operator: () -> String
    def type: () -> :match_required_node
            | ...
    def self.type: () -> :match_required_node
  end

# Represents writing local variables using a regular expression match with named capture groups.
  #
  #     /(?<foo>bar)/ =~ baz
  #     ^^^^^^^^^^^^^^^^^^^^
  class MatchWriteNode < Node
    include _Node

attr_reader call: CallNode
    attr_reader targets: Array[LocalVariableTargetNode]

def initialize: (Source source, Integer node_id, Location location, Integer flags, CallNode call, Array[LocalVariableTargetNode] targets) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?call: CallNode, ?targets: Array[LocalVariableTargetNode]) -> MatchWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, call: CallNode, targets: Array[LocalVariableTargetNode] }
    def type: () -> :match_write_node
            | ...
    def self.type: () -> :match_write_node
  end

# Represents a node that is missing from the source and results in a syntax error.
  class MissingNode < Node
    include _Node

def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> MissingNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
    def type: () -> :missing_node
            | ...
    def self.type: () -> :missing_node
  end

# Represents a module declaration involving the `module` keyword.
  #
  #     module Foo end
  #     ^^^^^^^^^^^^^^
  class ModuleNode < Node
    include _Node

attr_reader locals: Array[Symbol]
    attr_reader module_keyword_loc: Location
    attr_reader constant_path: ConstantReadNode | ConstantPathNode | MissingNode
    attr_reader body: StatementsNode | BeginNode | nil
    attr_reader end_keyword_loc: Location
    attr_reader name: Symbol

def save_module_keyword_loc: (_Repository repository) -> void
    def save_end_keyword_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[Symbol] locals, Location module_keyword_loc, ConstantReadNode | ConstantPathNode | MissingNode constant_path, StatementsNode | BeginNode | nil body, Location end_keyword_loc, Symbol name) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?module_keyword_loc: Location, ?constant_path: ConstantReadNode | ConstantPathNode | MissingNode, ?body: StatementsNode | BeginNode | nil, ?end_keyword_loc: Location, ?name: Symbol) -> ModuleNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], module_keyword_loc: Location, constant_path: ConstantReadNode | ConstantPathNode | MissingNode, body: StatementsNode | BeginNode | nil, end_keyword_loc: Location, name: Symbol }
    def module_keyword: () -> String
    def end_keyword: () -> String
    def type: () -> :module_node
            | ...
    def self.type: () -> :module_node
  end

# Represents a multi-target expression.
  #
  #     a, (b, c) = 1, 2, 3
  #        ^^^^^^
  #
  # This can be a part of `MultiWriteNode` as above, or the target of a `for` loop
  #
  #     for a, b in [[1, 2], [3, 4]]
  #         ^^^^
  class MultiTargetNode < Node
    include _Node

def save_lparen_loc: (_Repository repository) -> void
    def save_rparen_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode] lefts, ImplicitRestNode | SplatNode | nil rest, Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode] rights, Location? lparen_loc, Location? rparen_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], ?rest: ImplicitRestNode | SplatNode | nil, ?rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], ?lparen_loc: Location?, ?rparen_loc: Location?) -> MultiTargetNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], rest: ImplicitRestNode | SplatNode | nil, rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], lparen_loc: Location?, rparen_loc: Location? }
    def lparen: () -> String?
    def rparen: () -> String?
    def type: () -> :multi_target_node
            | ...
    def self.type: () -> :multi_target_node
  end

# Represents a write to a multi-target expression.
  #
  #     a, b, c = 1, 2, 3
  #     ^^^^^^^^^^^^^^^^^
  class MultiWriteNode < Node
    include _Node

def save_lparen_loc: (_Repository repository) -> void
    def save_rparen_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode] lefts, ImplicitRestNode | SplatNode | nil rest, Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode] rights, Location? lparen_loc, Location? rparen_loc, Location operator_loc, Prism::node value) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode], ?rest: ImplicitRestNode | SplatNode | nil, ?rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode], ?lparen_loc: Location?, ?rparen_loc: Location?, ?operator_loc: Location, ?value: Prism::node) -> MultiWriteNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode], rest: ImplicitRestNode | SplatNode | nil, rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode], lparen_loc: Location?, rparen_loc: Location?, operator_loc: Location, value: Prism::node }
    def lparen: () -> String?
    def rparen: () -> String?
    def operator: () -> String
    def type: () -> :multi_write_node
            | ...
    def self.type: () -> :multi_write_node
  end

# Represents the use of the `next` keyword.
  #
  #     next 1
  #     ^^^^^^
  class NextNode < Node
    include _Node

attr_reader arguments: ArgumentsNode?
    attr_reader keyword_loc: Location

def save_keyword_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, ArgumentsNode? arguments, Location keyword_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?arguments: ArgumentsNode?, ?keyword_loc: Location) -> NextNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, arguments: ArgumentsNode?, keyword_loc: Location }
    def keyword: () -> String
    def type: () -> :next_node
            | ...
    def self.type: () -> :next_node
  end

# Represents the use of the `nil` keyword.
  #
  #     nil
  #     ^^^
  class NilNode < Node
    include _Node

def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> NilNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
    def type: () -> :nil_node
            | ...
    def self.type: () -> :nil_node
  end

# Represents the use of `**nil` inside method arguments.
  #
  #     def a(**nil)
  #           ^^^^^
  #     end
  class NoKeywordsParameterNode < Node
    include _Node

attr_reader operator_loc: Location
    attr_reader keyword_loc: Location

def save_operator_loc: (_Repository repository) -> void
    def save_keyword_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location operator_loc, Location keyword_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?operator_loc: Location, ?keyword_loc: Location) -> NoKeywordsParameterNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, operator_loc: Location, keyword_loc: Location }
    def operator: () -> String
    def keyword: () -> String
    def type: () -> :no_keywords_parameter_node
            | ...
    def self.type: () -> :no_keywords_parameter_node
  end

# Represents an implicit set of parameters through the use of numbered parameters within a block or lambda.
  #
  #     -> { _1 + _2 }
  #     ^^^^^^^^^^^^^^
  class NumberedParametersNode < Node
    include _Node

attr_reader maximum: Integer

def initialize: (Source source, Integer node_id, Location location, Integer flags, Integer maximum) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?maximum: Integer) -> NumberedParametersNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, maximum: Integer }
    def type: () -> :numbered_parameters_node
            | ...
    def self.type: () -> :numbered_parameters_node
  end

# Represents reading a numbered reference to a capture in the previous match.
  #
  #     $1
  #     ^^
  class NumberedReferenceReadNode < Node
    include _Node

attr_reader number: Integer

def initialize: (Source source, Integer node_id, Location location, Integer flags, Integer number) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?number: Integer) -> NumberedReferenceReadNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, number: Integer }
    def type: () -> :numbered_reference_read_node
            | ...
    def self.type: () -> :numbered_reference_read_node
  end

# Represents an optional keyword parameter to a method, block, or lambda definition.
  #
  #     def a(b: 1)
  #           ^^^^
  #     end
  class OptionalKeywordParameterNode < Node
    include _Node

def repeated_parameter?: () -> bool

attr_reader name: Symbol
    attr_reader name_loc: Location
    attr_reader value: Prism::node

def save_name_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Prism::node value) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node) -> OptionalKeywordParameterNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node }
    def type: () -> :optional_keyword_parameter_node
            | ...
    def self.type: () -> :optional_keyword_parameter_node
  end

# Represents an optional parameter to a method, block, or lambda definition.
  #
  #     def a(b = 1)
  #           ^^^^^
  #     end
  class OptionalParameterNode < Node
    include _Node

def repeated_parameter?: () -> bool

attr_reader name: Symbol
    attr_reader name_loc: Location
    attr_reader operator_loc: Location
    attr_reader value: Prism::node

def save_name_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc, Location operator_loc, Prism::node value) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> OptionalParameterNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node }
    def operator: () -> String
    def type: () -> :optional_parameter_node
            | ...
    def self.type: () -> :optional_parameter_node
  end

# Represents the use of the `||` operator or the `or` keyword.
  #
  #     left or right
  #     ^^^^^^^^^^^^^
  class OrNode < Node
    include _Node

attr_reader left: Prism::node
    attr_reader right: Prism::node
    attr_reader operator_loc: Location

def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node left, Prism::node right, Location operator_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node, ?right: Prism::node, ?operator_loc: Location) -> OrNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node, right: Prism::node, operator_loc: Location }
    def operator: () -> String
    def type: () -> :or_node
            | ...
    def self.type: () -> :or_node
  end

# Represents the list of parameters on a method, block, or lambda definition.
  #
  #     def a(b, c, d)
  #           ^^^^^^^
  #     end
  class ParametersNode < Node
    include _Node

attr_reader requireds: Array[RequiredParameterNode | MultiTargetNode]
    attr_reader optionals: Array[OptionalParameterNode]
    attr_reader rest: RestParameterNode | ImplicitRestNode | nil
    attr_reader posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode]
    attr_reader keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode]
    attr_reader keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil
    attr_reader block: BlockParameterNode?

def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[RequiredParameterNode | MultiTargetNode] requireds, Array[OptionalParameterNode] optionals, RestParameterNode | ImplicitRestNode | nil rest, Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode] posts, Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode] keywords, KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil keyword_rest, BlockParameterNode? block) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?requireds: Array[RequiredParameterNode | MultiTargetNode], ?optionals: Array[OptionalParameterNode], ?rest: RestParameterNode | ImplicitRestNode | nil, ?posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode], ?keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], ?keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, ?block: BlockParameterNode?) -> ParametersNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, requireds: Array[RequiredParameterNode | MultiTargetNode], optionals: Array[OptionalParameterNode], rest: RestParameterNode | ImplicitRestNode | nil, posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode], keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, block: BlockParameterNode? }
    def type: () -> :parameters_node
            | ...
    def self.type: () -> :parameters_node
  end

# Represents a parenthesized expression
  #
  #     (10 + 34)
  #     ^^^^^^^^^
  class ParenthesesNode < Node
    include _Node

def multiple_statements?: () -> bool

attr_reader body: Prism::node?
    attr_reader opening_loc: Location
    attr_reader closing_loc: Location

def save_opening_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? body, Location opening_loc, Location closing_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?body: Prism::node?, ?opening_loc: Location, ?closing_loc: Location) -> ParenthesesNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, body: Prism::node?, opening_loc: Location, closing_loc: Location }
    def opening: () -> String
    def closing: () -> String
    def type: () -> :parentheses_node
            | ...
    def self.type: () -> :parentheses_node
  end

# Represents the use of the `^` operator for pinning an expression in a pattern matching expression.
  #
  #     foo in ^(bar)
  #            ^^^^^^
  class PinnedExpressionNode < Node
    include _Node

attr_reader expression: Prism::node
    attr_reader operator_loc: Location
    attr_reader lparen_loc: Location
    attr_reader rparen_loc: Location

def save_operator_loc: (_Repository repository) -> void
    def save_lparen_loc: (_Repository repository) -> void
    def save_rparen_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node expression, Location operator_loc, Location lparen_loc, Location rparen_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?expression: Prism::node, ?operator_loc: Location, ?lparen_loc: Location, ?rparen_loc: Location) -> PinnedExpressionNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, expression: Prism::node, operator_loc: Location, lparen_loc: Location, rparen_loc: Location }
    def operator: () -> String
    def lparen: () -> String
    def rparen: () -> String
    def type: () -> :pinned_expression_node
            | ...
    def self.type: () -> :pinned_expression_node
  end

# Represents the use of the `^` operator for pinning a variable in a pattern matching expression.
  #
  #     foo in ^bar
  #            ^^^^
  class PinnedVariableNode < Node
    include _Node

def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, LocalVariableReadNode | InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | ItLocalVariableReadNode | MissingNode variable, Location operator_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?variable: LocalVariableReadNode | InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | ItLocalVariableReadNode | MissingNode, ?operator_loc: Location) -> PinnedVariableNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, variable: LocalVariableReadNode | InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | ItLocalVariableReadNode | MissingNode, operator_loc: Location }
    def operator: () -> String
    def type: () -> :pinned_variable_node
            | ...
    def self.type: () -> :pinned_variable_node
  end

# Represents the use of the `END` keyword.
  #
  #     END { foo }
  #     ^^^^^^^^^^^
  class PostExecutionNode < Node
    include _Node

attr_reader statements: StatementsNode?
    attr_reader keyword_loc: Location
    attr_reader opening_loc: Location
    attr_reader closing_loc: Location

def save_keyword_loc: (_Repository repository) -> void
    def save_opening_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, StatementsNode? statements, Location keyword_loc, Location opening_loc, Location closing_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?statements: StatementsNode?, ?keyword_loc: Location, ?opening_loc: Location, ?closing_loc: Location) -> PostExecutionNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location }
    def keyword: () -> String
    def opening: () -> String
    def closing: () -> String
    def type: () -> :post_execution_node
            | ...
    def self.type: () -> :post_execution_node
  end

# Represents the use of the `BEGIN` keyword.
  #
  #     BEGIN { foo }
  #     ^^^^^^^^^^^^^
  class PreExecutionNode < Node
    include _Node

attr_reader statements: StatementsNode?
    attr_reader keyword_loc: Location
    attr_reader opening_loc: Location
    attr_reader closing_loc: Location

def save_keyword_loc: (_Repository repository) -> void
    def save_opening_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, StatementsNode? statements, Location keyword_loc, Location opening_loc, Location closing_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?statements: StatementsNode?, ?keyword_loc: Location, ?opening_loc: Location, ?closing_loc: Location) -> PreExecutionNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location }
    def keyword: () -> String
    def opening: () -> String
    def closing: () -> String
    def type: () -> :pre_execution_node
            | ...
    def self.type: () -> :pre_execution_node
  end

# The top level node of any parse tree.
  class ProgramNode < Node
    include _Node

attr_reader locals: Array[Symbol]
    attr_reader statements: StatementsNode

def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[Symbol] locals, StatementsNode statements) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?statements: StatementsNode) -> ProgramNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], statements: StatementsNode }
    def type: () -> :program_node
            | ...
    def self.type: () -> :program_node
  end

# Represents the use of the `..` or `...` operators.
  #
  #     1..2
  #     ^^^^
  #
  #     c if a =~ /left/ ... b =~ /right/
  #          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  class RangeNode < Node
    include _Node

def exclude_end?: () -> bool

attr_reader left: Prism::node?
    attr_reader right: Prism::node?
    attr_reader operator_loc: Location

def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node? left, Prism::node? right, Location operator_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node?, ?right: Prism::node?, ?operator_loc: Location) -> RangeNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node?, right: Prism::node?, operator_loc: Location }
    def operator: () -> String
    def type: () -> :range_node
            | ...
    def self.type: () -> :range_node
  end

# Represents a rational number literal.
  #
  #     1.0r
  #     ^^^^
  class RationalNode < Node
    include _Node

def binary?: () -> bool
    def decimal?: () -> bool
    def octal?: () -> bool
    def hexadecimal?: () -> bool

attr_reader numerator: Integer
    attr_reader denominator: Integer

def initialize: (Source source, Integer node_id, Location location, Integer flags, Integer numerator, Integer denominator) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?numerator: Integer, ?denominator: Integer) -> RationalNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, numerator: Integer, denominator: Integer }
    def type: () -> :rational_node
            | ...
    def self.type: () -> :rational_node
  end

# Represents the use of the `redo` keyword.
  #
  #     redo
  #     ^^^^
  class RedoNode < Node
    include _Node

def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> RedoNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
    def type: () -> :redo_node
            | ...
    def self.type: () -> :redo_node
  end

# Represents a regular expression literal with no interpolation.
  #
  #     /foo/i
  #     ^^^^^^
  class RegularExpressionNode < Node
    include _Node

attr_reader opening_loc: Location
    attr_reader content_loc: Location
    attr_reader closing_loc: Location
    attr_reader unescaped: String

def save_opening_loc: (_Repository repository) -> void
    def save_content_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location opening_loc, Location content_loc, Location closing_loc, String unescaped) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String) -> RegularExpressionNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String }
    def opening: () -> String
    def content: () -> String
    def closing: () -> String
    def type: () -> :regular_expression_node
            | ...
    def self.type: () -> :regular_expression_node
  end

# Represents a required keyword parameter to a method, block, or lambda definition.
  #
  #     def a(b: )
  #           ^^
  #     end
  class RequiredKeywordParameterNode < Node
    include _Node

def repeated_parameter?: () -> bool

attr_reader name: Symbol
    attr_reader name_loc: Location

def save_name_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name, Location name_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location) -> RequiredKeywordParameterNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location }
    def type: () -> :required_keyword_parameter_node
            | ...
    def self.type: () -> :required_keyword_parameter_node
  end

# Represents a required parameter to a method, block, or lambda definition.
  #
  #     def a(b)
  #           ^
  #     end
  class RequiredParameterNode < Node
    include _Node

def repeated_parameter?: () -> bool

attr_reader name: Symbol

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol name) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> RequiredParameterNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol }
    def type: () -> :required_parameter_node
            | ...
    def self.type: () -> :required_parameter_node
  end

# Represents an expression modified with a rescue.
  #
  #     foo rescue nil
  #     ^^^^^^^^^^^^^^
  class RescueModifierNode < Node
    include _Node

attr_reader expression: Prism::node
    attr_reader keyword_loc: Location
    attr_reader rescue_expression: Prism::node

def save_keyword_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Prism::node expression, Location keyword_loc, Prism::node rescue_expression) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?expression: Prism::node, ?keyword_loc: Location, ?rescue_expression: Prism::node) -> RescueModifierNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, expression: Prism::node, keyword_loc: Location, rescue_expression: Prism::node }
    def keyword: () -> String
    def type: () -> :rescue_modifier_node
            | ...
    def self.type: () -> :rescue_modifier_node
  end

# Represents a rescue statement.
  #
  #     begin
  #     rescue Foo, *splat, Bar => ex
  #       foo
  #     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  #     end
  #
  # `Foo, *splat, Bar` are in the `exceptions` field. `ex` is in the `reference` field.
  class RescueNode < Node
    include _Node

attr_reader keyword_loc: Location
    attr_reader exceptions: Array[Prism::node]
    attr_reader operator_loc: Location?
    attr_reader reference: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode | nil
    attr_reader then_keyword_loc: Location?
    attr_reader statements: StatementsNode?
    attr_reader subsequent: RescueNode?

def save_keyword_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void
    def save_then_keyword_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Array[Prism::node] exceptions, Location? operator_loc, LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode | nil reference, Location? then_keyword_loc, StatementsNode? statements, RescueNode? subsequent) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?exceptions: Array[Prism::node], ?operator_loc: Location?, ?reference: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode | nil, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?subsequent: RescueNode?) -> RescueNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, exceptions: Array[Prism::node], operator_loc: Location?, reference: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode | nil, then_keyword_loc: Location?, statements: StatementsNode?, subsequent: RescueNode? }
    def keyword: () -> String
    def operator: () -> String?
    def then_keyword: () -> String?
    def type: () -> :rescue_node
            | ...
    def self.type: () -> :rescue_node
  end

# Represents a rest parameter to a method, block, or lambda definition.
  #
  #     def a(*b)
  #           ^^
  #     end
  class RestParameterNode < Node
    include _Node

def repeated_parameter?: () -> bool

attr_reader name: Symbol?
    attr_reader name_loc: Location?
    attr_reader operator_loc: Location

def save_name_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Symbol? name, Location? name_loc, Location operator_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location) -> RestParameterNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol?, name_loc: Location?, operator_loc: Location }
    def operator: () -> String
    def type: () -> :rest_parameter_node
            | ...
    def self.type: () -> :rest_parameter_node
  end

# Represents the use of the `retry` keyword.
  #
  #     retry
  #     ^^^^^
  class RetryNode < Node
    include _Node

def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> RetryNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
    def type: () -> :retry_node
            | ...
    def self.type: () -> :retry_node
  end

# Represents the use of the `return` keyword.
  #
  #     return 1
  #     ^^^^^^^^
  class ReturnNode < Node
    include _Node

attr_reader keyword_loc: Location
    attr_reader arguments: ArgumentsNode?

def save_keyword_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, ArgumentsNode? arguments) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?arguments: ArgumentsNode?) -> ReturnNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, arguments: ArgumentsNode? }
    def keyword: () -> String
    def type: () -> :return_node
            | ...
    def self.type: () -> :return_node
  end

# Represents the `self` keyword.
  #
  #     self
  #     ^^^^
  class SelfNode < Node
    include _Node

def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> SelfNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
    def type: () -> :self_node
            | ...
    def self.type: () -> :self_node
  end

# This node wraps a constant write to indicate that when the value is written, it should have its shareability state modified.
  #
  #     # shareable_constant_value: literal
  #     C = { a: 1 }
  #     ^^^^^^^^^^^^
  class ShareableConstantNode < Node
    include _Node

def literal?: () -> bool
    def experimental_everything?: () -> bool
    def experimental_copy?: () -> bool

def initialize: (Source source, Integer node_id, Location location, Integer flags, ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode write) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?write: ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode) -> ShareableConstantNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, write: ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode }
    def type: () -> :shareable_constant_node
            | ...
    def self.type: () -> :shareable_constant_node
  end

# Represents a singleton class declaration involving the `class` keyword.
  #
  #     class << self end
  #     ^^^^^^^^^^^^^^^^^
  class SingletonClassNode < Node
    include _Node

attr_reader locals: Array[Symbol]
    attr_reader class_keyword_loc: Location
    attr_reader operator_loc: Location
    attr_reader expression: Prism::node
    attr_reader body: StatementsNode | BeginNode | nil
    attr_reader end_keyword_loc: Location

def save_class_keyword_loc: (_Repository repository) -> void
    def save_operator_loc: (_Repository repository) -> void
    def save_end_keyword_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[Symbol] locals, Location class_keyword_loc, Location operator_loc, Prism::node expression, StatementsNode | BeginNode | nil body, Location end_keyword_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?class_keyword_loc: Location, ?operator_loc: Location, ?expression: Prism::node, ?body: StatementsNode | BeginNode | nil, ?end_keyword_loc: Location) -> SingletonClassNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Prism::node, body: StatementsNode | BeginNode | nil, end_keyword_loc: Location }
    def class_keyword: () -> String
    def operator: () -> String
    def end_keyword: () -> String
    def type: () -> :singleton_class_node
            | ...
    def self.type: () -> :singleton_class_node
  end

# Represents the use of the `__ENCODING__` keyword.
  #
  #     __ENCODING__
  #     ^^^^^^^^^^^^
  class SourceEncodingNode < Node
    include _Node

def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> SourceEncodingNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
    def type: () -> :source_encoding_node
            | ...
    def self.type: () -> :source_encoding_node
  end

# Represents the use of the `__FILE__` keyword.
  #
  #     __FILE__
  #     ^^^^^^^^
  class SourceFileNode < Node
    include _Node

def forced_utf8_encoding?: () -> bool
    def forced_binary_encoding?: () -> bool
    def frozen?: () -> bool
    def mutable?: () -> bool

attr_reader filepath: String

def initialize: (Source source, Integer node_id, Location location, Integer flags, String filepath) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?filepath: String) -> SourceFileNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, filepath: String }
    def type: () -> :source_file_node
            | ...
    def self.type: () -> :source_file_node
  end

# Represents the use of the `__LINE__` keyword.
  #
  #     __LINE__
  #     ^^^^^^^^
  class SourceLineNode < Node
    include _Node

def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> SourceLineNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
    def type: () -> :source_line_node
            | ...
    def self.type: () -> :source_line_node
  end

# Represents the use of the splat operator.
  #
  #     [*a]
  #      ^^
  class SplatNode < Node
    include _Node

attr_reader operator_loc: Location
    attr_reader expression: Prism::node?

def save_operator_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location operator_loc, Prism::node? expression) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?operator_loc: Location, ?expression: Prism::node?) -> SplatNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, operator_loc: Location, expression: Prism::node? }
    def operator: () -> String
    def type: () -> :splat_node
            | ...
    def self.type: () -> :splat_node
  end

# Represents a set of statements contained within some scope.
  #
  #     foo; bar; baz
  #     ^^^^^^^^^^^^^
  class StatementsNode < Node
    include _Node

attr_reader body: Array[Prism::node]

def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[Prism::node] body) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?body: Array[Prism::node]) -> StatementsNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, body: Array[Prism::node] }
    def type: () -> :statements_node
            | ...
    def self.type: () -> :statements_node
  end

# Represents a string literal, a string contained within a `%w` list, or plain string content within an interpolated string.
  #
  #     "foo"
  #     ^^^^^
  #
  #     %w[foo]
  #        ^^^
  #
  #     "foo #{bar} baz"
  #      ^^^^      ^^^^
  class StringNode < Node
    include _Node

def forced_utf8_encoding?: () -> bool
    def forced_binary_encoding?: () -> bool
    def frozen?: () -> bool
    def mutable?: () -> bool

attr_reader opening_loc: Location?
    attr_reader content_loc: Location
    attr_reader closing_loc: Location?
    attr_reader unescaped: String

def save_opening_loc: (_Repository repository) -> void
    def save_content_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location? opening_loc, Location content_loc, Location? closing_loc, String unescaped) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?content_loc: Location, ?closing_loc: Location?, ?unescaped: String) -> StringNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, content_loc: Location, closing_loc: Location?, unescaped: String }
    def opening: () -> String?
    def content: () -> String
    def closing: () -> String?
    def type: () -> :string_node
            | ...
    def self.type: () -> :string_node
  end

# Represents the use of the `super` keyword with parentheses or arguments.
  #
  #     super()
  #     ^^^^^^^
  #
  #     super foo, bar
  #     ^^^^^^^^^^^^^^
  #
  # If no arguments are provided (except for a block), it would be a `ForwardingSuperNode` instead.
  class SuperNode < Node
    include _Node

attr_reader keyword_loc: Location
    attr_reader lparen_loc: Location?
    attr_reader arguments: ArgumentsNode?
    attr_reader rparen_loc: Location?
    attr_reader block: BlockNode | BlockArgumentNode | nil

def save_keyword_loc: (_Repository repository) -> void
    def save_lparen_loc: (_Repository repository) -> void
    def save_rparen_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Location? lparen_loc, ArgumentsNode? arguments, Location? rparen_loc, BlockNode | BlockArgumentNode | nil block) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?lparen_loc: Location?, ?arguments: ArgumentsNode?, ?rparen_loc: Location?, ?block: BlockNode | BlockArgumentNode | nil) -> SuperNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, block: BlockNode | BlockArgumentNode | nil }
    def keyword: () -> String
    def lparen: () -> String?
    def rparen: () -> String?
    def type: () -> :super_node
            | ...
    def self.type: () -> :super_node
  end

# Represents a symbol literal or a symbol contained within a `%i` list.
  #
  #     :foo
  #     ^^^^
  #
  #     %i[foo]
  #        ^^^
  class SymbolNode < Node
    include _Node

def forced_utf8_encoding?: () -> bool
    def forced_binary_encoding?: () -> bool
    def forced_us_ascii_encoding?: () -> bool

attr_reader opening_loc: Location?
    attr_reader value_loc: Location?
    attr_reader closing_loc: Location?
    attr_reader unescaped: String

def save_opening_loc: (_Repository repository) -> void
    def save_value_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location? opening_loc, Location? value_loc, Location? closing_loc, String unescaped) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?value_loc: Location?, ?closing_loc: Location?, ?unescaped: String) -> SymbolNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, value_loc: Location?, closing_loc: Location?, unescaped: String }
    def opening: () -> String?
    def value: () -> String?
    def closing: () -> String?
    def type: () -> :symbol_node
            | ...
    def self.type: () -> :symbol_node
  end

# Represents the use of the literal `true` keyword.
  #
  #     true
  #     ^^^^
  class TrueNode < Node
    include _Node

def initialize: (Source source, Integer node_id, Location location, Integer flags) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> TrueNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location }
    def type: () -> :true_node
            | ...
    def self.type: () -> :true_node
  end

# Represents the use of the `undef` keyword.
  #
  #     undef :foo, :bar, :baz
  #     ^^^^^^^^^^^^^^^^^^^^^^
  class UndefNode < Node
    include _Node

attr_reader names: Array[SymbolNode | InterpolatedSymbolNode]
    attr_reader keyword_loc: Location

def save_keyword_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Array[SymbolNode | InterpolatedSymbolNode] names, Location keyword_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?names: Array[SymbolNode | InterpolatedSymbolNode], ?keyword_loc: Location) -> UndefNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, names: Array[SymbolNode | InterpolatedSymbolNode], keyword_loc: Location }
    def keyword: () -> String
    def type: () -> :undef_node
            | ...
    def self.type: () -> :undef_node
  end

# Represents the use of the `unless` keyword, either in the block form or the modifier form.
  #
  #     bar unless foo
  #     ^^^^^^^^^^^^^^
  #
  #     unless foo then bar end
  #     ^^^^^^^^^^^^^^^^^^^^^^^
  class UnlessNode < Node
    include _Node

attr_reader keyword_loc: Location
    attr_reader predicate: Prism::node
    attr_reader then_keyword_loc: Location?
    attr_reader statements: StatementsNode?
    attr_reader else_clause: ElseNode?
    attr_reader end_keyword_loc: Location?

def save_keyword_loc: (_Repository repository) -> void
    def save_then_keyword_loc: (_Repository repository) -> void
    def save_end_keyword_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Prism::node predicate, Location? then_keyword_loc, StatementsNode? statements, ElseNode? else_clause, Location? end_keyword_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?else_clause: ElseNode?, ?end_keyword_loc: Location?) -> UnlessNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, predicate: Prism::node, then_keyword_loc: Location?, statements: StatementsNode?, else_clause: ElseNode?, end_keyword_loc: Location? }
    def keyword: () -> String
    def then_keyword: () -> String?
    def end_keyword: () -> String?
    def type: () -> :unless_node
            | ...
    def self.type: () -> :unless_node
  end

# Represents the use of the `until` keyword, either in the block form or the modifier form.
  #
  #     bar until foo
  #     ^^^^^^^^^^^^^
  #
  #     until foo do bar end
  #     ^^^^^^^^^^^^^^^^^^^^
  class UntilNode < Node
    include _Node

def begin_modifier?: () -> bool

attr_reader keyword_loc: Location
    attr_reader do_keyword_loc: Location?
    attr_reader closing_loc: Location?
    attr_reader predicate: Prism::node
    attr_reader statements: StatementsNode?

def save_keyword_loc: (_Repository repository) -> void
    def save_do_keyword_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Location? do_keyword_loc, Location? closing_loc, Prism::node predicate, StatementsNode? statements) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?do_keyword_loc: Location?, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> UntilNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, do_keyword_loc: Location?, closing_loc: Location?, predicate: Prism::node, statements: StatementsNode? }
    def keyword: () -> String
    def do_keyword: () -> String?
    def closing: () -> String?
    def type: () -> :until_node
            | ...
    def self.type: () -> :until_node
  end

# Represents the use of the `when` keyword within a case statement.
  #
  #     case true
  #     when true
  #     ^^^^^^^^^
  #     end
  class WhenNode < Node
    include _Node

attr_reader keyword_loc: Location
    attr_reader conditions: Array[Prism::node]
    attr_reader then_keyword_loc: Location?
    attr_reader statements: StatementsNode?

def save_keyword_loc: (_Repository repository) -> void
    def save_then_keyword_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Array[Prism::node] conditions, Location? then_keyword_loc, StatementsNode? statements) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?conditions: Array[Prism::node], ?then_keyword_loc: Location?, ?statements: StatementsNode?) -> WhenNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, conditions: Array[Prism::node], then_keyword_loc: Location?, statements: StatementsNode? }
    def keyword: () -> String
    def then_keyword: () -> String?
    def type: () -> :when_node
            | ...
    def self.type: () -> :when_node
  end

# Represents the use of the `while` keyword, either in the block form or the modifier form.
  #
  #     bar while foo
  #     ^^^^^^^^^^^^^
  #
  #     while foo do bar end
  #     ^^^^^^^^^^^^^^^^^^^^
  class WhileNode < Node
    include _Node

def begin_modifier?: () -> bool

attr_reader keyword_loc: Location
    attr_reader do_keyword_loc: Location?
    attr_reader closing_loc: Location?
    attr_reader predicate: Prism::node
    attr_reader statements: StatementsNode?

def save_keyword_loc: (_Repository repository) -> void
    def save_do_keyword_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Location? do_keyword_loc, Location? closing_loc, Prism::node predicate, StatementsNode? statements) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?do_keyword_loc: Location?, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> WhileNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, do_keyword_loc: Location?, closing_loc: Location?, predicate: Prism::node, statements: StatementsNode? }
    def keyword: () -> String
    def do_keyword: () -> String?
    def closing: () -> String?
    def type: () -> :while_node
            | ...
    def self.type: () -> :while_node
  end

# Represents an xstring literal with no interpolation.
  #
  #     `foo`
  #     ^^^^^
  class XStringNode < Node
    include _Node

def forced_utf8_encoding?: () -> bool
    def forced_binary_encoding?: () -> bool

attr_reader opening_loc: Location
    attr_reader content_loc: Location
    attr_reader closing_loc: Location
    attr_reader unescaped: String

def save_opening_loc: (_Repository repository) -> void
    def save_content_loc: (_Repository repository) -> void
    def save_closing_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location opening_loc, Location content_loc, Location closing_loc, String unescaped) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String) -> XStringNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String }
    def opening: () -> String
    def content: () -> String
    def closing: () -> String
    def type: () -> :x_string_node
            | ...
    def self.type: () -> :x_string_node
  end

# Represents the use of the `yield` keyword.
  #
  #     yield 1
  #     ^^^^^^^
  class YieldNode < Node
    include _Node

attr_reader keyword_loc: Location
    attr_reader lparen_loc: Location?
    attr_reader arguments: ArgumentsNode?
    attr_reader rparen_loc: Location?

def save_keyword_loc: (_Repository repository) -> void
    def save_lparen_loc: (_Repository repository) -> void
    def save_rparen_loc: (_Repository repository) -> void

def initialize: (Source source, Integer node_id, Location location, Integer flags, Location keyword_loc, Location? lparen_loc, ArgumentsNode? arguments, Location? rparen_loc) -> void
    def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?lparen_loc: Location?, ?arguments: ArgumentsNode?, ?rparen_loc: Location?) -> YieldNode
    def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location? }
    def keyword: () -> String
    def lparen: () -> String?
    def rparen: () -> String?
    def type: () -> :yield_node
            | ...
    def self.type: () -> :yield_node
  end

# Flags for arguments nodes.
  module ArgumentsNodeFlags
    # if the arguments contain forwarding
    CONTAINS_FORWARDING: Integer
    # if the arguments contain keywords
    CONTAINS_KEYWORDS: Integer
    # if the arguments contain a keyword splat
    CONTAINS_KEYWORD_SPLAT: Integer
    # if the arguments contain a splat
    CONTAINS_SPLAT: Integer
    # if the arguments contain multiple splats
    CONTAINS_MULTIPLE_SPLATS: Integer
  end

# Flags for array nodes.
  module ArrayNodeFlags
    # if array contains splat nodes
    CONTAINS_SPLAT: Integer
  end

# Flags for call nodes.
  module CallNodeFlags
    # &. operator
    SAFE_NAVIGATION: Integer
    # a call that could have been a local variable
    VARIABLE_CALL: Integer
    # a call that is an attribute write, so the value being written should be returned
    ATTRIBUTE_WRITE: Integer
    # a call that ignores method visibility
    IGNORE_VISIBILITY: Integer
  end

# Flags for nodes that have unescaped content.
  module EncodingFlags
    # internal bytes forced the encoding to UTF-8
    FORCED_UTF8_ENCODING: Integer
    # internal bytes forced the encoding to binary
    FORCED_BINARY_ENCODING: Integer
  end

# Flags for integer nodes that correspond to the base of the integer.
  module IntegerBaseFlags
    # 0b prefix
    BINARY: Integer
    # 0d or no prefix
    DECIMAL: Integer
    # 0o or 0 prefix
    OCTAL: Integer
    # 0x prefix
    HEXADECIMAL: Integer
  end

# Flags for interpolated string nodes that indicated mutability if they are also marked as literals.
  module InterpolatedStringNodeFlags
    # frozen by virtue of a `frozen_string_literal: true` comment or `--enable-frozen-string-literal`; only for adjacent string literals like `'a' 'b'`
    FROZEN: Integer
    # mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal`; only for adjacent string literals like `'a' 'b'`
    MUTABLE: Integer
  end

# Flags for keyword hash nodes.
  module KeywordHashNodeFlags
    # a keyword hash which only has `AssocNode` elements all with symbol keys, which means the elements can be treated as keyword arguments
    SYMBOL_KEYS: Integer
  end

# Flags for while and until loop nodes.
  module LoopFlags
    # a loop after a begin statement, so the body is executed first before the condition
    BEGIN_MODIFIER: Integer
  end

# Flags for parameter nodes.
  module ParameterFlags
    # a parameter name that has been repeated in the method signature
    REPEATED_PARAMETER: Integer
  end

# Flags for parentheses nodes.
  module ParenthesesNodeFlags
    # parentheses that contain multiple potentially void statements
    MULTIPLE_STATEMENTS: Integer
  end

# Flags for range and flip-flop nodes.
  module RangeFlags
    # ... operator
    EXCLUDE_END: Integer
  end

# Flags for regular expression and match last line nodes.
  module RegularExpressionFlags
    # i - ignores the case of characters when matching
    IGNORE_CASE: Integer
    # x - ignores whitespace and allows comments in regular expressions
    EXTENDED: Integer
    # m - allows $ to match the end of lines within strings
    MULTI_LINE: Integer
    # o - only interpolates values into the regular expression once
    ONCE: Integer
    # e - forces the EUC-JP encoding
    EUC_JP: Integer
    # n - forces the ASCII-8BIT encoding
    ASCII_8BIT: Integer
    # s - forces the Windows-31J encoding
    WINDOWS_31J: Integer
    # u - forces the UTF-8 encoding
    UTF_8: Integer
    # internal bytes forced the encoding to UTF-8
    FORCED_UTF8_ENCODING: Integer
    # internal bytes forced the encoding to binary
    FORCED_BINARY_ENCODING: Integer
    # internal bytes forced the encoding to US-ASCII
    FORCED_US_ASCII_ENCODING: Integer
  end

# Flags for shareable constant nodes.
  module ShareableConstantNodeFlags
    # constant writes that should be modified with shareable constant value literal
    LITERAL: Integer
    # constant writes that should be modified with shareable constant value experimental everything
    EXPERIMENTAL_EVERYTHING: Integer
    # constant writes that should be modified with shareable constant value experimental copy
    EXPERIMENTAL_COPY: Integer
  end

# Flags for string nodes.
  module StringFlags
    # internal bytes forced the encoding to UTF-8
    FORCED_UTF8_ENCODING: Integer
    # internal bytes forced the encoding to binary
    FORCED_BINARY_ENCODING: Integer
    # frozen by virtue of a `frozen_string_literal: true` comment or `--enable-frozen-string-literal`
    FROZEN: Integer
    # mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal`
    MUTABLE: Integer
  end

# Flags for symbol nodes.
  module SymbolFlags
    # internal bytes forced the encoding to UTF-8
    FORCED_UTF8_ENCODING: Integer
    # internal bytes forced the encoding to binary
    FORCED_BINARY_ENCODING: Integer
    # internal bytes forced the encoding to US-ASCII
    FORCED_US_ASCII_ENCODING: Integer
  end

# The flags that are common to all nodes.
  module NodeFlags
    NEWLINE: Integer
    STATIC_LITERAL: Integer
  end
end

Sid Gifari From Gifari Industries - BD Cyber Security Team