prism 0.15.1 → 0.17.0

data/sig/prism.rbs

@@ -0,0 +1,4468 @@
+# This file is generated by the templates/template.rb script and should not be
+# modified manually. See templates/sig/prism.rbs.erb
+# if you are looking to modify the template
+
+module Prism
+  # Represents the use of the `alias` keyword to alias a global variable.
+  #
+  #     alias $foo $bar
+  #     ^^^^^^^^^^^^^^^
+  class AliasGlobalVariableNode < Node
+    attr_reader new_name: Node
+    attr_reader old_name: Node
+    attr_reader keyword_loc: Location
+
+    def initialize: (new_name: Node, old_name: Node, keyword_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> AliasGlobalVariableNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def keyword: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `alias` keyword to alias a method.
+  #
+  #     alias foo bar
+  #     ^^^^^^^^^^^^^
+  class AliasMethodNode < Node
+    attr_reader new_name: Node
+    attr_reader old_name: Node
+    attr_reader keyword_loc: Location
+
+    def initialize: (new_name: Node, old_name: Node, keyword_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> AliasMethodNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def keyword: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents an alternation pattern in pattern matching.
+  #
+  #     foo => bar | baz
+  #            ^^^^^^^^^
+  class AlternationPatternNode < Node
+    attr_reader left: Node
+    attr_reader right: Node
+    attr_reader operator_loc: Location
+
+    def initialize: (left: Node, right: Node, operator_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> AlternationPatternNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `&&` operator or the `and` keyword.
+  #
+  #     left and right
+  #     ^^^^^^^^^^^^^^
+  class AndNode < Node
+    attr_reader left: Node
+    attr_reader right: Node
+    attr_reader operator_loc: Location
+
+    def initialize: (left: Node, right: Node, operator_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> AndNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a set of arguments to a method or a keyword.
+  #
+  #     return foo, bar, baz
+  #            ^^^^^^^^^^^^^
+  class ArgumentsNode < Node
+    attr_reader arguments: Array[Node]
+    attr_reader flags: Integer
+
+    def initialize: (arguments: Array[Node], flags: Integer, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ArgumentsNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def keyword_splat?: () -> bool
+
+    def inspect: (inspector: NodeInspector) -> String
+  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
+    attr_reader elements: Array[Node]
+    attr_reader opening_loc: Location?
+    attr_reader closing_loc: Location?
+
+    def initialize: (elements: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ArrayNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def opening: () -> String?
+
+    def closing: () -> String?
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents an array pattern in pattern matching.
+  #
+  #     foo in 1, 2
+  #     ^^^^^^^^^^^
+  #
+  #     foo in [1, 2]
+  #     ^^^^^^^^^^^^^
+  #
+  #     foo in *1
+  #     ^^^^^^^^^
+  #
+  #     foo in Bar[]
+  #     ^^^^^^^^^^^^
+  #
+  #     foo in Bar[1, 2, 3]
+  #     ^^^^^^^^^^^^^^^^^^^
+  class ArrayPatternNode < Node
+    attr_reader constant: Node?
+    attr_reader requireds: Array[Node]
+    attr_reader rest: Node?
+    attr_reader posts: Array[Node]
+    attr_reader opening_loc: Location?
+    attr_reader closing_loc: Location?
+
+    def initialize: (constant: Node?, requireds: Array[Node], rest: Node?, posts: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ArrayPatternNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def opening: () -> String?
+
+    def closing: () -> String?
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a hash key/value pair.
+  #
+  #     { a => b }
+  #       ^^^^^^
+  class AssocNode < Node
+    attr_reader key: Node
+    attr_reader value: Node?
+    attr_reader operator_loc: Location?
+
+    def initialize: (key: Node, value: Node?, operator_loc: Location?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> AssocNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String?
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a splat in a hash literal.
+  #
+  #     { **foo }
+  #       ^^^^^
+  class AssocSplatNode < Node
+    attr_reader value: Node?
+    attr_reader operator_loc: Location
+
+    def initialize: (value: Node?, operator_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> AssocSplatNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents reading a reference to a field in the previous match.
+  #
+  #     $'
+  #     ^^
+  class BackReferenceReadNode < Node
+    attr_reader name: Symbol
+
+    def initialize: (name: Symbol, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> BackReferenceReadNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a begin statement.
+  #
+  #     begin
+  #       foo
+  #     end
+  #     ^^^^^
+  class BeginNode < 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 initialize: (begin_keyword_loc: Location?, statements: StatementsNode?, rescue_clause: RescueNode?, else_clause: ElseNode?, ensure_clause: EnsureNode?, end_keyword_loc: Location?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> BeginNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def begin_keyword: () -> String?
+
+    def end_keyword: () -> String?
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents block method arguments.
+  #
+  #     bar(&args)
+  #     ^^^^^^^^^^
+  class BlockArgumentNode < Node
+    attr_reader expression: Node?
+    attr_reader operator_loc: Location
+
+    def initialize: (expression: Node?, operator_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> BlockArgumentNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a block local variable.
+  #
+  #     a { |; b| }
+  #            ^
+  class BlockLocalVariableNode < Node
+    attr_reader name: Symbol
+
+    def initialize: (name: Symbol, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> BlockLocalVariableNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a block of ruby code.
+  #
+  # [1, 2, 3].each { |i| puts x }
+  #                ^^^^^^^^^^^^^^
+  class BlockNode < Node
+    attr_reader locals: Array[Symbol]
+    attr_reader parameters: BlockParametersNode?
+    attr_reader body: Node?
+    attr_reader opening_loc: Location
+    attr_reader closing_loc: Location
+
+    def initialize: (locals: Array[Symbol], parameters: BlockParametersNode?, body: Node?, opening_loc: Location, closing_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> BlockNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def opening: () -> String
+
+    def closing: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a block parameter to a method, block, or lambda definition.
+  #
+  #     def a(&b)
+  #           ^^
+  #     end
+  class BlockParameterNode < Node
+    attr_reader name: Symbol?
+    attr_reader name_loc: Location?
+    attr_reader operator_loc: Location
+
+    def initialize: (name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> BlockParameterNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a block's parameters declaration.
+  #
+  #     -> (a, b = 1; local) { }
+  #        ^^^^^^^^^^^^^^^^^
+  #
+  #     foo do |a, b = 1; local|
+  #            ^^^^^^^^^^^^^^^^^
+  #     end
+  class BlockParametersNode < Node
+    attr_reader parameters: ParametersNode?
+    attr_reader locals: Array[Node]
+    attr_reader opening_loc: Location?
+    attr_reader closing_loc: Location?
+
+    def initialize: (parameters: ParametersNode?, locals: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> BlockParametersNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def opening: () -> String?
+
+    def closing: () -> String?
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `break` keyword.
+  #
+  #     break foo
+  #     ^^^^^^^^^
+  class BreakNode < Node
+    attr_reader arguments: ArgumentsNode?
+    attr_reader keyword_loc: Location
+
+    def initialize: (arguments: ArgumentsNode?, keyword_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> BreakNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def keyword: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `&&=` operator on a call.
+  #
+  #     foo.bar &&= value
+  #     ^^^^^^^^^^^^^^^^^
+  class CallAndWriteNode < Node
+    attr_reader receiver: Node?
+    attr_reader call_operator_loc: Location?
+    attr_reader message_loc: Location?
+    attr_reader flags: Integer
+    attr_reader read_name: Symbol
+    attr_reader write_name: Symbol
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+
+    def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, flags: Integer, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> CallAndWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def call_operator: () -> String?
+
+    def message: () -> String?
+
+    def safe_navigation?: () -> bool
+
+    def variable_call?: () -> bool
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  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
+    attr_reader receiver: Node?
+    attr_reader call_operator_loc: Location?
+    attr_reader message_loc: Location?
+    attr_reader opening_loc: Location?
+    attr_reader arguments: ArgumentsNode?
+    attr_reader closing_loc: Location?
+    attr_reader block: Node?
+    attr_reader flags: Integer
+    attr_reader name: Symbol
+
+    def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: Node?, flags: Integer, name: Symbol, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> CallNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def call_operator: () -> String?
+
+    def message: () -> String?
+
+    def opening: () -> String?
+
+    def closing: () -> String?
+
+    def safe_navigation?: () -> bool
+
+    def variable_call?: () -> bool
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of an assignment operator on a call.
+  #
+  #     foo.bar += baz
+  #     ^^^^^^^^^^^^^^
+  class CallOperatorWriteNode < Node
+    attr_reader receiver: Node?
+    attr_reader call_operator_loc: Location?
+    attr_reader message_loc: Location?
+    attr_reader flags: Integer
+    attr_reader read_name: Symbol
+    attr_reader write_name: Symbol
+    attr_reader operator: Symbol
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+
+    def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, flags: Integer, read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Location, value: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> CallOperatorWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def call_operator: () -> String?
+
+    def message: () -> String?
+
+    def safe_navigation?: () -> bool
+
+    def variable_call?: () -> bool
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `||=` operator on a call.
+  #
+  #     foo.bar ||= value
+  #     ^^^^^^^^^^^^^^^^^
+  class CallOrWriteNode < Node
+    attr_reader receiver: Node?
+    attr_reader call_operator_loc: Location?
+    attr_reader message_loc: Location?
+    attr_reader flags: Integer
+    attr_reader read_name: Symbol
+    attr_reader write_name: Symbol
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+
+    def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, flags: Integer, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> CallOrWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def call_operator: () -> String?
+
+    def message: () -> String?
+
+    def safe_navigation?: () -> bool
+
+    def variable_call?: () -> bool
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents assigning to a local variable in pattern matching.
+  #
+  #     foo => [bar => baz]
+  #            ^^^^^^^^^^^^
+  class CapturePatternNode < Node
+    attr_reader value: Node
+    attr_reader target: Node
+    attr_reader operator_loc: Location
+
+    def initialize: (value: Node, target: Node, operator_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> CapturePatternNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of a case statement.
+  #
+  #     case true
+  #     when false
+  #     end
+  #     ^^^^^^^^^^
+  class CaseNode < Node
+    attr_reader predicate: Node?
+    attr_reader conditions: Array[Node]
+    attr_reader consequent: ElseNode?
+    attr_reader case_keyword_loc: Location
+    attr_reader end_keyword_loc: Location
+
+    def initialize: (predicate: Node?, conditions: Array[Node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> CaseNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def case_keyword: () -> String
+
+    def end_keyword: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a class declaration involving the `class` keyword.
+  #
+  #     class Foo end
+  #     ^^^^^^^^^^^^^
+  class ClassNode < Node
+    attr_reader locals: Array[Symbol]
+    attr_reader class_keyword_loc: Location
+    attr_reader constant_path: Node
+    attr_reader inheritance_operator_loc: Location?
+    attr_reader superclass: Node?
+    attr_reader body: Node?
+    attr_reader end_keyword_loc: Location
+    attr_reader name: Symbol
+
+    def initialize: (locals: Array[Symbol], class_keyword_loc: Location, constant_path: Node, inheritance_operator_loc: Location?, superclass: Node?, body: Node?, end_keyword_loc: Location, name: Symbol, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ClassNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def class_keyword: () -> String
+
+    def inheritance_operator: () -> String?
+
+    def end_keyword: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `&&=` operator for assignment to a class variable.
+  #
+  #     @@target &&= value
+  #     ^^^^^^^^^^^^^^^^^^
+  class ClassVariableAndWriteNode < Node
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+
+    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ClassVariableAndWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents assigning to a class variable using an operator that isn't `=`.
+  #
+  #     @@target += value
+  #     ^^^^^^^^^^^^^^^^^
+  class ClassVariableOperatorWriteNode < Node
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+    attr_reader operator: Symbol
+
+    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ClassVariableOperatorWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `||=` operator for assignment to a class variable.
+  #
+  #     @@target ||= value
+  #     ^^^^^^^^^^^^^^^^^^
+  class ClassVariableOrWriteNode < Node
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+
+    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ClassVariableOrWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents referencing a class variable.
+  #
+  #     @@foo
+  #     ^^^^^
+  class ClassVariableReadNode < Node
+    attr_reader name: Symbol
+
+    def initialize: (name: Symbol, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ClassVariableReadNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents writing to a class variable in a context that doesn't have an explicit value.
+  #
+  #     @@foo, @@bar = baz
+  #     ^^^^^  ^^^^^
+  class ClassVariableTargetNode < Node
+    attr_reader name: Symbol
+
+    def initialize: (name: Symbol, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ClassVariableTargetNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents writing to a class variable.
+  #
+  #     @@foo = 1
+  #     ^^^^^^^^^
+  class ClassVariableWriteNode < Node
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader value: Node
+    attr_reader operator_loc: Location?
+
+    def initialize: (name: Symbol, name_loc: Location, value: Node, operator_loc: Location?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ClassVariableWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String?
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `&&=` operator for assignment to a constant.
+  #
+  #     Target &&= value
+  #     ^^^^^^^^^^^^^^^^
+  class ConstantAndWriteNode < Node
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+
+    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ConstantAndWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents assigning to a constant using an operator that isn't `=`.
+  #
+  #     Target += value
+  #     ^^^^^^^^^^^^^^^
+  class ConstantOperatorWriteNode < Node
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+    attr_reader operator: Symbol
+
+    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ConstantOperatorWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `||=` operator for assignment to a constant.
+  #
+  #     Target ||= value
+  #     ^^^^^^^^^^^^^^^^
+  class ConstantOrWriteNode < Node
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+
+    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ConstantOrWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `&&=` operator for assignment to a constant path.
+  #
+  #     Parent::Child &&= value
+  #     ^^^^^^^^^^^^^^^^^^^^^^^
+  class ConstantPathAndWriteNode < Node
+    attr_reader target: ConstantPathNode
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+
+    def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ConstantPathAndWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents accessing a constant through a path of `::` operators.
+  #
+  #     Foo::Bar
+  #     ^^^^^^^^
+  class ConstantPathNode < Node
+    attr_reader parent: Node?
+    attr_reader child: Node
+    attr_reader delimiter_loc: Location
+
+    def initialize: (parent: Node?, child: Node, delimiter_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ConstantPathNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def delimiter: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents assigning to a constant path using an operator that isn't `=`.
+  #
+  #     Parent::Child += value
+  #     ^^^^^^^^^^^^^^^^^^^^^^
+  class ConstantPathOperatorWriteNode < Node
+    attr_reader target: ConstantPathNode
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+    attr_reader operator: Symbol
+
+    def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ConstantPathOperatorWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `||=` operator for assignment to a constant path.
+  #
+  #     Parent::Child ||= value
+  #     ^^^^^^^^^^^^^^^^^^^^^^^
+  class ConstantPathOrWriteNode < Node
+    attr_reader target: ConstantPathNode
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+
+    def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ConstantPathOrWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  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
+    attr_reader parent: Node?
+    attr_reader child: Node
+    attr_reader delimiter_loc: Location
+
+    def initialize: (parent: Node?, child: Node, delimiter_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ConstantPathTargetNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def delimiter: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents writing to a constant path.
+  #
+  #     ::Foo = 1
+  #     ^^^^^^^^^
+  #
+  #     Foo::Bar = 1
+  #     ^^^^^^^^^^^^
+  #
+  #     ::Foo::Bar = 1
+  #     ^^^^^^^^^^^^^^
+  class ConstantPathWriteNode < Node
+    attr_reader target: ConstantPathNode
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+
+    def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ConstantPathWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents referencing a constant.
+  #
+  #     Foo
+  #     ^^^
+  class ConstantReadNode < Node
+    attr_reader name: Symbol
+
+    def initialize: (name: Symbol, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ConstantReadNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents writing to a constant in a context that doesn't have an explicit value.
+  #
+  #     Foo, Bar = baz
+  #     ^^^  ^^^
+  class ConstantTargetNode < Node
+    attr_reader name: Symbol
+
+    def initialize: (name: Symbol, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ConstantTargetNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents writing to a constant.
+  #
+  #     Foo = 1
+  #     ^^^^^^^
+  class ConstantWriteNode < Node
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader value: Node
+    attr_reader operator_loc: Location
+
+    def initialize: (name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ConstantWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a method definition.
+  #
+  #     def method
+  #     end
+  #     ^^^^^^^^^^
+  class DefNode < Node
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader receiver: Node?
+    attr_reader parameters: ParametersNode?
+    attr_reader body: Node?
+    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 initialize: (name: Symbol, name_loc: Location, receiver: Node?, parameters: ParametersNode?, body: Node?, locals: Array[Symbol], def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> DefNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def def_keyword: () -> String
+
+    def operator: () -> String?
+
+    def lparen: () -> String?
+
+    def rparen: () -> String?
+
+    def equal: () -> String?
+
+    def end_keyword: () -> String?
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `defined?` keyword.
+  #
+  #     defined?(a)
+  #     ^^^^^^^^^^^
+  class DefinedNode < Node
+    attr_reader lparen_loc: Location?
+    attr_reader value: Node
+    attr_reader rparen_loc: Location?
+    attr_reader keyword_loc: Location
+
+    def initialize: (lparen_loc: Location?, value: Node, rparen_loc: Location?, keyword_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> DefinedNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def lparen: () -> String?
+
+    def rparen: () -> String?
+
+    def keyword: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents an `else` clause in a `case`, `if`, or `unless` statement.
+  #
+  #     if a then b else c end
+  #                 ^^^^^^^^^^
+  class ElseNode < Node
+    attr_reader else_keyword_loc: Location
+    attr_reader statements: StatementsNode?
+    attr_reader end_keyword_loc: Location?
+
+    def initialize: (else_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ElseNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def else_keyword: () -> String
+
+    def end_keyword: () -> String?
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents an interpolated set of statements.
+  #
+  #     "foo #{bar}"
+  #          ^^^^^^
+  class EmbeddedStatementsNode < Node
+    attr_reader opening_loc: Location
+    attr_reader statements: StatementsNode?
+    attr_reader closing_loc: Location
+
+    def initialize: (opening_loc: Location, statements: StatementsNode?, closing_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> EmbeddedStatementsNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def opening: () -> String
+
+    def closing: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents an interpolated variable.
+  #
+  #     "foo #@bar"
+  #          ^^^^^
+  class EmbeddedVariableNode < Node
+    attr_reader operator_loc: Location
+    attr_reader variable: Node
+
+    def initialize: (operator_loc: Location, variable: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> EmbeddedVariableNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents an `ensure` clause in a `begin` statement.
+  #
+  #     begin
+  #       foo
+  #     ensure
+  #     ^^^^^^
+  #       bar
+  #     end
+  class EnsureNode < Node
+    attr_reader ensure_keyword_loc: Location
+    attr_reader statements: StatementsNode?
+    attr_reader end_keyword_loc: Location
+
+    def initialize: (ensure_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> EnsureNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def ensure_keyword: () -> String
+
+    def end_keyword: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the literal `false` keyword.
+  #
+  #     false
+  #     ^^^^^
+  class FalseNode < Node
+
+    def initialize: (location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> FalseNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a find pattern in pattern matching.
+  #
+  #     foo in *bar, baz, *qux
+  #            ^^^^^^^^^^^^^^^
+  #
+  #     foo in [*bar, baz, *qux]
+  #            ^^^^^^^^^^^^^^^^^
+  #
+  #     foo in Foo(*bar, baz, *qux)
+  #            ^^^^^^^^^^^^^^^^^^^^
+  class FindPatternNode < Node
+    attr_reader constant: Node?
+    attr_reader left: Node
+    attr_reader requireds: Array[Node]
+    attr_reader right: Node
+    attr_reader opening_loc: Location?
+    attr_reader closing_loc: Location?
+
+    def initialize: (constant: Node?, left: Node, requireds: Array[Node], right: Node, opening_loc: Location?, closing_loc: Location?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> FindPatternNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def opening: () -> String?
+
+    def closing: () -> String?
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `..` or `...` operators to create flip flops.
+  #
+  #     baz if foo .. bar
+  #            ^^^^^^^^^^
+  class FlipFlopNode < Node
+    attr_reader left: Node?
+    attr_reader right: Node?
+    attr_reader operator_loc: Location
+    attr_reader flags: Integer
+
+    def initialize: (left: Node?, right: Node?, operator_loc: Location, flags: Integer, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> FlipFlopNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def exclude_end?: () -> bool
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a floating point number literal.
+  #
+  #     1.0
+  #     ^^^
+  class FloatNode < Node
+
+    def initialize: (location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> FloatNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `for` keyword.
+  #
+  #     for i in a end
+  #     ^^^^^^^^^^^^^^
+  class ForNode < Node
+    attr_reader index: Node
+    attr_reader collection: 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 initialize: (index: Node, collection: Node, statements: StatementsNode?, for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: Location?, end_keyword_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ForNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def for_keyword: () -> String
+
+    def in_keyword: () -> String
+
+    def do_keyword: () -> String?
+
+    def end_keyword: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents forwarding all arguments to this method to another method.
+  #
+  #     def foo(...)
+  #       bar(...)
+  #           ^^^
+  #     end
+  class ForwardingArgumentsNode < Node
+
+    def initialize: (location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ForwardingArgumentsNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the forwarding parameter in a method, block, or lambda declaration.
+  #
+  #     def foo(...)
+  #             ^^^
+  #     end
+  class ForwardingParameterNode < Node
+
+    def initialize: (location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ForwardingParameterNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `super` keyword without parentheses or arguments.
+  #
+  #     super
+  #     ^^^^^
+  class ForwardingSuperNode < Node
+    attr_reader block: BlockNode?
+
+    def initialize: (block: BlockNode?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ForwardingSuperNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `&&=` operator for assignment to a global variable.
+  #
+  #     $target &&= value
+  #     ^^^^^^^^^^^^^^^^^
+  class GlobalVariableAndWriteNode < Node
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+
+    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> GlobalVariableAndWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents assigning to a global variable using an operator that isn't `=`.
+  #
+  #     $target += value
+  #     ^^^^^^^^^^^^^^^^
+  class GlobalVariableOperatorWriteNode < Node
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+    attr_reader operator: Symbol
+
+    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> GlobalVariableOperatorWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `||=` operator for assignment to a global variable.
+  #
+  #     $target ||= value
+  #     ^^^^^^^^^^^^^^^^^
+  class GlobalVariableOrWriteNode < Node
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+
+    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> GlobalVariableOrWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents referencing a global variable.
+  #
+  #     $foo
+  #     ^^^^
+  class GlobalVariableReadNode < Node
+    attr_reader name: Symbol
+
+    def initialize: (name: Symbol, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> GlobalVariableReadNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents writing to a global variable in a context that doesn't have an explicit value.
+  #
+  #     $foo, $bar = baz
+  #     ^^^^  ^^^^
+  class GlobalVariableTargetNode < Node
+    attr_reader name: Symbol
+
+    def initialize: (name: Symbol, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> GlobalVariableTargetNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents writing to a global variable.
+  #
+  #     $foo = 1
+  #     ^^^^^^^^
+  class GlobalVariableWriteNode < Node
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader value: Node
+    attr_reader operator_loc: Location
+
+    def initialize: (name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> GlobalVariableWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a hash literal.
+  #
+  #     { a => b }
+  #     ^^^^^^^^^^
+  class HashNode < Node
+    attr_reader opening_loc: Location
+    attr_reader elements: Array[Node]
+    attr_reader closing_loc: Location
+
+    def initialize: (opening_loc: Location, elements: Array[Node], closing_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> HashNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def opening: () -> String
+
+    def closing: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a hash pattern in pattern matching.
+  #
+  #     foo => { a: 1, b: 2 }
+  #            ^^^^^^^^^^^^^^
+  #
+  #     foo => { a: 1, b: 2, **c }
+  #            ^^^^^^^^^^^^^^^^^^^
+  class HashPatternNode < Node
+    attr_reader constant: Node?
+    attr_reader elements: Array[Node]
+    attr_reader rest: Node?
+    attr_reader opening_loc: Location?
+    attr_reader closing_loc: Location?
+
+    def initialize: (constant: Node?, elements: Array[Node], rest: Node?, opening_loc: Location?, closing_loc: Location?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> HashPatternNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def opening: () -> String?
+
+    def closing: () -> String?
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `if` keyword, either in the block form or the modifier form.
+  #
+  #     bar if foo
+  #     ^^^^^^^^^^
+  #
+  #     if foo then bar end
+  #     ^^^^^^^^^^^^^^^^^^^
+  class IfNode < Node
+    attr_reader if_keyword_loc: Location?
+    attr_reader predicate: Node
+    attr_reader statements: StatementsNode?
+    attr_reader consequent: Node?
+    attr_reader end_keyword_loc: Location?
+
+    def initialize: (if_keyword_loc: Location?, predicate: Node, statements: StatementsNode?, consequent: Node?, end_keyword_loc: Location?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> IfNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def if_keyword: () -> String?
+
+    def end_keyword: () -> String?
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents an imaginary number literal.
+  #
+  #     1.0i
+  #     ^^^^
+  class ImaginaryNode < Node
+    attr_reader numeric: Node
+
+    def initialize: (numeric: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ImaginaryNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  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: }
+  #       ^^^^
+  class ImplicitNode < Node
+    attr_reader value: Node
+
+    def initialize: (value: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ImplicitNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `in` keyword in a case statement.
+  #
+  #     case a; in b then c end
+  #             ^^^^^^^^^^^
+  class InNode < Node
+    attr_reader pattern: Node
+    attr_reader statements: StatementsNode?
+    attr_reader in_loc: Location
+    attr_reader then_loc: Location?
+
+    def initialize: (pattern: Node, statements: StatementsNode?, in_loc: Location, then_loc: Location?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> InNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def in: () -> String
+
+    def then: () -> String?
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `&&=` operator on a call to the `[]` method.
+  #
+  #     foo.bar[baz] &&= value
+  #     ^^^^^^^^^^^^^^^^^^^^^^
+  class IndexAndWriteNode < Node
+    attr_reader receiver: Node?
+    attr_reader call_operator_loc: Location?
+    attr_reader opening_loc: Location
+    attr_reader arguments: ArgumentsNode?
+    attr_reader closing_loc: Location
+    attr_reader block: Node?
+    attr_reader flags: Integer
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+
+    def initialize: (receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, flags: Integer, operator_loc: Location, value: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> IndexAndWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def call_operator: () -> String?
+
+    def opening: () -> String
+
+    def closing: () -> String
+
+    def safe_navigation?: () -> bool
+
+    def variable_call?: () -> bool
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of an assignment operator on a call to `[]`.
+  #
+  #     foo.bar[baz] += value
+  #     ^^^^^^^^^^^^^^^^^^^^^
+  class IndexOperatorWriteNode < Node
+    attr_reader receiver: Node?
+    attr_reader call_operator_loc: Location?
+    attr_reader opening_loc: Location
+    attr_reader arguments: ArgumentsNode?
+    attr_reader closing_loc: Location
+    attr_reader block: Node?
+    attr_reader flags: Integer
+    attr_reader operator: Symbol
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+
+    def initialize: (receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, flags: Integer, operator: Symbol, operator_loc: Location, value: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> IndexOperatorWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def call_operator: () -> String?
+
+    def opening: () -> String
+
+    def closing: () -> String
+
+    def safe_navigation?: () -> bool
+
+    def variable_call?: () -> bool
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `||=` operator on a call to `[]`.
+  #
+  #     foo.bar[baz] ||= value
+  #     ^^^^^^^^^^^^^^^^^^^^^^
+  class IndexOrWriteNode < Node
+    attr_reader receiver: Node?
+    attr_reader call_operator_loc: Location?
+    attr_reader opening_loc: Location
+    attr_reader arguments: ArgumentsNode?
+    attr_reader closing_loc: Location
+    attr_reader block: Node?
+    attr_reader flags: Integer
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+
+    def initialize: (receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, flags: Integer, operator_loc: Location, value: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> IndexOrWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def call_operator: () -> String?
+
+    def opening: () -> String
+
+    def closing: () -> String
+
+    def safe_navigation?: () -> bool
+
+    def variable_call?: () -> bool
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `&&=` operator for assignment to an instance variable.
+  #
+  #     @target &&= value
+  #     ^^^^^^^^^^^^^^^^^
+  class InstanceVariableAndWriteNode < Node
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+
+    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> InstanceVariableAndWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents assigning to an instance variable using an operator that isn't `=`.
+  #
+  #     @target += value
+  #     ^^^^^^^^^^^^^^^^
+  class InstanceVariableOperatorWriteNode < Node
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+    attr_reader operator: Symbol
+
+    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> InstanceVariableOperatorWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `||=` operator for assignment to an instance variable.
+  #
+  #     @target ||= value
+  #     ^^^^^^^^^^^^^^^^^
+  class InstanceVariableOrWriteNode < Node
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+
+    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> InstanceVariableOrWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents referencing an instance variable.
+  #
+  #     @foo
+  #     ^^^^
+  class InstanceVariableReadNode < Node
+    attr_reader name: Symbol
+
+    def initialize: (name: Symbol, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> InstanceVariableReadNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents writing to an instance variable in a context that doesn't have an explicit value.
+  #
+  #     @foo, @bar = baz
+  #     ^^^^  ^^^^
+  class InstanceVariableTargetNode < Node
+    attr_reader name: Symbol
+
+    def initialize: (name: Symbol, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> InstanceVariableTargetNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents writing to an instance variable.
+  #
+  #     @foo = 1
+  #     ^^^^^^^^
+  class InstanceVariableWriteNode < Node
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader value: Node
+    attr_reader operator_loc: Location
+
+    def initialize: (name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> InstanceVariableWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents an integer number literal.
+  #
+  #     1
+  #     ^
+  class IntegerNode < Node
+    attr_reader flags: Integer
+
+    def initialize: (flags: Integer, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> IntegerNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def binary?: () -> bool
+
+    def octal?: () -> bool
+
+    def decimal?: () -> bool
+
+    def hexadecimal?: () -> bool
+
+    def inspect: (inspector: NodeInspector) -> String
+  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
+    attr_reader opening_loc: Location
+    attr_reader parts: Array[Node]
+    attr_reader closing_loc: Location
+    attr_reader flags: Integer
+
+    def initialize: (opening_loc: Location, parts: Array[Node], closing_loc: Location, flags: Integer, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> InterpolatedMatchLastLineNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def opening: () -> String
+
+    def closing: () -> String
+
+    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 inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a regular expression literal that contains interpolation.
+  #
+  #     /foo #{bar} baz/
+  #     ^^^^^^^^^^^^^^^^
+  class InterpolatedRegularExpressionNode < Node
+    attr_reader opening_loc: Location
+    attr_reader parts: Array[Node]
+    attr_reader closing_loc: Location
+    attr_reader flags: Integer
+
+    def initialize: (opening_loc: Location, parts: Array[Node], closing_loc: Location, flags: Integer, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> InterpolatedRegularExpressionNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def opening: () -> String
+
+    def closing: () -> String
+
+    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 inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a string literal that contains interpolation.
+  #
+  #     "foo #{bar} baz"
+  #     ^^^^^^^^^^^^^^^^
+  class InterpolatedStringNode < Node
+    attr_reader opening_loc: Location?
+    attr_reader parts: Array[Node]
+    attr_reader closing_loc: Location?
+
+    def initialize: (opening_loc: Location?, parts: Array[Node], closing_loc: Location?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> InterpolatedStringNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def opening: () -> String?
+
+    def closing: () -> String?
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a symbol literal that contains interpolation.
+  #
+  #     :"foo #{bar} baz"
+  #     ^^^^^^^^^^^^^^^^^
+  class InterpolatedSymbolNode < Node
+    attr_reader opening_loc: Location?
+    attr_reader parts: Array[Node]
+    attr_reader closing_loc: Location?
+
+    def initialize: (opening_loc: Location?, parts: Array[Node], closing_loc: Location?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> InterpolatedSymbolNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def opening: () -> String?
+
+    def closing: () -> String?
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents an xstring literal that contains interpolation.
+  #
+  #     `foo #{bar} baz`
+  #     ^^^^^^^^^^^^^^^^
+  class InterpolatedXStringNode < Node
+    attr_reader opening_loc: Location
+    attr_reader parts: Array[Node]
+    attr_reader closing_loc: Location
+
+    def initialize: (opening_loc: Location, parts: Array[Node], closing_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> InterpolatedXStringNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def opening: () -> String
+
+    def closing: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a hash literal without opening and closing braces.
+  #
+  #     foo(a: b)
+  #         ^^^^
+  class KeywordHashNode < Node
+    attr_reader elements: Array[Node]
+
+    def initialize: (elements: Array[Node], location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> KeywordHashNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a keyword rest parameter to a method, block, or lambda definition.
+  #
+  #     def a(**b)
+  #           ^^^
+  #     end
+  class KeywordRestParameterNode < Node
+    attr_reader name: Symbol?
+    attr_reader name_loc: Location?
+    attr_reader operator_loc: Location
+
+    def initialize: (name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> KeywordRestParameterNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents using a lambda literal (not the lambda method call).
+  #
+  #     ->(value) { value * 2 }
+  #     ^^^^^^^^^^^^^^^^^^^^^^^
+  class LambdaNode < 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?
+    attr_reader body: Node?
+
+    def initialize: (locals: Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: BlockParametersNode?, body: Node?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> LambdaNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def opening: () -> String
+
+    def closing: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `&&=` operator for assignment to a local variable.
+  #
+  #     target &&= value
+  #     ^^^^^^^^^^^^^^^^
+  class LocalVariableAndWriteNode < Node
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+    attr_reader name: Symbol
+    attr_reader depth: Integer
+
+    def initialize: (name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> LocalVariableAndWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents assigning to a local variable using an operator that isn't `=`.
+  #
+  #     target += value
+  #     ^^^^^^^^^^^^^^^
+  class LocalVariableOperatorWriteNode < Node
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+    attr_reader name: Symbol
+    attr_reader operator: Symbol
+    attr_reader depth: Integer
+
+    def initialize: (name_loc: Location, operator_loc: Location, value: Node, name: Symbol, operator: Symbol, depth: Integer, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> LocalVariableOperatorWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `||=` operator for assignment to a local variable.
+  #
+  #     target ||= value
+  #     ^^^^^^^^^^^^^^^^
+  class LocalVariableOrWriteNode < Node
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+    attr_reader name: Symbol
+    attr_reader depth: Integer
+
+    def initialize: (name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> LocalVariableOrWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  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
+    attr_reader name: Symbol
+    attr_reader depth: Integer
+
+    def initialize: (name: Symbol, depth: Integer, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> LocalVariableReadNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents writing to a local variable in a context that doesn't have an explicit value.
+  #
+  #     foo, bar = baz
+  #     ^^^  ^^^
+  class LocalVariableTargetNode < Node
+    attr_reader name: Symbol
+    attr_reader depth: Integer
+
+    def initialize: (name: Symbol, depth: Integer, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> LocalVariableTargetNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents writing to a local variable.
+  #
+  #     foo = 1
+  #     ^^^^^^^
+  class LocalVariableWriteNode < Node
+    attr_reader name: Symbol
+    attr_reader depth: Integer
+    attr_reader name_loc: Location
+    attr_reader value: Node
+    attr_reader operator_loc: Location
+
+    def initialize: (name: Symbol, depth: Integer, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> LocalVariableWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  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
+    attr_reader opening_loc: Location
+    attr_reader content_loc: Location
+    attr_reader closing_loc: Location
+    attr_reader unescaped: String
+    attr_reader flags: Integer
+
+    def initialize: (opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, flags: Integer, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> MatchLastLineNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def opening: () -> String
+
+    def content: () -> String
+
+    def closing: () -> String
+
+    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 inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the modifier `in` operator.
+  #
+  #     foo in bar
+  #     ^^^^^^^^^^
+  class MatchPredicateNode < Node
+    attr_reader value: Node
+    attr_reader pattern: Node
+    attr_reader operator_loc: Location
+
+    def initialize: (value: Node, pattern: Node, operator_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> MatchPredicateNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `=>` operator.
+  #
+  #     foo => bar
+  #     ^^^^^^^^^^
+  class MatchRequiredNode < Node
+    attr_reader value: Node
+    attr_reader pattern: Node
+    attr_reader operator_loc: Location
+
+    def initialize: (value: Node, pattern: Node, operator_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> MatchRequiredNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents writing local variables using a regular expression match with
+  # named capture groups.
+  #
+  #     /(?<foo>bar)/ =~ baz
+  #     ^^^^^^^^^^^^^^^^^^^^
+  class MatchWriteNode < Node
+    attr_reader call: CallNode
+    attr_reader locals: Array[Symbol]
+
+    def initialize: (call: CallNode, locals: Array[Symbol], location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> MatchWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a node that is missing from the source and results in a syntax
+  # error.
+  class MissingNode < Node
+
+    def initialize: (location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> MissingNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a module declaration involving the `module` keyword.
+  #
+  #     module Foo end
+  #     ^^^^^^^^^^^^^^
+  class ModuleNode < Node
+    attr_reader locals: Array[Symbol]
+    attr_reader module_keyword_loc: Location
+    attr_reader constant_path: Node
+    attr_reader body: Node?
+    attr_reader end_keyword_loc: Location
+    attr_reader name: Symbol
+
+    def initialize: (locals: Array[Symbol], module_keyword_loc: Location, constant_path: Node, body: Node?, end_keyword_loc: Location, name: Symbol, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ModuleNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def module_keyword: () -> String
+
+    def end_keyword: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a multi-target expression.
+  #
+  #     a, (b, c) = 1, 2, 3
+  #        ^^^^^^
+  class MultiTargetNode < Node
+    attr_reader lefts: Array[Node]
+    attr_reader rest: Node?
+    attr_reader rights: Array[Node]
+    attr_reader lparen_loc: Location?
+    attr_reader rparen_loc: Location?
+
+    def initialize: (lefts: Array[Node], rest: Node?, rights: Array[Node], lparen_loc: Location?, rparen_loc: Location?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> MultiTargetNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def lparen: () -> String?
+
+    def rparen: () -> String?
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a write to a multi-target expression.
+  #
+  #     a, b, c = 1, 2, 3
+  #     ^^^^^^^^^^^^^^^^^
+  class MultiWriteNode < Node
+    attr_reader lefts: Array[Node]
+    attr_reader rest: Node?
+    attr_reader rights: Array[Node]
+    attr_reader lparen_loc: Location?
+    attr_reader rparen_loc: Location?
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+
+    def initialize: (lefts: Array[Node], rest: Node?, rights: Array[Node], lparen_loc: Location?, rparen_loc: Location?, operator_loc: Location, value: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> MultiWriteNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def lparen: () -> String?
+
+    def rparen: () -> String?
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `next` keyword.
+  #
+  #     next 1
+  #     ^^^^^^
+  class NextNode < Node
+    attr_reader arguments: ArgumentsNode?
+    attr_reader keyword_loc: Location
+
+    def initialize: (arguments: ArgumentsNode?, keyword_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> NextNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def keyword: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `nil` keyword.
+  #
+  #     nil
+  #     ^^^
+  class NilNode < Node
+
+    def initialize: (location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> NilNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of `**nil` inside method arguments.
+  #
+  #     def a(**nil)
+  #           ^^^^^
+  #     end
+  class NoKeywordsParameterNode < Node
+    attr_reader operator_loc: Location
+    attr_reader keyword_loc: Location
+
+    def initialize: (operator_loc: Location, keyword_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> NoKeywordsParameterNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def keyword: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents reading a numbered reference to a capture in the previous match.
+  #
+  #     $1
+  #     ^^
+  class NumberedReferenceReadNode < Node
+    attr_reader number: Integer
+
+    def initialize: (number: Integer, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> NumberedReferenceReadNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents an optional keyword parameter to a method, block, or lambda definition.
+  #
+  #     def a(b: 1)
+  #           ^^^^
+  #     end
+  class OptionalKeywordParameterNode < Node
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader value: Node
+
+    def initialize: (name: Symbol, name_loc: Location, value: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> OptionalKeywordParameterNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents an optional parameter to a method, block, or lambda definition.
+  #
+  #     def a(b = 1)
+  #           ^^^^^
+  #     end
+  class OptionalParameterNode < Node
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Node
+
+    def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> OptionalParameterNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `||` operator or the `or` keyword.
+  #
+  #     left or right
+  #     ^^^^^^^^^^^^^
+  class OrNode < Node
+    attr_reader left: Node
+    attr_reader right: Node
+    attr_reader operator_loc: Location
+
+    def initialize: (left: Node, right: Node, operator_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> OrNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the list of parameters on a method, block, or lambda definition.
+  #
+  #     def a(b, c, d)
+  #           ^^^^^^^
+  #     end
+  class ParametersNode < Node
+    attr_reader requireds: Array[Node]
+    attr_reader optionals: Array[Node]
+    attr_reader rest: RestParameterNode?
+    attr_reader posts: Array[Node]
+    attr_reader keywords: Array[Node]
+    attr_reader keyword_rest: Node?
+    attr_reader block: BlockParameterNode?
+
+    def initialize: (requireds: Array[Node], optionals: Array[Node], rest: RestParameterNode?, posts: Array[Node], keywords: Array[Node], keyword_rest: Node?, block: BlockParameterNode?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ParametersNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a parenthesized expression
+  #
+  #     (10 + 34)
+  #     ^^^^^^^^^
+  class ParenthesesNode < Node
+    attr_reader body: Node?
+    attr_reader opening_loc: Location
+    attr_reader closing_loc: Location
+
+    def initialize: (body: Node?, opening_loc: Location, closing_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ParenthesesNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def opening: () -> String
+
+    def closing: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `^` operator for pinning an expression in a
+  # pattern matching expression.
+  #
+  #     foo in ^(bar)
+  #            ^^^^^^
+  class PinnedExpressionNode < Node
+    attr_reader expression: Node
+    attr_reader operator_loc: Location
+    attr_reader lparen_loc: Location
+    attr_reader rparen_loc: Location
+
+    def initialize: (expression: Node, operator_loc: Location, lparen_loc: Location, rparen_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> PinnedExpressionNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def lparen: () -> String
+
+    def rparen: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `^` operator for pinning a variable in a pattern
+  # matching expression.
+  #
+  #     foo in ^bar
+  #            ^^^^
+  class PinnedVariableNode < Node
+    attr_reader variable: Node
+    attr_reader operator_loc: Location
+
+    def initialize: (variable: Node, operator_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> PinnedVariableNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `END` keyword.
+  #
+  #     END { foo }
+  #     ^^^^^^^^^^^
+  class PostExecutionNode < Node
+    attr_reader statements: StatementsNode?
+    attr_reader keyword_loc: Location
+    attr_reader opening_loc: Location
+    attr_reader closing_loc: Location
+
+    def initialize: (statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> PostExecutionNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def keyword: () -> String
+
+    def opening: () -> String
+
+    def closing: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `BEGIN` keyword.
+  #
+  #     BEGIN { foo }
+  #     ^^^^^^^^^^^^^
+  class PreExecutionNode < Node
+    attr_reader statements: StatementsNode?
+    attr_reader keyword_loc: Location
+    attr_reader opening_loc: Location
+    attr_reader closing_loc: Location
+
+    def initialize: (statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> PreExecutionNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def keyword: () -> String
+
+    def opening: () -> String
+
+    def closing: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # The top level node of any parse tree.
+  class ProgramNode < Node
+    attr_reader locals: Array[Symbol]
+    attr_reader statements: StatementsNode
+
+    def initialize: (locals: Array[Symbol], statements: StatementsNode, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ProgramNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `..` or `...` operators.
+  #
+  #     1..2
+  #     ^^^^
+  #
+  #     c if a =~ /left/ ... b =~ /right/
+  #          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  class RangeNode < Node
+    attr_reader left: Node?
+    attr_reader right: Node?
+    attr_reader operator_loc: Location
+    attr_reader flags: Integer
+
+    def initialize: (left: Node?, right: Node?, operator_loc: Location, flags: Integer, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> RangeNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def exclude_end?: () -> bool
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a rational number literal.
+  #
+  #     1.0r
+  #     ^^^^
+  class RationalNode < Node
+    attr_reader numeric: Node
+
+    def initialize: (numeric: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> RationalNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `redo` keyword.
+  #
+  #     redo
+  #     ^^^^
+  class RedoNode < Node
+
+    def initialize: (location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> RedoNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a regular expression literal with no interpolation.
+  #
+  #     /foo/i
+  #     ^^^^^^
+  class RegularExpressionNode < Node
+    attr_reader opening_loc: Location
+    attr_reader content_loc: Location
+    attr_reader closing_loc: Location
+    attr_reader unescaped: String
+    attr_reader flags: Integer
+
+    def initialize: (opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, flags: Integer, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> RegularExpressionNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def opening: () -> String
+
+    def content: () -> String
+
+    def closing: () -> String
+
+    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 inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a required keyword parameter to a method, block, or lambda definition.
+  #
+  #     def a(b: )
+  #           ^^
+  #     end
+  class RequiredKeywordParameterNode < Node
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+
+    def initialize: (name: Symbol, name_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> RequiredKeywordParameterNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a required parameter to a method, block, or lambda definition.
+  #
+  #     def a(b)
+  #           ^
+  #     end
+  class RequiredParameterNode < Node
+    attr_reader name: Symbol
+
+    def initialize: (name: Symbol, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> RequiredParameterNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents an expression modified with a rescue.
+  #
+  #     foo rescue nil
+  #     ^^^^^^^^^^^^^^
+  class RescueModifierNode < Node
+    attr_reader expression: Node
+    attr_reader keyword_loc: Location
+    attr_reader rescue_expression: Node
+
+    def initialize: (expression: Node, keyword_loc: Location, rescue_expression: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> RescueModifierNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def keyword: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  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 `exception` field.
+  class RescueNode < Node
+    attr_reader keyword_loc: Location
+    attr_reader exceptions: Array[Node]
+    attr_reader operator_loc: Location?
+    attr_reader reference: Node?
+    attr_reader statements: StatementsNode?
+    attr_reader consequent: RescueNode?
+
+    def initialize: (keyword_loc: Location, exceptions: Array[Node], operator_loc: Location?, reference: Node?, statements: StatementsNode?, consequent: RescueNode?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> RescueNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def keyword: () -> String
+
+    def operator: () -> String?
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a rest parameter to a method, block, or lambda definition.
+  #
+  #     def a(*b)
+  #           ^^
+  #     end
+  class RestParameterNode < Node
+    attr_reader name: Symbol?
+    attr_reader name_loc: Location?
+    attr_reader operator_loc: Location
+
+    def initialize: (name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> RestParameterNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `retry` keyword.
+  #
+  #     retry
+  #     ^^^^^
+  class RetryNode < Node
+
+    def initialize: (location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> RetryNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `return` keyword.
+  #
+  #     return 1
+  #     ^^^^^^^^
+  class ReturnNode < Node
+    attr_reader keyword_loc: Location
+    attr_reader arguments: ArgumentsNode?
+
+    def initialize: (keyword_loc: Location, arguments: ArgumentsNode?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> ReturnNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def keyword: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the `self` keyword.
+  #
+  #     self
+  #     ^^^^
+  class SelfNode < Node
+
+    def initialize: (location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> SelfNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a singleton class declaration involving the `class` keyword.
+  #
+  #     class << self end
+  #     ^^^^^^^^^^^^^^^^^
+  class SingletonClassNode < Node
+    attr_reader locals: Array[Symbol]
+    attr_reader class_keyword_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader expression: Node
+    attr_reader body: Node?
+    attr_reader end_keyword_loc: Location
+
+    def initialize: (locals: Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Node, body: Node?, end_keyword_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> SingletonClassNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def class_keyword: () -> String
+
+    def operator: () -> String
+
+    def end_keyword: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `__ENCODING__` keyword.
+  #
+  #     __ENCODING__
+  #     ^^^^^^^^^^^^
+  class SourceEncodingNode < Node
+
+    def initialize: (location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> SourceEncodingNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `__FILE__` keyword.
+  #
+  #     __FILE__
+  #     ^^^^^^^^
+  class SourceFileNode < Node
+    attr_reader filepath: String
+
+    def initialize: (filepath: String, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> SourceFileNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `__LINE__` keyword.
+  #
+  #     __LINE__
+  #     ^^^^^^^^
+  class SourceLineNode < Node
+
+    def initialize: (location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> SourceLineNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the splat operator.
+  #
+  #     [*a]
+  #      ^^
+  class SplatNode < Node
+    attr_reader operator_loc: Location
+    attr_reader expression: Node?
+
+    def initialize: (operator_loc: Location, expression: Node?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> SplatNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def operator: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a set of statements contained within some scope.
+  #
+  #     foo; bar; baz
+  #     ^^^^^^^^^^^^^
+  class StatementsNode < Node
+    attr_reader body: Array[Node]
+
+    def initialize: (body: Array[Node], location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> StatementsNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of compile-time string concatenation.
+  #
+  #     "foo" "bar"
+  #     ^^^^^^^^^^^
+  class StringConcatNode < Node
+    attr_reader left: Node
+    attr_reader right: Node
+
+    def initialize: (left: Node, right: Node, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> StringConcatNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  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
+    attr_reader flags: Integer
+    attr_reader opening_loc: Location?
+    attr_reader content_loc: Location
+    attr_reader closing_loc: Location?
+    attr_reader unescaped: String
+
+    def initialize: (flags: Integer, opening_loc: Location?, content_loc: Location, closing_loc: Location?, unescaped: String, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> StringNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def frozen?: () -> bool
+
+    def opening: () -> String?
+
+    def content: () -> String
+
+    def closing: () -> String?
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `super` keyword with parentheses or arguments.
+  #
+  #     super()
+  #     ^^^^^^^
+  #
+  #     super foo, bar
+  #     ^^^^^^^^^^^^^^
+  class SuperNode < Node
+    attr_reader keyword_loc: Location
+    attr_reader lparen_loc: Location?
+    attr_reader arguments: ArgumentsNode?
+    attr_reader rparen_loc: Location?
+    attr_reader block: Node?
+
+    def initialize: (keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, block: Node?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> SuperNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def keyword: () -> String
+
+    def lparen: () -> String?
+
+    def rparen: () -> String?
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents a symbol literal or a symbol contained within a `%i` list.
+  #
+  #     :foo
+  #     ^^^^
+  #
+  #     %i[foo]
+  #        ^^^
+  class SymbolNode < Node
+    attr_reader opening_loc: Location?
+    attr_reader value_loc: Location?
+    attr_reader closing_loc: Location?
+    attr_reader unescaped: String
+
+    def initialize: (opening_loc: Location?, value_loc: Location?, closing_loc: Location?, unescaped: String, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> SymbolNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def opening: () -> String?
+
+    def value: () -> String?
+
+    def closing: () -> String?
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the literal `true` keyword.
+  #
+  #     true
+  #     ^^^^
+  class TrueNode < Node
+
+    def initialize: (location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> TrueNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `undef` keyword.
+  #
+  #     undef :foo, :bar, :baz
+  #     ^^^^^^^^^^^^^^^^^^^^^^
+  class UndefNode < Node
+    attr_reader names: Array[Node]
+    attr_reader keyword_loc: Location
+
+    def initialize: (names: Array[Node], keyword_loc: Location, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> UndefNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def keyword: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  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
+    attr_reader keyword_loc: Location
+    attr_reader predicate: Node
+    attr_reader statements: StatementsNode?
+    attr_reader consequent: ElseNode?
+    attr_reader end_keyword_loc: Location?
+
+    def initialize: (keyword_loc: Location, predicate: Node, statements: StatementsNode?, consequent: ElseNode?, end_keyword_loc: Location?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> UnlessNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def keyword: () -> String
+
+    def end_keyword: () -> String?
+
+    def inspect: (inspector: NodeInspector) -> String
+  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
+    attr_reader keyword_loc: Location
+    attr_reader closing_loc: Location?
+    attr_reader predicate: Node
+    attr_reader statements: StatementsNode?
+    attr_reader flags: Integer
+
+    def initialize: (keyword_loc: Location, closing_loc: Location?, predicate: Node, statements: StatementsNode?, flags: Integer, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> UntilNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def keyword: () -> String
+
+    def closing: () -> String?
+
+    def begin_modifier?: () -> bool
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `when` keyword within a case statement.
+  #
+  #     case true
+  #     when true
+  #     ^^^^^^^^^
+  #     end
+  class WhenNode < Node
+    attr_reader keyword_loc: Location
+    attr_reader conditions: Array[Node]
+    attr_reader statements: StatementsNode?
+
+    def initialize: (keyword_loc: Location, conditions: Array[Node], statements: StatementsNode?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> WhenNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def keyword: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  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
+    attr_reader keyword_loc: Location
+    attr_reader closing_loc: Location?
+    attr_reader predicate: Node
+    attr_reader statements: StatementsNode?
+    attr_reader flags: Integer
+
+    def initialize: (keyword_loc: Location, closing_loc: Location?, predicate: Node, statements: StatementsNode?, flags: Integer, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> WhileNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def keyword: () -> String
+
+    def closing: () -> String?
+
+    def begin_modifier?: () -> bool
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents an xstring literal with no interpolation.
+  #
+  #     `foo`
+  #     ^^^^^
+  class XStringNode < Node
+    attr_reader opening_loc: Location
+    attr_reader content_loc: Location
+    attr_reader closing_loc: Location
+    attr_reader unescaped: String
+
+    def initialize: (opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> XStringNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def opening: () -> String
+
+    def content: () -> String
+
+    def closing: () -> String
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+  # Represents the use of the `yield` keyword.
+  #
+  #     yield 1
+  #     ^^^^^^^
+  class YieldNode < Node
+    attr_reader keyword_loc: Location
+    attr_reader lparen_loc: Location?
+    attr_reader arguments: ArgumentsNode?
+    attr_reader rparen_loc: Location?
+
+    def initialize: (keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, location: Location) -> void
+    def accept: (visitor: Visitor) -> void
+    def set_newline_flag: (newline_marked: Array[bool]) -> void
+    def child_nodes: () -> Array[Node?]
+    def deconstruct: () -> Array[Node?]
+
+    def copy: (**untyped) -> YieldNode
+
+    def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, (Node | Array[Node] | String | Token | Array[Token] | Location)?]
+
+    def keyword: () -> String
+
+    def lparen: () -> String?
+
+    def rparen: () -> String?
+
+    def inspect: (inspector: NodeInspector) -> String
+  end
+
+  # Flags for arguments nodes.
+  module ArgumentsNodeFlags
+    # if arguments contain keyword splat
+    KEYWORD_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
+  end
+
+  # Flags for integer nodes that correspond to the base of the integer.
+  module IntegerBaseFlags
+    # 0b prefix
+    BINARY: Integer
+    # 0o or 0 prefix
+    OCTAL: Integer
+    # 0d or no prefix
+    DECIMAL: Integer
+    # 0x prefix
+    HEXADECIMAL: 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 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
+  end
+
+  # Flags for string nodes.
+  module StringFlags
+    # frozen by virtue of a `frozen_string_literal` comment
+    FROZEN: Integer
+  end
+
+
+  class Visitor < BasicVisitor
+    # Visit a AliasGlobalVariableNode node
+    def visit_alias_global_variable_node: (node: AliasGlobalVariableNode) -> void
+    
+    # Visit a AliasMethodNode node
+    def visit_alias_method_node: (node: AliasMethodNode) -> void
+    
+    # Visit a AlternationPatternNode node
+    def visit_alternation_pattern_node: (node: AlternationPatternNode) -> void
+    
+    # Visit a AndNode node
+    def visit_and_node: (node: AndNode) -> void
+    
+    # Visit a ArgumentsNode node
+    def visit_arguments_node: (node: ArgumentsNode) -> void
+    
+    # Visit a ArrayNode node
+    def visit_array_node: (node: ArrayNode) -> void
+    
+    # Visit a ArrayPatternNode node
+    def visit_array_pattern_node: (node: ArrayPatternNode) -> void
+    
+    # Visit a AssocNode node
+    def visit_assoc_node: (node: AssocNode) -> void
+    
+    # Visit a AssocSplatNode node
+    def visit_assoc_splat_node: (node: AssocSplatNode) -> void
+    
+    # Visit a BackReferenceReadNode node
+    def visit_back_reference_read_node: (node: BackReferenceReadNode) -> void
+    
+    # Visit a BeginNode node
+    def visit_begin_node: (node: BeginNode) -> void
+    
+    # Visit a BlockArgumentNode node
+    def visit_block_argument_node: (node: BlockArgumentNode) -> void
+    
+    # Visit a BlockLocalVariableNode node
+    def visit_block_local_variable_node: (node: BlockLocalVariableNode) -> void
+    
+    # Visit a BlockNode node
+    def visit_block_node: (node: BlockNode) -> void
+    
+    # Visit a BlockParameterNode node
+    def visit_block_parameter_node: (node: BlockParameterNode) -> void
+    
+    # Visit a BlockParametersNode node
+    def visit_block_parameters_node: (node: BlockParametersNode) -> void
+    
+    # Visit a BreakNode node
+    def visit_break_node: (node: BreakNode) -> void
+    
+    # Visit a CallAndWriteNode node
+    def visit_call_and_write_node: (node: CallAndWriteNode) -> void
+    
+    # Visit a CallNode node
+    def visit_call_node: (node: CallNode) -> void
+    
+    # Visit a CallOperatorWriteNode node
+    def visit_call_operator_write_node: (node: CallOperatorWriteNode) -> void
+    
+    # Visit a CallOrWriteNode node
+    def visit_call_or_write_node: (node: CallOrWriteNode) -> void
+    
+    # Visit a CapturePatternNode node
+    def visit_capture_pattern_node: (node: CapturePatternNode) -> void
+    
+    # Visit a CaseNode node
+    def visit_case_node: (node: CaseNode) -> void
+    
+    # Visit a ClassNode node
+    def visit_class_node: (node: ClassNode) -> void
+    
+    # Visit a ClassVariableAndWriteNode node
+    def visit_class_variable_and_write_node: (node: ClassVariableAndWriteNode) -> void
+    
+    # Visit a ClassVariableOperatorWriteNode node
+    def visit_class_variable_operator_write_node: (node: ClassVariableOperatorWriteNode) -> void
+    
+    # Visit a ClassVariableOrWriteNode node
+    def visit_class_variable_or_write_node: (node: ClassVariableOrWriteNode) -> void
+    
+    # Visit a ClassVariableReadNode node
+    def visit_class_variable_read_node: (node: ClassVariableReadNode) -> void
+    
+    # Visit a ClassVariableTargetNode node
+    def visit_class_variable_target_node: (node: ClassVariableTargetNode) -> void
+    
+    # Visit a ClassVariableWriteNode node
+    def visit_class_variable_write_node: (node: ClassVariableWriteNode) -> void
+    
+    # Visit a ConstantAndWriteNode node
+    def visit_constant_and_write_node: (node: ConstantAndWriteNode) -> void
+    
+    # Visit a ConstantOperatorWriteNode node
+    def visit_constant_operator_write_node: (node: ConstantOperatorWriteNode) -> void
+    
+    # Visit a ConstantOrWriteNode node
+    def visit_constant_or_write_node: (node: ConstantOrWriteNode) -> void
+    
+    # Visit a ConstantPathAndWriteNode node
+    def visit_constant_path_and_write_node: (node: ConstantPathAndWriteNode) -> void
+    
+    # Visit a ConstantPathNode node
+    def visit_constant_path_node: (node: ConstantPathNode) -> void
+    
+    # Visit a ConstantPathOperatorWriteNode node
+    def visit_constant_path_operator_write_node: (node: ConstantPathOperatorWriteNode) -> void
+    
+    # Visit a ConstantPathOrWriteNode node
+    def visit_constant_path_or_write_node: (node: ConstantPathOrWriteNode) -> void
+    
+    # Visit a ConstantPathTargetNode node
+    def visit_constant_path_target_node: (node: ConstantPathTargetNode) -> void
+    
+    # Visit a ConstantPathWriteNode node
+    def visit_constant_path_write_node: (node: ConstantPathWriteNode) -> void
+    
+    # Visit a ConstantReadNode node
+    def visit_constant_read_node: (node: ConstantReadNode) -> void
+    
+    # Visit a ConstantTargetNode node
+    def visit_constant_target_node: (node: ConstantTargetNode) -> void
+    
+    # Visit a ConstantWriteNode node
+    def visit_constant_write_node: (node: ConstantWriteNode) -> void
+    
+    # Visit a DefNode node
+    def visit_def_node: (node: DefNode) -> void
+    
+    # Visit a DefinedNode node
+    def visit_defined_node: (node: DefinedNode) -> void
+    
+    # Visit a ElseNode node
+    def visit_else_node: (node: ElseNode) -> void
+    
+    # Visit a EmbeddedStatementsNode node
+    def visit_embedded_statements_node: (node: EmbeddedStatementsNode) -> void
+    
+    # Visit a EmbeddedVariableNode node
+    def visit_embedded_variable_node: (node: EmbeddedVariableNode) -> void
+    
+    # Visit a EnsureNode node
+    def visit_ensure_node: (node: EnsureNode) -> void
+    
+    # Visit a FalseNode node
+    def visit_false_node: (node: FalseNode) -> void
+    
+    # Visit a FindPatternNode node
+    def visit_find_pattern_node: (node: FindPatternNode) -> void
+    
+    # Visit a FlipFlopNode node
+    def visit_flip_flop_node: (node: FlipFlopNode) -> void
+    
+    # Visit a FloatNode node
+    def visit_float_node: (node: FloatNode) -> void
+    
+    # Visit a ForNode node
+    def visit_for_node: (node: ForNode) -> void
+    
+    # Visit a ForwardingArgumentsNode node
+    def visit_forwarding_arguments_node: (node: ForwardingArgumentsNode) -> void
+    
+    # Visit a ForwardingParameterNode node
+    def visit_forwarding_parameter_node: (node: ForwardingParameterNode) -> void
+    
+    # Visit a ForwardingSuperNode node
+    def visit_forwarding_super_node: (node: ForwardingSuperNode) -> void
+    
+    # Visit a GlobalVariableAndWriteNode node
+    def visit_global_variable_and_write_node: (node: GlobalVariableAndWriteNode) -> void
+    
+    # Visit a GlobalVariableOperatorWriteNode node
+    def visit_global_variable_operator_write_node: (node: GlobalVariableOperatorWriteNode) -> void
+    
+    # Visit a GlobalVariableOrWriteNode node
+    def visit_global_variable_or_write_node: (node: GlobalVariableOrWriteNode) -> void
+    
+    # Visit a GlobalVariableReadNode node
+    def visit_global_variable_read_node: (node: GlobalVariableReadNode) -> void
+    
+    # Visit a GlobalVariableTargetNode node
+    def visit_global_variable_target_node: (node: GlobalVariableTargetNode) -> void
+    
+    # Visit a GlobalVariableWriteNode node
+    def visit_global_variable_write_node: (node: GlobalVariableWriteNode) -> void
+    
+    # Visit a HashNode node
+    def visit_hash_node: (node: HashNode) -> void
+    
+    # Visit a HashPatternNode node
+    def visit_hash_pattern_node: (node: HashPatternNode) -> void
+    
+    # Visit a IfNode node
+    def visit_if_node: (node: IfNode) -> void
+    
+    # Visit a ImaginaryNode node
+    def visit_imaginary_node: (node: ImaginaryNode) -> void
+    
+    # Visit a ImplicitNode node
+    def visit_implicit_node: (node: ImplicitNode) -> void
+    
+    # Visit a InNode node
+    def visit_in_node: (node: InNode) -> void
+    
+    # Visit a IndexAndWriteNode node
+    def visit_index_and_write_node: (node: IndexAndWriteNode) -> void
+    
+    # Visit a IndexOperatorWriteNode node
+    def visit_index_operator_write_node: (node: IndexOperatorWriteNode) -> void
+    
+    # Visit a IndexOrWriteNode node
+    def visit_index_or_write_node: (node: IndexOrWriteNode) -> void
+    
+    # Visit a InstanceVariableAndWriteNode node
+    def visit_instance_variable_and_write_node: (node: InstanceVariableAndWriteNode) -> void
+    
+    # Visit a InstanceVariableOperatorWriteNode node
+    def visit_instance_variable_operator_write_node: (node: InstanceVariableOperatorWriteNode) -> void
+    
+    # Visit a InstanceVariableOrWriteNode node
+    def visit_instance_variable_or_write_node: (node: InstanceVariableOrWriteNode) -> void
+    
+    # Visit a InstanceVariableReadNode node
+    def visit_instance_variable_read_node: (node: InstanceVariableReadNode) -> void
+    
+    # Visit a InstanceVariableTargetNode node
+    def visit_instance_variable_target_node: (node: InstanceVariableTargetNode) -> void
+    
+    # Visit a InstanceVariableWriteNode node
+    def visit_instance_variable_write_node: (node: InstanceVariableWriteNode) -> void
+    
+    # Visit a IntegerNode node
+    def visit_integer_node: (node: IntegerNode) -> void
+    
+    # Visit a InterpolatedMatchLastLineNode node
+    def visit_interpolated_match_last_line_node: (node: InterpolatedMatchLastLineNode) -> void
+    
+    # Visit a InterpolatedRegularExpressionNode node
+    def visit_interpolated_regular_expression_node: (node: InterpolatedRegularExpressionNode) -> void
+    
+    # Visit a InterpolatedStringNode node
+    def visit_interpolated_string_node: (node: InterpolatedStringNode) -> void
+    
+    # Visit a InterpolatedSymbolNode node
+    def visit_interpolated_symbol_node: (node: InterpolatedSymbolNode) -> void
+    
+    # Visit a InterpolatedXStringNode node
+    def visit_interpolated_x_string_node: (node: InterpolatedXStringNode) -> void
+    
+    # Visit a KeywordHashNode node
+    def visit_keyword_hash_node: (node: KeywordHashNode) -> void
+    
+    # Visit a KeywordRestParameterNode node
+    def visit_keyword_rest_parameter_node: (node: KeywordRestParameterNode) -> void
+    
+    # Visit a LambdaNode node
+    def visit_lambda_node: (node: LambdaNode) -> void
+    
+    # Visit a LocalVariableAndWriteNode node
+    def visit_local_variable_and_write_node: (node: LocalVariableAndWriteNode) -> void
+    
+    # Visit a LocalVariableOperatorWriteNode node
+    def visit_local_variable_operator_write_node: (node: LocalVariableOperatorWriteNode) -> void
+    
+    # Visit a LocalVariableOrWriteNode node
+    def visit_local_variable_or_write_node: (node: LocalVariableOrWriteNode) -> void
+    
+    # Visit a LocalVariableReadNode node
+    def visit_local_variable_read_node: (node: LocalVariableReadNode) -> void
+    
+    # Visit a LocalVariableTargetNode node
+    def visit_local_variable_target_node: (node: LocalVariableTargetNode) -> void
+    
+    # Visit a LocalVariableWriteNode node
+    def visit_local_variable_write_node: (node: LocalVariableWriteNode) -> void
+    
+    # Visit a MatchLastLineNode node
+    def visit_match_last_line_node: (node: MatchLastLineNode) -> void
+    
+    # Visit a MatchPredicateNode node
+    def visit_match_predicate_node: (node: MatchPredicateNode) -> void
+    
+    # Visit a MatchRequiredNode node
+    def visit_match_required_node: (node: MatchRequiredNode) -> void
+    
+    # Visit a MatchWriteNode node
+    def visit_match_write_node: (node: MatchWriteNode) -> void
+    
+    # Visit a MissingNode node
+    def visit_missing_node: (node: MissingNode) -> void
+    
+    # Visit a ModuleNode node
+    def visit_module_node: (node: ModuleNode) -> void
+    
+    # Visit a MultiTargetNode node
+    def visit_multi_target_node: (node: MultiTargetNode) -> void
+    
+    # Visit a MultiWriteNode node
+    def visit_multi_write_node: (node: MultiWriteNode) -> void
+    
+    # Visit a NextNode node
+    def visit_next_node: (node: NextNode) -> void
+    
+    # Visit a NilNode node
+    def visit_nil_node: (node: NilNode) -> void
+    
+    # Visit a NoKeywordsParameterNode node
+    def visit_no_keywords_parameter_node: (node: NoKeywordsParameterNode) -> void
+    
+    # Visit a NumberedReferenceReadNode node
+    def visit_numbered_reference_read_node: (node: NumberedReferenceReadNode) -> void
+    
+    # Visit a OptionalKeywordParameterNode node
+    def visit_optional_keyword_parameter_node: (node: OptionalKeywordParameterNode) -> void
+    
+    # Visit a OptionalParameterNode node
+    def visit_optional_parameter_node: (node: OptionalParameterNode) -> void
+    
+    # Visit a OrNode node
+    def visit_or_node: (node: OrNode) -> void
+    
+    # Visit a ParametersNode node
+    def visit_parameters_node: (node: ParametersNode) -> void
+    
+    # Visit a ParenthesesNode node
+    def visit_parentheses_node: (node: ParenthesesNode) -> void
+    
+    # Visit a PinnedExpressionNode node
+    def visit_pinned_expression_node: (node: PinnedExpressionNode) -> void
+    
+    # Visit a PinnedVariableNode node
+    def visit_pinned_variable_node: (node: PinnedVariableNode) -> void
+    
+    # Visit a PostExecutionNode node
+    def visit_post_execution_node: (node: PostExecutionNode) -> void
+    
+    # Visit a PreExecutionNode node
+    def visit_pre_execution_node: (node: PreExecutionNode) -> void
+    
+    # Visit a ProgramNode node
+    def visit_program_node: (node: ProgramNode) -> void
+    
+    # Visit a RangeNode node
+    def visit_range_node: (node: RangeNode) -> void
+    
+    # Visit a RationalNode node
+    def visit_rational_node: (node: RationalNode) -> void
+    
+    # Visit a RedoNode node
+    def visit_redo_node: (node: RedoNode) -> void
+    
+    # Visit a RegularExpressionNode node
+    def visit_regular_expression_node: (node: RegularExpressionNode) -> void
+    
+    # Visit a RequiredKeywordParameterNode node
+    def visit_required_keyword_parameter_node: (node: RequiredKeywordParameterNode) -> void
+    
+    # Visit a RequiredParameterNode node
+    def visit_required_parameter_node: (node: RequiredParameterNode) -> void
+    
+    # Visit a RescueModifierNode node
+    def visit_rescue_modifier_node: (node: RescueModifierNode) -> void
+    
+    # Visit a RescueNode node
+    def visit_rescue_node: (node: RescueNode) -> void
+    
+    # Visit a RestParameterNode node
+    def visit_rest_parameter_node: (node: RestParameterNode) -> void
+    
+    # Visit a RetryNode node
+    def visit_retry_node: (node: RetryNode) -> void
+    
+    # Visit a ReturnNode node
+    def visit_return_node: (node: ReturnNode) -> void
+    
+    # Visit a SelfNode node
+    def visit_self_node: (node: SelfNode) -> void
+    
+    # Visit a SingletonClassNode node
+    def visit_singleton_class_node: (node: SingletonClassNode) -> void
+    
+    # Visit a SourceEncodingNode node
+    def visit_source_encoding_node: (node: SourceEncodingNode) -> void
+    
+    # Visit a SourceFileNode node
+    def visit_source_file_node: (node: SourceFileNode) -> void
+    
+    # Visit a SourceLineNode node
+    def visit_source_line_node: (node: SourceLineNode) -> void
+    
+    # Visit a SplatNode node
+    def visit_splat_node: (node: SplatNode) -> void
+    
+    # Visit a StatementsNode node
+    def visit_statements_node: (node: StatementsNode) -> void
+    
+    # Visit a StringConcatNode node
+    def visit_string_concat_node: (node: StringConcatNode) -> void
+    
+    # Visit a StringNode node
+    def visit_string_node: (node: StringNode) -> void
+    
+    # Visit a SuperNode node
+    def visit_super_node: (node: SuperNode) -> void
+    
+    # Visit a SymbolNode node
+    def visit_symbol_node: (node: SymbolNode) -> void
+    
+    # Visit a TrueNode node
+    def visit_true_node: (node: TrueNode) -> void
+    
+    # Visit a UndefNode node
+    def visit_undef_node: (node: UndefNode) -> void
+    
+    # Visit a UnlessNode node
+    def visit_unless_node: (node: UnlessNode) -> void
+    
+    # Visit a UntilNode node
+    def visit_until_node: (node: UntilNode) -> void
+    
+    # Visit a WhenNode node
+    def visit_when_node: (node: WhenNode) -> void
+    
+    # Visit a WhileNode node
+    def visit_while_node: (node: WhileNode) -> void
+    
+    # Visit a XStringNode node
+    def visit_x_string_node: (node: XStringNode) -> void
+    
+    # Visit a YieldNode node
+    def visit_yield_node: (node: YieldNode) -> void
+      end
+
+  module DSL
+    private
+
+    # Create a new Location object
+    def Location: (source: Source?, start_offset: Integer, length: Integer) -> Location
+
+    # Create a new AliasGlobalVariableNode node
+    def AliasGlobalVariableNode: (new_name: Node, old_name: Node, keyword_loc: Location, location: Location) -> AliasGlobalVariableNode
+    # Create a new AliasMethodNode node
+    def AliasMethodNode: (new_name: Node, old_name: Node, keyword_loc: Location, location: Location) -> AliasMethodNode
+    # Create a new AlternationPatternNode node
+    def AlternationPatternNode: (left: Node, right: Node, operator_loc: Location, location: Location) -> AlternationPatternNode
+    # Create a new AndNode node
+    def AndNode: (left: Node, right: Node, operator_loc: Location, location: Location) -> AndNode
+    # Create a new ArgumentsNode node
+    def ArgumentsNode: (arguments: Array[Node], flags: Integer, location: Location) -> ArgumentsNode
+    # Create a new ArrayNode node
+    def ArrayNode: (elements: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location) -> ArrayNode
+    # Create a new ArrayPatternNode node
+    def ArrayPatternNode: (constant: Node?, requireds: Array[Node], rest: Node?, posts: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location) -> ArrayPatternNode
+    # Create a new AssocNode node
+    def AssocNode: (key: Node, value: Node?, operator_loc: Location?, location: Location) -> AssocNode
+    # Create a new AssocSplatNode node
+    def AssocSplatNode: (value: Node?, operator_loc: Location, location: Location) -> AssocSplatNode
+    # Create a new BackReferenceReadNode node
+    def BackReferenceReadNode: (name: Symbol, location: Location) -> BackReferenceReadNode
+    # Create a new BeginNode node
+    def BeginNode: (begin_keyword_loc: Location?, statements: StatementsNode?, rescue_clause: RescueNode?, else_clause: ElseNode?, ensure_clause: EnsureNode?, end_keyword_loc: Location?, location: Location) -> BeginNode
+    # Create a new BlockArgumentNode node
+    def BlockArgumentNode: (expression: Node?, operator_loc: Location, location: Location) -> BlockArgumentNode
+    # Create a new BlockLocalVariableNode node
+    def BlockLocalVariableNode: (name: Symbol, location: Location) -> BlockLocalVariableNode
+    # Create a new BlockNode node
+    def BlockNode: (locals: Array[Symbol], parameters: BlockParametersNode?, body: Node?, opening_loc: Location, closing_loc: Location, location: Location) -> BlockNode
+    # Create a new BlockParameterNode node
+    def BlockParameterNode: (name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location) -> BlockParameterNode
+    # Create a new BlockParametersNode node
+    def BlockParametersNode: (parameters: ParametersNode?, locals: Array[Node], opening_loc: Location?, closing_loc: Location?, location: Location) -> BlockParametersNode
+    # Create a new BreakNode node
+    def BreakNode: (arguments: ArgumentsNode?, keyword_loc: Location, location: Location) -> BreakNode
+    # Create a new CallAndWriteNode node
+    def CallAndWriteNode: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, flags: Integer, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location) -> CallAndWriteNode
+    # Create a new CallNode node
+    def CallNode: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: Node?, flags: Integer, name: Symbol, location: Location) -> CallNode
+    # Create a new CallOperatorWriteNode node
+    def CallOperatorWriteNode: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, flags: Integer, read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Location, value: Node, location: Location) -> CallOperatorWriteNode
+    # Create a new CallOrWriteNode node
+    def CallOrWriteNode: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, flags: Integer, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location) -> CallOrWriteNode
+    # Create a new CapturePatternNode node
+    def CapturePatternNode: (value: Node, target: Node, operator_loc: Location, location: Location) -> CapturePatternNode
+    # Create a new CaseNode node
+    def CaseNode: (predicate: Node?, conditions: Array[Node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location) -> CaseNode
+    # Create a new ClassNode node
+    def ClassNode: (locals: Array[Symbol], class_keyword_loc: Location, constant_path: Node, inheritance_operator_loc: Location?, superclass: Node?, body: Node?, end_keyword_loc: Location, name: Symbol, location: Location) -> ClassNode
+    # Create a new ClassVariableAndWriteNode node
+    def ClassVariableAndWriteNode: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> ClassVariableAndWriteNode
+    # Create a new ClassVariableOperatorWriteNode node
+    def ClassVariableOperatorWriteNode: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> ClassVariableOperatorWriteNode
+    # Create a new ClassVariableOrWriteNode node
+    def ClassVariableOrWriteNode: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> ClassVariableOrWriteNode
+    # Create a new ClassVariableReadNode node
+    def ClassVariableReadNode: (name: Symbol, location: Location) -> ClassVariableReadNode
+    # Create a new ClassVariableTargetNode node
+    def ClassVariableTargetNode: (name: Symbol, location: Location) -> ClassVariableTargetNode
+    # Create a new ClassVariableWriteNode node
+    def ClassVariableWriteNode: (name: Symbol, name_loc: Location, value: Node, operator_loc: Location?, location: Location) -> ClassVariableWriteNode
+    # Create a new ConstantAndWriteNode node
+    def ConstantAndWriteNode: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> ConstantAndWriteNode
+    # Create a new ConstantOperatorWriteNode node
+    def ConstantOperatorWriteNode: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> ConstantOperatorWriteNode
+    # Create a new ConstantOrWriteNode node
+    def ConstantOrWriteNode: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> ConstantOrWriteNode
+    # Create a new ConstantPathAndWriteNode node
+    def ConstantPathAndWriteNode: (target: ConstantPathNode, operator_loc: Location, value: Node, location: Location) -> ConstantPathAndWriteNode
+    # Create a new ConstantPathNode node
+    def ConstantPathNode: (parent: Node?, child: Node, delimiter_loc: Location, location: Location) -> ConstantPathNode
+    # Create a new ConstantPathOperatorWriteNode node
+    def ConstantPathOperatorWriteNode: (target: ConstantPathNode, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> ConstantPathOperatorWriteNode
+    # Create a new ConstantPathOrWriteNode node
+    def ConstantPathOrWriteNode: (target: ConstantPathNode, operator_loc: Location, value: Node, location: Location) -> ConstantPathOrWriteNode
+    # Create a new ConstantPathTargetNode node
+    def ConstantPathTargetNode: (parent: Node?, child: Node, delimiter_loc: Location, location: Location) -> ConstantPathTargetNode
+    # Create a new ConstantPathWriteNode node
+    def ConstantPathWriteNode: (target: ConstantPathNode, operator_loc: Location, value: Node, location: Location) -> ConstantPathWriteNode
+    # Create a new ConstantReadNode node
+    def ConstantReadNode: (name: Symbol, location: Location) -> ConstantReadNode
+    # Create a new ConstantTargetNode node
+    def ConstantTargetNode: (name: Symbol, location: Location) -> ConstantTargetNode
+    # Create a new ConstantWriteNode node
+    def ConstantWriteNode: (name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> ConstantWriteNode
+    # Create a new DefNode node
+    def DefNode: (name: Symbol, name_loc: Location, receiver: Node?, parameters: ParametersNode?, body: Node?, locals: Array[Symbol], def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location?, location: Location) -> DefNode
+    # Create a new DefinedNode node
+    def DefinedNode: (lparen_loc: Location?, value: Node, rparen_loc: Location?, keyword_loc: Location, location: Location) -> DefinedNode
+    # Create a new ElseNode node
+    def ElseNode: (else_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location?, location: Location) -> ElseNode
+    # Create a new EmbeddedStatementsNode node
+    def EmbeddedStatementsNode: (opening_loc: Location, statements: StatementsNode?, closing_loc: Location, location: Location) -> EmbeddedStatementsNode
+    # Create a new EmbeddedVariableNode node
+    def EmbeddedVariableNode: (operator_loc: Location, variable: Node, location: Location) -> EmbeddedVariableNode
+    # Create a new EnsureNode node
+    def EnsureNode: (ensure_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location, location: Location) -> EnsureNode
+    # Create a new FalseNode node
+    def FalseNode: (location: Location) -> FalseNode
+    # Create a new FindPatternNode node
+    def FindPatternNode: (constant: Node?, left: Node, requireds: Array[Node], right: Node, opening_loc: Location?, closing_loc: Location?, location: Location) -> FindPatternNode
+    # Create a new FlipFlopNode node
+    def FlipFlopNode: (left: Node?, right: Node?, operator_loc: Location, flags: Integer, location: Location) -> FlipFlopNode
+    # Create a new FloatNode node
+    def FloatNode: (location: Location) -> FloatNode
+    # Create a new ForNode node
+    def ForNode: (index: Node, collection: Node, statements: StatementsNode?, for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: Location?, end_keyword_loc: Location, location: Location) -> ForNode
+    # Create a new ForwardingArgumentsNode node
+    def ForwardingArgumentsNode: (location: Location) -> ForwardingArgumentsNode
+    # Create a new ForwardingParameterNode node
+    def ForwardingParameterNode: (location: Location) -> ForwardingParameterNode
+    # Create a new ForwardingSuperNode node
+    def ForwardingSuperNode: (block: BlockNode?, location: Location) -> ForwardingSuperNode
+    # Create a new GlobalVariableAndWriteNode node
+    def GlobalVariableAndWriteNode: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> GlobalVariableAndWriteNode
+    # Create a new GlobalVariableOperatorWriteNode node
+    def GlobalVariableOperatorWriteNode: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> GlobalVariableOperatorWriteNode
+    # Create a new GlobalVariableOrWriteNode node
+    def GlobalVariableOrWriteNode: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> GlobalVariableOrWriteNode
+    # Create a new GlobalVariableReadNode node
+    def GlobalVariableReadNode: (name: Symbol, location: Location) -> GlobalVariableReadNode
+    # Create a new GlobalVariableTargetNode node
+    def GlobalVariableTargetNode: (name: Symbol, location: Location) -> GlobalVariableTargetNode
+    # Create a new GlobalVariableWriteNode node
+    def GlobalVariableWriteNode: (name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> GlobalVariableWriteNode
+    # Create a new HashNode node
+    def HashNode: (opening_loc: Location, elements: Array[Node], closing_loc: Location, location: Location) -> HashNode
+    # Create a new HashPatternNode node
+    def HashPatternNode: (constant: Node?, elements: Array[Node], rest: Node?, opening_loc: Location?, closing_loc: Location?, location: Location) -> HashPatternNode
+    # Create a new IfNode node
+    def IfNode: (if_keyword_loc: Location?, predicate: Node, statements: StatementsNode?, consequent: Node?, end_keyword_loc: Location?, location: Location) -> IfNode
+    # Create a new ImaginaryNode node
+    def ImaginaryNode: (numeric: Node, location: Location) -> ImaginaryNode
+    # Create a new ImplicitNode node
+    def ImplicitNode: (value: Node, location: Location) -> ImplicitNode
+    # Create a new InNode node
+    def InNode: (pattern: Node, statements: StatementsNode?, in_loc: Location, then_loc: Location?, location: Location) -> InNode
+    # Create a new IndexAndWriteNode node
+    def IndexAndWriteNode: (receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, flags: Integer, operator_loc: Location, value: Node, location: Location) -> IndexAndWriteNode
+    # Create a new IndexOperatorWriteNode node
+    def IndexOperatorWriteNode: (receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, flags: Integer, operator: Symbol, operator_loc: Location, value: Node, location: Location) -> IndexOperatorWriteNode
+    # Create a new IndexOrWriteNode node
+    def IndexOrWriteNode: (receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, flags: Integer, operator_loc: Location, value: Node, location: Location) -> IndexOrWriteNode
+    # Create a new InstanceVariableAndWriteNode node
+    def InstanceVariableAndWriteNode: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> InstanceVariableAndWriteNode
+    # Create a new InstanceVariableOperatorWriteNode node
+    def InstanceVariableOperatorWriteNode: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> InstanceVariableOperatorWriteNode
+    # Create a new InstanceVariableOrWriteNode node
+    def InstanceVariableOrWriteNode: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> InstanceVariableOrWriteNode
+    # Create a new InstanceVariableReadNode node
+    def InstanceVariableReadNode: (name: Symbol, location: Location) -> InstanceVariableReadNode
+    # Create a new InstanceVariableTargetNode node
+    def InstanceVariableTargetNode: (name: Symbol, location: Location) -> InstanceVariableTargetNode
+    # Create a new InstanceVariableWriteNode node
+    def InstanceVariableWriteNode: (name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> InstanceVariableWriteNode
+    # Create a new IntegerNode node
+    def IntegerNode: (flags: Integer, location: Location) -> IntegerNode
+    # Create a new InterpolatedMatchLastLineNode node
+    def InterpolatedMatchLastLineNode: (opening_loc: Location, parts: Array[Node], closing_loc: Location, flags: Integer, location: Location) -> InterpolatedMatchLastLineNode
+    # Create a new InterpolatedRegularExpressionNode node
+    def InterpolatedRegularExpressionNode: (opening_loc: Location, parts: Array[Node], closing_loc: Location, flags: Integer, location: Location) -> InterpolatedRegularExpressionNode
+    # Create a new InterpolatedStringNode node
+    def InterpolatedStringNode: (opening_loc: Location?, parts: Array[Node], closing_loc: Location?, location: Location) -> InterpolatedStringNode
+    # Create a new InterpolatedSymbolNode node
+    def InterpolatedSymbolNode: (opening_loc: Location?, parts: Array[Node], closing_loc: Location?, location: Location) -> InterpolatedSymbolNode
+    # Create a new InterpolatedXStringNode node
+    def InterpolatedXStringNode: (opening_loc: Location, parts: Array[Node], closing_loc: Location, location: Location) -> InterpolatedXStringNode
+    # Create a new KeywordHashNode node
+    def KeywordHashNode: (elements: Array[Node], location: Location) -> KeywordHashNode
+    # Create a new KeywordRestParameterNode node
+    def KeywordRestParameterNode: (name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location) -> KeywordRestParameterNode
+    # Create a new LambdaNode node
+    def LambdaNode: (locals: Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: BlockParametersNode?, body: Node?, location: Location) -> LambdaNode
+    # Create a new LocalVariableAndWriteNode node
+    def LocalVariableAndWriteNode: (name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location) -> LocalVariableAndWriteNode
+    # Create a new LocalVariableOperatorWriteNode node
+    def LocalVariableOperatorWriteNode: (name_loc: Location, operator_loc: Location, value: Node, name: Symbol, operator: Symbol, depth: Integer, location: Location) -> LocalVariableOperatorWriteNode
+    # Create a new LocalVariableOrWriteNode node
+    def LocalVariableOrWriteNode: (name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location) -> LocalVariableOrWriteNode
+    # Create a new LocalVariableReadNode node
+    def LocalVariableReadNode: (name: Symbol, depth: Integer, location: Location) -> LocalVariableReadNode
+    # Create a new LocalVariableTargetNode node
+    def LocalVariableTargetNode: (name: Symbol, depth: Integer, location: Location) -> LocalVariableTargetNode
+    # Create a new LocalVariableWriteNode node
+    def LocalVariableWriteNode: (name: Symbol, depth: Integer, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> LocalVariableWriteNode
+    # Create a new MatchLastLineNode node
+    def MatchLastLineNode: (opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, flags: Integer, location: Location) -> MatchLastLineNode
+    # Create a new MatchPredicateNode node
+    def MatchPredicateNode: (value: Node, pattern: Node, operator_loc: Location, location: Location) -> MatchPredicateNode
+    # Create a new MatchRequiredNode node
+    def MatchRequiredNode: (value: Node, pattern: Node, operator_loc: Location, location: Location) -> MatchRequiredNode
+    # Create a new MatchWriteNode node
+    def MatchWriteNode: (call: CallNode, locals: Array[Symbol], location: Location) -> MatchWriteNode
+    # Create a new MissingNode node
+    def MissingNode: (location: Location) -> MissingNode
+    # Create a new ModuleNode node
+    def ModuleNode: (locals: Array[Symbol], module_keyword_loc: Location, constant_path: Node, body: Node?, end_keyword_loc: Location, name: Symbol, location: Location) -> ModuleNode
+    # Create a new MultiTargetNode node
+    def MultiTargetNode: (lefts: Array[Node], rest: Node?, rights: Array[Node], lparen_loc: Location?, rparen_loc: Location?, location: Location) -> MultiTargetNode
+    # Create a new MultiWriteNode node
+    def MultiWriteNode: (lefts: Array[Node], rest: Node?, rights: Array[Node], lparen_loc: Location?, rparen_loc: Location?, operator_loc: Location, value: Node, location: Location) -> MultiWriteNode
+    # Create a new NextNode node
+    def NextNode: (arguments: ArgumentsNode?, keyword_loc: Location, location: Location) -> NextNode
+    # Create a new NilNode node
+    def NilNode: (location: Location) -> NilNode
+    # Create a new NoKeywordsParameterNode node
+    def NoKeywordsParameterNode: (operator_loc: Location, keyword_loc: Location, location: Location) -> NoKeywordsParameterNode
+    # Create a new NumberedReferenceReadNode node
+    def NumberedReferenceReadNode: (number: Integer, location: Location) -> NumberedReferenceReadNode
+    # Create a new OptionalKeywordParameterNode node
+    def OptionalKeywordParameterNode: (name: Symbol, name_loc: Location, value: Node, location: Location) -> OptionalKeywordParameterNode
+    # Create a new OptionalParameterNode node
+    def OptionalParameterNode: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> OptionalParameterNode
+    # Create a new OrNode node
+    def OrNode: (left: Node, right: Node, operator_loc: Location, location: Location) -> OrNode
+    # Create a new ParametersNode node
+    def ParametersNode: (requireds: Array[Node], optionals: Array[Node], rest: RestParameterNode?, posts: Array[Node], keywords: Array[Node], keyword_rest: Node?, block: BlockParameterNode?, location: Location) -> ParametersNode
+    # Create a new ParenthesesNode node
+    def ParenthesesNode: (body: Node?, opening_loc: Location, closing_loc: Location, location: Location) -> ParenthesesNode
+    # Create a new PinnedExpressionNode node
+    def PinnedExpressionNode: (expression: Node, operator_loc: Location, lparen_loc: Location, rparen_loc: Location, location: Location) -> PinnedExpressionNode
+    # Create a new PinnedVariableNode node
+    def PinnedVariableNode: (variable: Node, operator_loc: Location, location: Location) -> PinnedVariableNode
+    # Create a new PostExecutionNode node
+    def PostExecutionNode: (statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location) -> PostExecutionNode
+    # Create a new PreExecutionNode node
+    def PreExecutionNode: (statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location) -> PreExecutionNode
+    # Create a new ProgramNode node
+    def ProgramNode: (locals: Array[Symbol], statements: StatementsNode, location: Location) -> ProgramNode
+    # Create a new RangeNode node
+    def RangeNode: (left: Node?, right: Node?, operator_loc: Location, flags: Integer, location: Location) -> RangeNode
+    # Create a new RationalNode node
+    def RationalNode: (numeric: Node, location: Location) -> RationalNode
+    # Create a new RedoNode node
+    def RedoNode: (location: Location) -> RedoNode
+    # Create a new RegularExpressionNode node
+    def RegularExpressionNode: (opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, flags: Integer, location: Location) -> RegularExpressionNode
+    # Create a new RequiredKeywordParameterNode node
+    def RequiredKeywordParameterNode: (name: Symbol, name_loc: Location, location: Location) -> RequiredKeywordParameterNode
+    # Create a new RequiredParameterNode node
+    def RequiredParameterNode: (name: Symbol, location: Location) -> RequiredParameterNode
+    # Create a new RescueModifierNode node
+    def RescueModifierNode: (expression: Node, keyword_loc: Location, rescue_expression: Node, location: Location) -> RescueModifierNode
+    # Create a new RescueNode node
+    def RescueNode: (keyword_loc: Location, exceptions: Array[Node], operator_loc: Location?, reference: Node?, statements: StatementsNode?, consequent: RescueNode?, location: Location) -> RescueNode
+    # Create a new RestParameterNode node
+    def RestParameterNode: (name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location) -> RestParameterNode
+    # Create a new RetryNode node
+    def RetryNode: (location: Location) -> RetryNode
+    # Create a new ReturnNode node
+    def ReturnNode: (keyword_loc: Location, arguments: ArgumentsNode?, location: Location) -> ReturnNode
+    # Create a new SelfNode node
+    def SelfNode: (location: Location) -> SelfNode
+    # Create a new SingletonClassNode node
+    def SingletonClassNode: (locals: Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Node, body: Node?, end_keyword_loc: Location, location: Location) -> SingletonClassNode
+    # Create a new SourceEncodingNode node
+    def SourceEncodingNode: (location: Location) -> SourceEncodingNode
+    # Create a new SourceFileNode node
+    def SourceFileNode: (filepath: String, location: Location) -> SourceFileNode
+    # Create a new SourceLineNode node
+    def SourceLineNode: (location: Location) -> SourceLineNode
+    # Create a new SplatNode node
+    def SplatNode: (operator_loc: Location, expression: Node?, location: Location) -> SplatNode
+    # Create a new StatementsNode node
+    def StatementsNode: (body: Array[Node], location: Location) -> StatementsNode
+    # Create a new StringConcatNode node
+    def StringConcatNode: (left: Node, right: Node, location: Location) -> StringConcatNode
+    # Create a new StringNode node
+    def StringNode: (flags: Integer, opening_loc: Location?, content_loc: Location, closing_loc: Location?, unescaped: String, location: Location) -> StringNode
+    # Create a new SuperNode node
+    def SuperNode: (keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, block: Node?, location: Location) -> SuperNode
+    # Create a new SymbolNode node
+    def SymbolNode: (opening_loc: Location?, value_loc: Location?, closing_loc: Location?, unescaped: String, location: Location) -> SymbolNode
+    # Create a new TrueNode node
+    def TrueNode: (location: Location) -> TrueNode
+    # Create a new UndefNode node
+    def UndefNode: (names: Array[Node], keyword_loc: Location, location: Location) -> UndefNode
+    # Create a new UnlessNode node
+    def UnlessNode: (keyword_loc: Location, predicate: Node, statements: StatementsNode?, consequent: ElseNode?, end_keyword_loc: Location?, location: Location) -> UnlessNode
+    # Create a new UntilNode node
+    def UntilNode: (keyword_loc: Location, closing_loc: Location?, predicate: Node, statements: StatementsNode?, flags: Integer, location: Location) -> UntilNode
+    # Create a new WhenNode node
+    def WhenNode: (keyword_loc: Location, conditions: Array[Node], statements: StatementsNode?, location: Location) -> WhenNode
+    # Create a new WhileNode node
+    def WhileNode: (keyword_loc: Location, closing_loc: Location?, predicate: Node, statements: StatementsNode?, flags: Integer, location: Location) -> WhileNode
+    # Create a new XStringNode node
+    def XStringNode: (opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location) -> XStringNode
+    # Create a new YieldNode node
+    def YieldNode: (keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, location: Location) -> YieldNode
+  end
+end