prism 0.23.0 → 0.25.0

data/sig/prism/node.rbs

@@ -0,0 +1,3529 @@
+# This file is generated by the templates/template.rb script and should not be
+# modified manually. See templates/sig/prism/node.rbs.erb
+# if you are looking to modify the template
+
+module Prism
+  class Node
+    attr_reader location: Location
+    attr_reader source: Source
+
+    def start_offset: () -> Integer
+    def end_offset: () -> Integer
+    def slice: () -> String
+    def pretty_print: (untyped q) -> untyped
+    def to_dot: () -> String
+  end
+
+  # Methods implemented by every subclass of Node
+  interface _Node
+    def accept: (_Visitor) -> void
+    def child_nodes: () -> Array[Prism::node?]
+    def deconstruct: () -> Array[Prism::node?]
+    def compact_child_nodes: () -> Array[Prism::node]
+    def comment_targets: () -> Array[Prism::node | Location]
+
+    def inspect: (?untyped) -> String
+    def type: () -> Symbol
+  end
+
+  type node = Node & _Node
+
+
+  # Represents the use of the `alias` keyword to alias a global variable.
+  #
+  #     alias $foo $bar
+  #     ^^^^^^^^^^^^^^^
+  class AliasGlobalVariableNode < Node
+    include _Node
+
+    attr_reader new_name: Prism::node
+    attr_reader old_name: Prism::node
+    attr_reader keyword_loc: Location
+
+    def initialize: (Source source, Prism::node new_name, Prism::node old_name, Location keyword_loc, Location location) -> void
+    def copy: (?new_name: Prism::node, ?old_name: Prism::node, ?keyword_loc: Location, ?location: Location) -> AliasGlobalVariableNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { new_name: Prism::node, old_name: Prism::node, keyword_loc: Location, location: Location }
+    def keyword: () -> String
+    def type: () -> :alias_global_variable_node
+            | ...
+    def self.type: () -> :alias_global_variable_node
+  end
+
+  # Represents the use of the `alias` keyword to alias a method.
+  #
+  #     alias foo bar
+  #     ^^^^^^^^^^^^^
+  class AliasMethodNode < Node
+    include _Node
+
+    attr_reader new_name: Prism::node
+    attr_reader old_name: Prism::node
+    attr_reader keyword_loc: Location
+
+    def initialize: (Source source, Prism::node new_name, Prism::node old_name, Location keyword_loc, Location location) -> void
+    def copy: (?new_name: Prism::node, ?old_name: Prism::node, ?keyword_loc: Location, ?location: Location) -> AliasMethodNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { new_name: Prism::node, old_name: Prism::node, keyword_loc: Location, location: Location }
+    def keyword: () -> String
+    def type: () -> :alias_method_node
+            | ...
+    def self.type: () -> :alias_method_node
+  end
+
+  # Represents an alternation pattern in pattern matching.
+  #
+  #     foo => bar | baz
+  #            ^^^^^^^^^
+  class AlternationPatternNode < Node
+    include _Node
+
+    attr_reader left: Prism::node
+    attr_reader right: Prism::node
+    attr_reader operator_loc: Location
+
+    def initialize: (Source source, Prism::node left, Prism::node right, Location operator_loc, Location location) -> void
+    def copy: (?left: Prism::node, ?right: Prism::node, ?operator_loc: Location, ?location: Location) -> AlternationPatternNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { left: Prism::node, right: Prism::node, operator_loc: Location, location: Location }
+    def operator: () -> String
+    def type: () -> :alternation_pattern_node
+            | ...
+    def self.type: () -> :alternation_pattern_node
+  end
+
+  # Represents the use of the `&&` operator or the `and` keyword.
+  #
+  #     left and right
+  #     ^^^^^^^^^^^^^^
+  class AndNode < Node
+    include _Node
+
+    attr_reader left: Prism::node
+    attr_reader right: Prism::node
+    attr_reader operator_loc: Location
+
+    def initialize: (Source source, Prism::node left, Prism::node right, Location operator_loc, Location location) -> void
+    def copy: (?left: Prism::node, ?right: Prism::node, ?operator_loc: Location, ?location: Location) -> AndNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { left: Prism::node, right: Prism::node, operator_loc: Location, location: Location }
+    def operator: () -> String
+    def type: () -> :and_node
+            | ...
+    def self.type: () -> :and_node
+  end
+
+  # Represents a set of arguments to a method or a keyword.
+  #
+  #     return foo, bar, baz
+  #            ^^^^^^^^^^^^^
+  class ArgumentsNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader arguments: Array[Prism::node]
+
+    def initialize: (Source source, Integer flags, Array[Prism::node] arguments, Location location) -> void
+    def copy: (?flags: Integer, ?arguments: Array[Prism::node], ?location: Location) -> ArgumentsNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, arguments: Array[Prism::node], location: Location }
+    def contains_keyword_splat?: () -> bool
+    def type: () -> :arguments_node
+            | ...
+    def self.type: () -> :arguments_node
+  end
+
+  # Represents an array literal. This can be a regular array using brackets or a special array using % like %w or %i.
+  #
+  #     [1, 2, 3]
+  #     ^^^^^^^^^
+  class ArrayNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader elements: Array[Prism::node]
+    attr_reader opening_loc: Location?
+    attr_reader closing_loc: Location?
+
+    def initialize: (Source source, Integer flags, Array[Prism::node] elements, Location? opening_loc, Location? closing_loc, Location location) -> void
+    def copy: (?flags: Integer, ?elements: Array[Prism::node], ?opening_loc: Location?, ?closing_loc: Location?, ?location: Location) -> ArrayNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, elements: Array[Prism::node], opening_loc: Location?, closing_loc: Location?, location: Location }
+    def contains_splat?: () -> bool
+    def opening: () -> String?
+    def closing: () -> String?
+    def type: () -> :array_node
+            | ...
+    def self.type: () -> :array_node
+  end
+
+  # Represents an array pattern in pattern matching.
+  #
+  #     foo in 1, 2
+  #     ^^^^^^^^^^^
+  #
+  #     foo in [1, 2]
+  #     ^^^^^^^^^^^^^
+  #
+  #     foo in *1
+  #     ^^^^^^^^^
+  #
+  #     foo in Bar[]
+  #     ^^^^^^^^^^^^
+  #
+  #     foo in Bar[1, 2, 3]
+  #     ^^^^^^^^^^^^^^^^^^^
+  class ArrayPatternNode < Node
+    include _Node
+
+    attr_reader constant: Prism::node?
+    attr_reader requireds: Array[Prism::node]
+    attr_reader rest: Prism::node?
+    attr_reader posts: Array[Prism::node]
+    attr_reader opening_loc: Location?
+    attr_reader closing_loc: Location?
+
+    def initialize: (Source source, Prism::node? constant, Array[Prism::node] requireds, Prism::node? rest, Array[Prism::node] posts, Location? opening_loc, Location? closing_loc, Location location) -> void
+    def copy: (?constant: Prism::node?, ?requireds: Array[Prism::node], ?rest: Prism::node?, ?posts: Array[Prism::node], ?opening_loc: Location?, ?closing_loc: Location?, ?location: Location) -> ArrayPatternNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { constant: Prism::node?, requireds: Array[Prism::node], rest: Prism::node?, posts: Array[Prism::node], opening_loc: Location?, closing_loc: Location?, location: Location }
+    def opening: () -> String?
+    def closing: () -> String?
+    def type: () -> :array_pattern_node
+            | ...
+    def self.type: () -> :array_pattern_node
+  end
+
+  # Represents a hash key/value pair.
+  #
+  #     { a => b }
+  #       ^^^^^^
+  class AssocNode < Node
+    include _Node
+
+    attr_reader key: Prism::node
+    attr_reader value: Prism::node
+    attr_reader operator_loc: Location?
+
+    def initialize: (Source source, Prism::node key, Prism::node value, Location? operator_loc, Location location) -> void
+    def copy: (?key: Prism::node, ?value: Prism::node, ?operator_loc: Location?, ?location: Location) -> AssocNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { key: Prism::node, value: Prism::node, operator_loc: Location?, location: Location }
+    def operator: () -> String?
+    def type: () -> :assoc_node
+            | ...
+    def self.type: () -> :assoc_node
+  end
+
+  # Represents a splat in a hash literal.
+  #
+  #     { **foo }
+  #       ^^^^^
+  class AssocSplatNode < Node
+    include _Node
+
+    attr_reader value: Prism::node?
+    attr_reader operator_loc: Location
+
+    def initialize: (Source source, Prism::node? value, Location operator_loc, Location location) -> void
+    def copy: (?value: Prism::node?, ?operator_loc: Location, ?location: Location) -> AssocSplatNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { value: Prism::node?, operator_loc: Location, location: Location }
+    def operator: () -> String
+    def type: () -> :assoc_splat_node
+            | ...
+    def self.type: () -> :assoc_splat_node
+  end
+
+  # Represents reading a reference to a field in the previous match.
+  #
+  #     $'
+  #     ^^
+  class BackReferenceReadNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+
+    def initialize: (Source source, Symbol name, Location location) -> void
+    def copy: (?name: Symbol, ?location: Location) -> BackReferenceReadNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
+    def type: () -> :back_reference_read_node
+            | ...
+    def self.type: () -> :back_reference_read_node
+  end
+
+  # Represents a begin statement.
+  #
+  #     begin
+  #       foo
+  #     end
+  #     ^^^^^
+  class BeginNode < Node
+    include _Node
+
+    attr_reader begin_keyword_loc: Location?
+    attr_reader statements: StatementsNode?
+    attr_reader rescue_clause: RescueNode?
+    attr_reader else_clause: ElseNode?
+    attr_reader ensure_clause: EnsureNode?
+    attr_reader end_keyword_loc: Location?
+
+    def initialize: (Source source, Location? begin_keyword_loc, StatementsNode? statements, RescueNode? rescue_clause, ElseNode? else_clause, EnsureNode? ensure_clause, Location? end_keyword_loc, Location location) -> void
+    def copy: (?begin_keyword_loc: Location?, ?statements: StatementsNode?, ?rescue_clause: RescueNode?, ?else_clause: ElseNode?, ?ensure_clause: EnsureNode?, ?end_keyword_loc: Location?, ?location: Location) -> BeginNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { begin_keyword_loc: Location?, statements: StatementsNode?, rescue_clause: RescueNode?, else_clause: ElseNode?, ensure_clause: EnsureNode?, end_keyword_loc: Location?, location: Location }
+    def begin_keyword: () -> String?
+    def end_keyword: () -> String?
+    def type: () -> :begin_node
+            | ...
+    def self.type: () -> :begin_node
+  end
+
+  # Represents block method arguments.
+  #
+  #     bar(&args)
+  #     ^^^^^^^^^^
+  class BlockArgumentNode < Node
+    include _Node
+
+    attr_reader expression: Prism::node?
+    attr_reader operator_loc: Location
+
+    def initialize: (Source source, Prism::node? expression, Location operator_loc, Location location) -> void
+    def copy: (?expression: Prism::node?, ?operator_loc: Location, ?location: Location) -> BlockArgumentNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { expression: Prism::node?, operator_loc: Location, location: Location }
+    def operator: () -> String
+    def type: () -> :block_argument_node
+            | ...
+    def self.type: () -> :block_argument_node
+  end
+
+  # Represents a block local variable.
+  #
+  #     a { |; b| }
+  #            ^
+  class BlockLocalVariableNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader name: Symbol
+
+    def initialize: (Source source, Integer flags, Symbol name, Location location) -> void
+    def copy: (?flags: Integer, ?name: Symbol, ?location: Location) -> BlockLocalVariableNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol, location: Location }
+    def repeated_parameter?: () -> bool
+    def type: () -> :block_local_variable_node
+            | ...
+    def self.type: () -> :block_local_variable_node
+  end
+
+  # Represents a block of ruby code.
+  #
+  #     [1, 2, 3].each { |i| puts x }
+  #                    ^^^^^^^^^^^^^^
+  class BlockNode < Node
+    include _Node
+
+    attr_reader locals: Array[Symbol]
+    attr_reader parameters: Prism::node?
+    attr_reader body: Prism::node?
+    attr_reader opening_loc: Location
+    attr_reader closing_loc: Location
+
+    def initialize: (Source source, Array[Symbol] locals, Prism::node? parameters, Prism::node? body, Location opening_loc, Location closing_loc, Location location) -> void
+    def copy: (?locals: Array[Symbol], ?parameters: Prism::node?, ?body: Prism::node?, ?opening_loc: Location, ?closing_loc: Location, ?location: Location) -> BlockNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], parameters: Prism::node?, body: Prism::node?, opening_loc: Location, closing_loc: Location, location: Location }
+    def opening: () -> String
+    def closing: () -> String
+    def type: () -> :block_node
+            | ...
+    def self.type: () -> :block_node
+  end
+
+  # Represents a block parameter to a method, block, or lambda definition.
+  #
+  #     def a(&b)
+  #           ^^
+  #     end
+  class BlockParameterNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader name: Symbol?
+    attr_reader name_loc: Location?
+    attr_reader operator_loc: Location
+
+    def initialize: (Source source, Integer flags, Symbol? name, Location? name_loc, Location operator_loc, Location location) -> void
+    def copy: (?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location, ?location: Location) -> BlockParameterNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location }
+    def repeated_parameter?: () -> bool
+    def operator: () -> String
+    def type: () -> :block_parameter_node
+            | ...
+    def self.type: () -> :block_parameter_node
+  end
+
+  # Represents a block's parameters declaration.
+  #
+  #     -> (a, b = 1; local) { }
+  #        ^^^^^^^^^^^^^^^^^
+  #
+  #     foo do |a, b = 1; local|
+  #            ^^^^^^^^^^^^^^^^^
+  #     end
+  class BlockParametersNode < Node
+    include _Node
+
+    attr_reader parameters: ParametersNode?
+    attr_reader locals: Array[BlockLocalVariableNode]
+    attr_reader opening_loc: Location?
+    attr_reader closing_loc: Location?
+
+    def initialize: (Source source, ParametersNode? parameters, Array[BlockLocalVariableNode] locals, Location? opening_loc, Location? closing_loc, Location location) -> void
+    def copy: (?parameters: ParametersNode?, ?locals: Array[BlockLocalVariableNode], ?opening_loc: Location?, ?closing_loc: Location?, ?location: Location) -> BlockParametersNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { parameters: ParametersNode?, locals: Array[BlockLocalVariableNode], opening_loc: Location?, closing_loc: Location?, location: Location }
+    def opening: () -> String?
+    def closing: () -> String?
+    def type: () -> :block_parameters_node
+            | ...
+    def self.type: () -> :block_parameters_node
+  end
+
+  # Represents the use of the `break` keyword.
+  #
+  #     break foo
+  #     ^^^^^^^^^
+  class BreakNode < Node
+    include _Node
+
+    attr_reader arguments: ArgumentsNode?
+    attr_reader keyword_loc: Location
+
+    def initialize: (Source source, ArgumentsNode? arguments, Location keyword_loc, Location location) -> void
+    def copy: (?arguments: ArgumentsNode?, ?keyword_loc: Location, ?location: Location) -> BreakNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { arguments: ArgumentsNode?, keyword_loc: Location, location: Location }
+    def keyword: () -> String
+    def type: () -> :break_node
+            | ...
+    def self.type: () -> :break_node
+  end
+
+  # Represents the use of the `&&=` operator on a call.
+  #
+  #     foo.bar &&= value
+  #     ^^^^^^^^^^^^^^^^^
+  class CallAndWriteNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader receiver: Prism::node?
+    attr_reader call_operator_loc: Location?
+    attr_reader message_loc: Location?
+    attr_reader read_name: Symbol
+    attr_reader write_name: Symbol
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+
+    def initialize: (Source source, Integer flags, Prism::node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Location operator_loc, Prism::node value, Location location) -> void
+    def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> CallAndWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Prism::node, location: Location }
+    def safe_navigation?: () -> bool
+    def variable_call?: () -> bool
+    def attribute_write?: () -> bool
+    def ignore_visibility?: () -> bool
+    def call_operator: () -> String?
+    def message: () -> String?
+    def operator: () -> String
+    def type: () -> :call_and_write_node
+            | ...
+    def self.type: () -> :call_and_write_node
+  end
+
+  # Represents a method call, in all of the various forms that can take.
+  #
+  #     foo
+  #     ^^^
+  #
+  #     foo()
+  #     ^^^^^
+  #
+  #     +foo
+  #     ^^^^
+  #
+  #     foo + bar
+  #     ^^^^^^^^^
+  #
+  #     foo.bar
+  #     ^^^^^^^
+  #
+  #     foo&.bar
+  #     ^^^^^^^^
+  class CallNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader receiver: Prism::node?
+    attr_reader call_operator_loc: Location?
+    attr_reader name: Symbol
+    attr_reader message_loc: Location?
+    attr_reader opening_loc: Location?
+    attr_reader arguments: ArgumentsNode?
+    attr_reader closing_loc: Location?
+    attr_reader block: Prism::node?
+
+    def initialize: (Source source, Integer flags, Prism::node? receiver, Location? call_operator_loc, Symbol name, Location? message_loc, Location? opening_loc, ArgumentsNode? arguments, Location? closing_loc, Prism::node? block, Location location) -> void
+    def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?name: Symbol, ?message_loc: Location?, ?opening_loc: Location?, ?arguments: ArgumentsNode?, ?closing_loc: Location?, ?block: Prism::node?, ?location: Location) -> CallNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, name: Symbol, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: Prism::node?, location: Location }
+    def safe_navigation?: () -> bool
+    def variable_call?: () -> bool
+    def attribute_write?: () -> bool
+    def ignore_visibility?: () -> bool
+    def call_operator: () -> String?
+    def message: () -> String?
+    def opening: () -> String?
+    def closing: () -> String?
+    def type: () -> :call_node
+            | ...
+    def self.type: () -> :call_node
+  end
+
+  # Represents the use of an assignment operator on a call.
+  #
+  #     foo.bar += baz
+  #     ^^^^^^^^^^^^^^
+  class CallOperatorWriteNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader receiver: Prism::node?
+    attr_reader call_operator_loc: Location?
+    attr_reader message_loc: Location?
+    attr_reader read_name: Symbol
+    attr_reader write_name: Symbol
+    attr_reader operator: Symbol
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+
+    def initialize: (Source source, Integer flags, Prism::node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Symbol operator, Location operator_loc, Prism::node value, Location location) -> void
+    def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?operator: Symbol, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> CallOperatorWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Location, value: Prism::node, location: Location }
+    def safe_navigation?: () -> bool
+    def variable_call?: () -> bool
+    def attribute_write?: () -> bool
+    def ignore_visibility?: () -> bool
+    def call_operator: () -> String?
+    def message: () -> String?
+    def type: () -> :call_operator_write_node
+            | ...
+    def self.type: () -> :call_operator_write_node
+  end
+
+  # Represents the use of the `||=` operator on a call.
+  #
+  #     foo.bar ||= value
+  #     ^^^^^^^^^^^^^^^^^
+  class CallOrWriteNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader receiver: Prism::node?
+    attr_reader call_operator_loc: Location?
+    attr_reader message_loc: Location?
+    attr_reader read_name: Symbol
+    attr_reader write_name: Symbol
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+
+    def initialize: (Source source, Integer flags, Prism::node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Location operator_loc, Prism::node value, Location location) -> void
+    def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> CallOrWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Prism::node, location: Location }
+    def safe_navigation?: () -> bool
+    def variable_call?: () -> bool
+    def attribute_write?: () -> bool
+    def ignore_visibility?: () -> bool
+    def call_operator: () -> String?
+    def message: () -> String?
+    def operator: () -> String
+    def type: () -> :call_or_write_node
+            | ...
+    def self.type: () -> :call_or_write_node
+  end
+
+  # Represents assigning to a method call.
+  #
+  #     foo.bar, = 1
+  #     ^^^^^^^
+  #
+  #     begin
+  #     rescue => foo.bar
+  #               ^^^^^^^
+  #     end
+  #
+  #     for foo.bar in baz do end
+  #         ^^^^^^^
+  class CallTargetNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader receiver: Prism::node
+    attr_reader call_operator_loc: Location
+    attr_reader name: Symbol
+    attr_reader message_loc: Location
+
+    def initialize: (Source source, Integer flags, Prism::node receiver, Location call_operator_loc, Symbol name, Location message_loc, Location location) -> void
+    def copy: (?flags: Integer, ?receiver: Prism::node, ?call_operator_loc: Location, ?name: Symbol, ?message_loc: Location, ?location: Location) -> CallTargetNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node, call_operator_loc: Location, name: Symbol, message_loc: Location, location: Location }
+    def safe_navigation?: () -> bool
+    def variable_call?: () -> bool
+    def attribute_write?: () -> bool
+    def ignore_visibility?: () -> bool
+    def call_operator: () -> String
+    def message: () -> String
+    def type: () -> :call_target_node
+            | ...
+    def self.type: () -> :call_target_node
+  end
+
+  # Represents assigning to a local variable in pattern matching.
+  #
+  #     foo => [bar => baz]
+  #            ^^^^^^^^^^^^
+  class CapturePatternNode < Node
+    include _Node
+
+    attr_reader value: Prism::node
+    attr_reader target: Prism::node
+    attr_reader operator_loc: Location
+
+    def initialize: (Source source, Prism::node value, Prism::node target, Location operator_loc, Location location) -> void
+    def copy: (?value: Prism::node, ?target: Prism::node, ?operator_loc: Location, ?location: Location) -> CapturePatternNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { value: Prism::node, target: Prism::node, operator_loc: Location, location: Location }
+    def operator: () -> String
+    def type: () -> :capture_pattern_node
+            | ...
+    def self.type: () -> :capture_pattern_node
+  end
+
+  # Represents the use of a case statement for pattern matching.
+  #
+  #     case true
+  #     in false
+  #     end
+  #     ^^^^^^^^^
+  class CaseMatchNode < Node
+    include _Node
+
+    attr_reader predicate: Prism::node?
+    attr_reader conditions: Array[Prism::node]
+    attr_reader consequent: ElseNode?
+    attr_reader case_keyword_loc: Location
+    attr_reader end_keyword_loc: Location
+
+    def initialize: (Source source, Prism::node? predicate, Array[Prism::node] conditions, ElseNode? consequent, Location case_keyword_loc, Location end_keyword_loc, Location location) -> void
+    def copy: (?predicate: Prism::node?, ?conditions: Array[Prism::node], ?consequent: ElseNode?, ?case_keyword_loc: Location, ?end_keyword_loc: Location, ?location: Location) -> CaseMatchNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { predicate: Prism::node?, conditions: Array[Prism::node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location }
+    def case_keyword: () -> String
+    def end_keyword: () -> String
+    def type: () -> :case_match_node
+            | ...
+    def self.type: () -> :case_match_node
+  end
+
+  # Represents the use of a case statement.
+  #
+  #     case true
+  #     when false
+  #     end
+  #     ^^^^^^^^^^
+  class CaseNode < Node
+    include _Node
+
+    attr_reader predicate: Prism::node?
+    attr_reader conditions: Array[Prism::node]
+    attr_reader consequent: ElseNode?
+    attr_reader case_keyword_loc: Location
+    attr_reader end_keyword_loc: Location
+
+    def initialize: (Source source, Prism::node? predicate, Array[Prism::node] conditions, ElseNode? consequent, Location case_keyword_loc, Location end_keyword_loc, Location location) -> void
+    def copy: (?predicate: Prism::node?, ?conditions: Array[Prism::node], ?consequent: ElseNode?, ?case_keyword_loc: Location, ?end_keyword_loc: Location, ?location: Location) -> CaseNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { predicate: Prism::node?, conditions: Array[Prism::node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location }
+    def case_keyword: () -> String
+    def end_keyword: () -> String
+    def type: () -> :case_node
+            | ...
+    def self.type: () -> :case_node
+  end
+
+  # Represents a class declaration involving the `class` keyword.
+  #
+  #     class Foo end
+  #     ^^^^^^^^^^^^^
+  class ClassNode < Node
+    include _Node
+
+    attr_reader locals: Array[Symbol]
+    attr_reader class_keyword_loc: Location
+    attr_reader constant_path: Prism::node
+    attr_reader inheritance_operator_loc: Location?
+    attr_reader superclass: Prism::node?
+    attr_reader body: Prism::node?
+    attr_reader end_keyword_loc: Location
+    attr_reader name: Symbol
+
+    def initialize: (Source source, Array[Symbol] locals, Location class_keyword_loc, Prism::node constant_path, Location? inheritance_operator_loc, Prism::node? superclass, Prism::node? body, Location end_keyword_loc, Symbol name, Location location) -> void
+    def copy: (?locals: Array[Symbol], ?class_keyword_loc: Location, ?constant_path: Prism::node, ?inheritance_operator_loc: Location?, ?superclass: Prism::node?, ?body: Prism::node?, ?end_keyword_loc: Location, ?name: Symbol, ?location: Location) -> ClassNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], class_keyword_loc: Location, constant_path: Prism::node, inheritance_operator_loc: Location?, superclass: Prism::node?, body: Prism::node?, end_keyword_loc: Location, name: Symbol, location: Location }
+    def class_keyword: () -> String
+    def inheritance_operator: () -> String?
+    def end_keyword: () -> String
+    def type: () -> :class_node
+            | ...
+    def self.type: () -> :class_node
+  end
+
+  # Represents the use of the `&&=` operator for assignment to a class variable.
+  #
+  #     @@target &&= value
+  #     ^^^^^^^^^^^^^^^^^^
+  class ClassVariableAndWriteNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+
+    def initialize: (Source source, Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
+    def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> ClassVariableAndWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, location: Location }
+    def operator: () -> String
+    def type: () -> :class_variable_and_write_node
+            | ...
+    def self.type: () -> :class_variable_and_write_node
+  end
+
+  # Represents assigning to a class variable using an operator that isn't `=`.
+  #
+  #     @@target += value
+  #     ^^^^^^^^^^^^^^^^^
+  class ClassVariableOperatorWriteNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+    attr_reader operator: Symbol
+
+    def initialize: (Source source, Symbol name, Location name_loc, Location operator_loc, Prism::node value, Symbol operator, Location location) -> void
+    def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?operator: Symbol, ?location: Location) -> ClassVariableOperatorWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, operator: Symbol, location: Location }
+    def type: () -> :class_variable_operator_write_node
+            | ...
+    def self.type: () -> :class_variable_operator_write_node
+  end
+
+  # Represents the use of the `||=` operator for assignment to a class variable.
+  #
+  #     @@target ||= value
+  #     ^^^^^^^^^^^^^^^^^^
+  class ClassVariableOrWriteNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+
+    def initialize: (Source source, Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
+    def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> ClassVariableOrWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, location: Location }
+    def operator: () -> String
+    def type: () -> :class_variable_or_write_node
+            | ...
+    def self.type: () -> :class_variable_or_write_node
+  end
+
+  # Represents referencing a class variable.
+  #
+  #     @@foo
+  #     ^^^^^
+  class ClassVariableReadNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+
+    def initialize: (Source source, Symbol name, Location location) -> void
+    def copy: (?name: Symbol, ?location: Location) -> ClassVariableReadNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
+    def type: () -> :class_variable_read_node
+            | ...
+    def self.type: () -> :class_variable_read_node
+  end
+
+  # Represents writing to a class variable in a context that doesn't have an explicit value.
+  #
+  #     @@foo, @@bar = baz
+  #     ^^^^^  ^^^^^
+  class ClassVariableTargetNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+
+    def initialize: (Source source, Symbol name, Location location) -> void
+    def copy: (?name: Symbol, ?location: Location) -> ClassVariableTargetNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
+    def type: () -> :class_variable_target_node
+            | ...
+    def self.type: () -> :class_variable_target_node
+  end
+
+  # Represents writing to a class variable.
+  #
+  #     @@foo = 1
+  #     ^^^^^^^^^
+  class ClassVariableWriteNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader value: Prism::node
+    attr_reader operator_loc: Location
+
+    def initialize: (Source source, Symbol name, Location name_loc, Prism::node value, Location operator_loc, Location location) -> void
+    def copy: (?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location, ?location: Location) -> ClassVariableWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location, location: Location }
+    def operator: () -> String
+    def type: () -> :class_variable_write_node
+            | ...
+    def self.type: () -> :class_variable_write_node
+  end
+
+  # Represents the use of the `&&=` operator for assignment to a constant.
+  #
+  #     Target &&= value
+  #     ^^^^^^^^^^^^^^^^
+  class ConstantAndWriteNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+
+    def initialize: (Source source, Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
+    def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> ConstantAndWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, location: Location }
+    def operator: () -> String
+    def type: () -> :constant_and_write_node
+            | ...
+    def self.type: () -> :constant_and_write_node
+  end
+
+  # Represents assigning to a constant using an operator that isn't `=`.
+  #
+  #     Target += value
+  #     ^^^^^^^^^^^^^^^
+  class ConstantOperatorWriteNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+    attr_reader operator: Symbol
+
+    def initialize: (Source source, Symbol name, Location name_loc, Location operator_loc, Prism::node value, Symbol operator, Location location) -> void
+    def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?operator: Symbol, ?location: Location) -> ConstantOperatorWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, operator: Symbol, location: Location }
+    def type: () -> :constant_operator_write_node
+            | ...
+    def self.type: () -> :constant_operator_write_node
+  end
+
+  # Represents the use of the `||=` operator for assignment to a constant.
+  #
+  #     Target ||= value
+  #     ^^^^^^^^^^^^^^^^
+  class ConstantOrWriteNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+
+    def initialize: (Source source, Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
+    def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> ConstantOrWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, location: Location }
+    def operator: () -> String
+    def type: () -> :constant_or_write_node
+            | ...
+    def self.type: () -> :constant_or_write_node
+  end
+
+  # Represents the use of the `&&=` operator for assignment to a constant path.
+  #
+  #     Parent::Child &&= value
+  #     ^^^^^^^^^^^^^^^^^^^^^^^
+  class ConstantPathAndWriteNode < Node
+    include _Node
+
+    attr_reader target: ConstantPathNode
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+
+    def initialize: (Source source, ConstantPathNode target, Location operator_loc, Prism::node value, Location location) -> void
+    def copy: (?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> ConstantPathAndWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, operator_loc: Location, value: Prism::node, location: Location }
+    def operator: () -> String
+    def type: () -> :constant_path_and_write_node
+            | ...
+    def self.type: () -> :constant_path_and_write_node
+  end
+
+  # Represents accessing a constant through a path of `::` operators.
+  #
+  #     Foo::Bar
+  #     ^^^^^^^^
+  class ConstantPathNode < Node
+    include _Node
+
+    attr_reader parent: Prism::node?
+    attr_reader child: ConstantReadNode | MissingNode
+    attr_reader delimiter_loc: Location
+
+    def initialize: (Source source, Prism::node? parent, ConstantReadNode | MissingNode child, Location delimiter_loc, Location location) -> void
+    def copy: (?parent: Prism::node?, ?child: ConstantReadNode | MissingNode, ?delimiter_loc: Location, ?location: Location) -> ConstantPathNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { parent: Prism::node?, child: ConstantReadNode | MissingNode, delimiter_loc: Location, location: Location }
+    def delimiter: () -> String
+    def type: () -> :constant_path_node
+            | ...
+    def self.type: () -> :constant_path_node
+  end
+
+  # Represents assigning to a constant path using an operator that isn't `=`.
+  #
+  #     Parent::Child += value
+  #     ^^^^^^^^^^^^^^^^^^^^^^
+  class ConstantPathOperatorWriteNode < Node
+    include _Node
+
+    attr_reader target: ConstantPathNode
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+    attr_reader operator: Symbol
+
+    def initialize: (Source source, ConstantPathNode target, Location operator_loc, Prism::node value, Symbol operator, Location location) -> void
+    def copy: (?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node, ?operator: Symbol, ?location: Location) -> ConstantPathOperatorWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, operator_loc: Location, value: Prism::node, operator: Symbol, location: Location }
+    def type: () -> :constant_path_operator_write_node
+            | ...
+    def self.type: () -> :constant_path_operator_write_node
+  end
+
+  # Represents the use of the `||=` operator for assignment to a constant path.
+  #
+  #     Parent::Child ||= value
+  #     ^^^^^^^^^^^^^^^^^^^^^^^
+  class ConstantPathOrWriteNode < Node
+    include _Node
+
+    attr_reader target: ConstantPathNode
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+
+    def initialize: (Source source, ConstantPathNode target, Location operator_loc, Prism::node value, Location location) -> void
+    def copy: (?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> ConstantPathOrWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, operator_loc: Location, value: Prism::node, location: Location }
+    def operator: () -> String
+    def type: () -> :constant_path_or_write_node
+            | ...
+    def self.type: () -> :constant_path_or_write_node
+  end
+
+  # Represents writing to a constant path in a context that doesn't have an explicit value.
+  #
+  #     Foo::Foo, Bar::Bar = baz
+  #     ^^^^^^^^  ^^^^^^^^
+  class ConstantPathTargetNode < Node
+    include _Node
+
+    attr_reader parent: Prism::node?
+    attr_reader child: ConstantReadNode | MissingNode
+    attr_reader delimiter_loc: Location
+
+    def initialize: (Source source, Prism::node? parent, ConstantReadNode | MissingNode child, Location delimiter_loc, Location location) -> void
+    def copy: (?parent: Prism::node?, ?child: ConstantReadNode | MissingNode, ?delimiter_loc: Location, ?location: Location) -> ConstantPathTargetNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { parent: Prism::node?, child: ConstantReadNode | MissingNode, delimiter_loc: Location, location: Location }
+    def delimiter: () -> String
+    def type: () -> :constant_path_target_node
+            | ...
+    def self.type: () -> :constant_path_target_node
+  end
+
+  # Represents writing to a constant path.
+  #
+  #     ::Foo = 1
+  #     ^^^^^^^^^
+  #
+  #     Foo::Bar = 1
+  #     ^^^^^^^^^^^^
+  #
+  #     ::Foo::Bar = 1
+  #     ^^^^^^^^^^^^^^
+  class ConstantPathWriteNode < Node
+    include _Node
+
+    attr_reader target: ConstantPathNode
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+
+    def initialize: (Source source, ConstantPathNode target, Location operator_loc, Prism::node value, Location location) -> void
+    def copy: (?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> ConstantPathWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, operator_loc: Location, value: Prism::node, location: Location }
+    def operator: () -> String
+    def type: () -> :constant_path_write_node
+            | ...
+    def self.type: () -> :constant_path_write_node
+  end
+
+  # Represents referencing a constant.
+  #
+  #     Foo
+  #     ^^^
+  class ConstantReadNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+
+    def initialize: (Source source, Symbol name, Location location) -> void
+    def copy: (?name: Symbol, ?location: Location) -> ConstantReadNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
+    def type: () -> :constant_read_node
+            | ...
+    def self.type: () -> :constant_read_node
+  end
+
+  # Represents writing to a constant in a context that doesn't have an explicit value.
+  #
+  #     Foo, Bar = baz
+  #     ^^^  ^^^
+  class ConstantTargetNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+
+    def initialize: (Source source, Symbol name, Location location) -> void
+    def copy: (?name: Symbol, ?location: Location) -> ConstantTargetNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
+    def type: () -> :constant_target_node
+            | ...
+    def self.type: () -> :constant_target_node
+  end
+
+  # Represents writing to a constant.
+  #
+  #     Foo = 1
+  #     ^^^^^^^
+  class ConstantWriteNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader value: Prism::node
+    attr_reader operator_loc: Location
+
+    def initialize: (Source source, Symbol name, Location name_loc, Prism::node value, Location operator_loc, Location location) -> void
+    def copy: (?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location, ?location: Location) -> ConstantWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location, location: Location }
+    def operator: () -> String
+    def type: () -> :constant_write_node
+            | ...
+    def self.type: () -> :constant_write_node
+  end
+
+  # Represents a method definition.
+  #
+  #     def method
+  #     end
+  #     ^^^^^^^^^^
+  class DefNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader receiver: Prism::node?
+    attr_reader parameters: ParametersNode?
+    attr_reader body: Prism::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: (Source source, Symbol name, Location name_loc, Prism::node? receiver, ParametersNode? parameters, Prism::node? body, Array[Symbol] locals, Location def_keyword_loc, Location? operator_loc, Location? lparen_loc, Location? rparen_loc, Location? equal_loc, Location? end_keyword_loc, Location location) -> void
+    def copy: (?name: Symbol, ?name_loc: Location, ?receiver: Prism::node?, ?parameters: ParametersNode?, ?body: Prism::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
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, receiver: Prism::node?, parameters: ParametersNode?, body: Prism::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 }
+    def def_keyword: () -> String
+    def operator: () -> String?
+    def lparen: () -> String?
+    def rparen: () -> String?
+    def equal: () -> String?
+    def end_keyword: () -> String?
+    def type: () -> :def_node
+            | ...
+    def self.type: () -> :def_node
+  end
+
+  # Represents the use of the `defined?` keyword.
+  #
+  #     defined?(a)
+  #     ^^^^^^^^^^^
+  class DefinedNode < Node
+    include _Node
+
+    attr_reader lparen_loc: Location?
+    attr_reader value: Prism::node
+    attr_reader rparen_loc: Location?
+    attr_reader keyword_loc: Location
+
+    def initialize: (Source source, Location? lparen_loc, Prism::node value, Location? rparen_loc, Location keyword_loc, Location location) -> void
+    def copy: (?lparen_loc: Location?, ?value: Prism::node, ?rparen_loc: Location?, ?keyword_loc: Location, ?location: Location) -> DefinedNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { lparen_loc: Location?, value: Prism::node, rparen_loc: Location?, keyword_loc: Location, location: Location }
+    def lparen: () -> String?
+    def rparen: () -> String?
+    def keyword: () -> String
+    def type: () -> :defined_node
+            | ...
+    def self.type: () -> :defined_node
+  end
+
+  # Represents an `else` clause in a `case`, `if`, or `unless` statement.
+  #
+  #     if a then b else c end
+  #                 ^^^^^^^^^^
+  class ElseNode < Node
+    include _Node
+
+    attr_reader else_keyword_loc: Location
+    attr_reader statements: StatementsNode?
+    attr_reader end_keyword_loc: Location?
+
+    def initialize: (Source source, Location else_keyword_loc, StatementsNode? statements, Location? end_keyword_loc, Location location) -> void
+    def copy: (?else_keyword_loc: Location, ?statements: StatementsNode?, ?end_keyword_loc: Location?, ?location: Location) -> ElseNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { else_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location?, location: Location }
+    def else_keyword: () -> String
+    def end_keyword: () -> String?
+    def type: () -> :else_node
+            | ...
+    def self.type: () -> :else_node
+  end
+
+  # Represents an interpolated set of statements.
+  #
+  #     "foo #{bar}"
+  #          ^^^^^^
+  class EmbeddedStatementsNode < Node
+    include _Node
+
+    attr_reader opening_loc: Location
+    attr_reader statements: StatementsNode?
+    attr_reader closing_loc: Location
+
+    def initialize: (Source source, Location opening_loc, StatementsNode? statements, Location closing_loc, Location location) -> void
+    def copy: (?opening_loc: Location, ?statements: StatementsNode?, ?closing_loc: Location, ?location: Location) -> EmbeddedStatementsNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { opening_loc: Location, statements: StatementsNode?, closing_loc: Location, location: Location }
+    def opening: () -> String
+    def closing: () -> String
+    def type: () -> :embedded_statements_node
+            | ...
+    def self.type: () -> :embedded_statements_node
+  end
+
+  # Represents an interpolated variable.
+  #
+  #     "foo #@bar"
+  #          ^^^^^
+  class EmbeddedVariableNode < Node
+    include _Node
+
+    attr_reader operator_loc: Location
+    attr_reader variable: Prism::node
+
+    def initialize: (Source source, Location operator_loc, Prism::node variable, Location location) -> void
+    def copy: (?operator_loc: Location, ?variable: Prism::node, ?location: Location) -> EmbeddedVariableNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { operator_loc: Location, variable: Prism::node, location: Location }
+    def operator: () -> String
+    def type: () -> :embedded_variable_node
+            | ...
+    def self.type: () -> :embedded_variable_node
+  end
+
+  # Represents an `ensure` clause in a `begin` statement.
+  #
+  #     begin
+  #       foo
+  #     ensure
+  #     ^^^^^^
+  #       bar
+  #     end
+  class EnsureNode < Node
+    include _Node
+
+    attr_reader ensure_keyword_loc: Location
+    attr_reader statements: StatementsNode?
+    attr_reader end_keyword_loc: Location
+
+    def initialize: (Source source, Location ensure_keyword_loc, StatementsNode? statements, Location end_keyword_loc, Location location) -> void
+    def copy: (?ensure_keyword_loc: Location, ?statements: StatementsNode?, ?end_keyword_loc: Location, ?location: Location) -> EnsureNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { ensure_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location, location: Location }
+    def ensure_keyword: () -> String
+    def end_keyword: () -> String
+    def type: () -> :ensure_node
+            | ...
+    def self.type: () -> :ensure_node
+  end
+
+  # Represents the use of the literal `false` keyword.
+  #
+  #     false
+  #     ^^^^^
+  class FalseNode < Node
+    include _Node
+
+
+    def initialize: (Source source, Location location) -> void
+    def copy: (?location: Location) -> FalseNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+    def type: () -> :false_node
+            | ...
+    def self.type: () -> :false_node
+  end
+
+  # Represents a find pattern in pattern matching.
+  #
+  #     foo in *bar, baz, *qux
+  #            ^^^^^^^^^^^^^^^
+  #
+  #     foo in [*bar, baz, *qux]
+  #            ^^^^^^^^^^^^^^^^^
+  #
+  #     foo in Foo(*bar, baz, *qux)
+  #            ^^^^^^^^^^^^^^^^^^^^
+  class FindPatternNode < Node
+    include _Node
+
+    attr_reader constant: Prism::node?
+    attr_reader left: Prism::node
+    attr_reader requireds: Array[Prism::node]
+    attr_reader right: Prism::node
+    attr_reader opening_loc: Location?
+    attr_reader closing_loc: Location?
+
+    def initialize: (Source source, Prism::node? constant, Prism::node left, Array[Prism::node] requireds, Prism::node right, Location? opening_loc, Location? closing_loc, Location location) -> void
+    def copy: (?constant: Prism::node?, ?left: Prism::node, ?requireds: Array[Prism::node], ?right: Prism::node, ?opening_loc: Location?, ?closing_loc: Location?, ?location: Location) -> FindPatternNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { constant: Prism::node?, left: Prism::node, requireds: Array[Prism::node], right: Prism::node, opening_loc: Location?, closing_loc: Location?, location: Location }
+    def opening: () -> String?
+    def closing: () -> String?
+    def type: () -> :find_pattern_node
+            | ...
+    def self.type: () -> :find_pattern_node
+  end
+
+  # Represents the use of the `..` or `...` operators to create flip flops.
+  #
+  #     baz if foo .. bar
+  #            ^^^^^^^^^^
+  class FlipFlopNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader left: Prism::node?
+    attr_reader right: Prism::node?
+    attr_reader operator_loc: Location
+
+    def initialize: (Source source, Integer flags, Prism::node? left, Prism::node? right, Location operator_loc, Location location) -> void
+    def copy: (?flags: Integer, ?left: Prism::node?, ?right: Prism::node?, ?operator_loc: Location, ?location: Location) -> FlipFlopNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, left: Prism::node?, right: Prism::node?, operator_loc: Location, location: Location }
+    def exclude_end?: () -> bool
+    def operator: () -> String
+    def type: () -> :flip_flop_node
+            | ...
+    def self.type: () -> :flip_flop_node
+  end
+
+  # Represents a floating point number literal.
+  #
+  #     1.0
+  #     ^^^
+  class FloatNode < Node
+    include _Node
+
+    attr_reader value: Float
+
+    def initialize: (Source source, Float value, Location location) -> void
+    def copy: (?value: Float, ?location: Location) -> FloatNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { value: Float, location: Location }
+    def type: () -> :float_node
+            | ...
+    def self.type: () -> :float_node
+  end
+
+  # Represents the use of the `for` keyword.
+  #
+  #     for i in a end
+  #     ^^^^^^^^^^^^^^
+  class ForNode < Node
+    include _Node
+
+    attr_reader index: Prism::node
+    attr_reader collection: Prism::node
+    attr_reader statements: StatementsNode?
+    attr_reader for_keyword_loc: Location
+    attr_reader in_keyword_loc: Location
+    attr_reader do_keyword_loc: Location?
+    attr_reader end_keyword_loc: Location
+
+    def initialize: (Source source, Prism::node index, Prism::node collection, StatementsNode? statements, Location for_keyword_loc, Location in_keyword_loc, Location? do_keyword_loc, Location end_keyword_loc, Location location) -> void
+    def copy: (?index: Prism::node, ?collection: Prism::node, ?statements: StatementsNode?, ?for_keyword_loc: Location, ?in_keyword_loc: Location, ?do_keyword_loc: Location?, ?end_keyword_loc: Location, ?location: Location) -> ForNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { index: Prism::node, collection: Prism::node, statements: StatementsNode?, for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: Location?, end_keyword_loc: Location, location: Location }
+    def for_keyword: () -> String
+    def in_keyword: () -> String
+    def do_keyword: () -> String?
+    def end_keyword: () -> String
+    def type: () -> :for_node
+            | ...
+    def self.type: () -> :for_node
+  end
+
+  # Represents forwarding all arguments to this method to another method.
+  #
+  #     def foo(...)
+  #       bar(...)
+  #           ^^^
+  #     end
+  class ForwardingArgumentsNode < Node
+    include _Node
+
+
+    def initialize: (Source source, Location location) -> void
+    def copy: (?location: Location) -> ForwardingArgumentsNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+    def type: () -> :forwarding_arguments_node
+            | ...
+    def self.type: () -> :forwarding_arguments_node
+  end
+
+  # Represents the use of the forwarding parameter in a method, block, or lambda declaration.
+  #
+  #     def foo(...)
+  #             ^^^
+  #     end
+  class ForwardingParameterNode < Node
+    include _Node
+
+
+    def initialize: (Source source, Location location) -> void
+    def copy: (?location: Location) -> ForwardingParameterNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+    def type: () -> :forwarding_parameter_node
+            | ...
+    def self.type: () -> :forwarding_parameter_node
+  end
+
+  # Represents the use of the `super` keyword without parentheses or arguments.
+  #
+  #     super
+  #     ^^^^^
+  class ForwardingSuperNode < Node
+    include _Node
+
+    attr_reader block: BlockNode?
+
+    def initialize: (Source source, BlockNode? block, Location location) -> void
+    def copy: (?block: BlockNode?, ?location: Location) -> ForwardingSuperNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { block: BlockNode?, location: Location }
+    def type: () -> :forwarding_super_node
+            | ...
+    def self.type: () -> :forwarding_super_node
+  end
+
+  # Represents the use of the `&&=` operator for assignment to a global variable.
+  #
+  #     $target &&= value
+  #     ^^^^^^^^^^^^^^^^^
+  class GlobalVariableAndWriteNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+
+    def initialize: (Source source, Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
+    def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> GlobalVariableAndWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, location: Location }
+    def operator: () -> String
+    def type: () -> :global_variable_and_write_node
+            | ...
+    def self.type: () -> :global_variable_and_write_node
+  end
+
+  # Represents assigning to a global variable using an operator that isn't `=`.
+  #
+  #     $target += value
+  #     ^^^^^^^^^^^^^^^^
+  class GlobalVariableOperatorWriteNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+    attr_reader operator: Symbol
+
+    def initialize: (Source source, Symbol name, Location name_loc, Location operator_loc, Prism::node value, Symbol operator, Location location) -> void
+    def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?operator: Symbol, ?location: Location) -> GlobalVariableOperatorWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, operator: Symbol, location: Location }
+    def type: () -> :global_variable_operator_write_node
+            | ...
+    def self.type: () -> :global_variable_operator_write_node
+  end
+
+  # Represents the use of the `||=` operator for assignment to a global variable.
+  #
+  #     $target ||= value
+  #     ^^^^^^^^^^^^^^^^^
+  class GlobalVariableOrWriteNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+
+    def initialize: (Source source, Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
+    def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> GlobalVariableOrWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, location: Location }
+    def operator: () -> String
+    def type: () -> :global_variable_or_write_node
+            | ...
+    def self.type: () -> :global_variable_or_write_node
+  end
+
+  # Represents referencing a global variable.
+  #
+  #     $foo
+  #     ^^^^
+  class GlobalVariableReadNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+
+    def initialize: (Source source, Symbol name, Location location) -> void
+    def copy: (?name: Symbol, ?location: Location) -> GlobalVariableReadNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
+    def type: () -> :global_variable_read_node
+            | ...
+    def self.type: () -> :global_variable_read_node
+  end
+
+  # Represents writing to a global variable in a context that doesn't have an explicit value.
+  #
+  #     $foo, $bar = baz
+  #     ^^^^  ^^^^
+  class GlobalVariableTargetNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+
+    def initialize: (Source source, Symbol name, Location location) -> void
+    def copy: (?name: Symbol, ?location: Location) -> GlobalVariableTargetNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
+    def type: () -> :global_variable_target_node
+            | ...
+    def self.type: () -> :global_variable_target_node
+  end
+
+  # Represents writing to a global variable.
+  #
+  #     $foo = 1
+  #     ^^^^^^^^
+  class GlobalVariableWriteNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader value: Prism::node
+    attr_reader operator_loc: Location
+
+    def initialize: (Source source, Symbol name, Location name_loc, Prism::node value, Location operator_loc, Location location) -> void
+    def copy: (?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location, ?location: Location) -> GlobalVariableWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location, location: Location }
+    def operator: () -> String
+    def type: () -> :global_variable_write_node
+            | ...
+    def self.type: () -> :global_variable_write_node
+  end
+
+  # Represents a hash literal.
+  #
+  #     { a => b }
+  #     ^^^^^^^^^^
+  class HashNode < Node
+    include _Node
+
+    attr_reader opening_loc: Location
+    attr_reader elements: Array[AssocNode | AssocSplatNode]
+    attr_reader closing_loc: Location
+
+    def initialize: (Source source, Location opening_loc, Array[AssocNode | AssocSplatNode] elements, Location closing_loc, Location location) -> void
+    def copy: (?opening_loc: Location, ?elements: Array[AssocNode | AssocSplatNode], ?closing_loc: Location, ?location: Location) -> HashNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { opening_loc: Location, elements: Array[AssocNode | AssocSplatNode], closing_loc: Location, location: Location }
+    def opening: () -> String
+    def closing: () -> String
+    def type: () -> :hash_node
+            | ...
+    def self.type: () -> :hash_node
+  end
+
+  # Represents a hash pattern in pattern matching.
+  #
+  #     foo => { a: 1, b: 2 }
+  #            ^^^^^^^^^^^^^^
+  #
+  #     foo => { a: 1, b: 2, **c }
+  #            ^^^^^^^^^^^^^^^^^^^
+  class HashPatternNode < Node
+    include _Node
+
+    attr_reader constant: Prism::node?
+    attr_reader elements: Array[AssocNode]
+    attr_reader rest: AssocSplatNode | NoKeywordsParameterNode | nil
+    attr_reader opening_loc: Location?
+    attr_reader closing_loc: Location?
+
+    def initialize: (Source source, Prism::node? constant, Array[AssocNode] elements, AssocSplatNode | NoKeywordsParameterNode | nil rest, Location? opening_loc, Location? closing_loc, Location location) -> void
+    def copy: (?constant: Prism::node?, ?elements: Array[AssocNode], ?rest: AssocSplatNode | NoKeywordsParameterNode | nil, ?opening_loc: Location?, ?closing_loc: Location?, ?location: Location) -> HashPatternNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { constant: Prism::node?, elements: Array[AssocNode], rest: AssocSplatNode | NoKeywordsParameterNode | nil, opening_loc: Location?, closing_loc: Location?, location: Location }
+    def opening: () -> String?
+    def closing: () -> String?
+    def type: () -> :hash_pattern_node
+            | ...
+    def self.type: () -> :hash_pattern_node
+  end
+
+  # Represents the use of the `if` keyword, either in the block form or the modifier form.
+  #
+  #     bar if foo
+  #     ^^^^^^^^^^
+  #
+  #     if foo then bar end
+  #     ^^^^^^^^^^^^^^^^^^^
+  class IfNode < Node
+    include _Node
+
+    attr_reader if_keyword_loc: Location?
+    attr_reader predicate: Prism::node
+    attr_reader then_keyword_loc: Location?
+    attr_reader statements: StatementsNode?
+    attr_reader consequent: Prism::node?
+    attr_reader end_keyword_loc: Location?
+
+    def initialize: (Source source, Location? if_keyword_loc, Prism::node predicate, Location? then_keyword_loc, StatementsNode? statements, Prism::node? consequent, Location? end_keyword_loc, Location location) -> void
+    def copy: (?if_keyword_loc: Location?, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?consequent: Prism::node?, ?end_keyword_loc: Location?, ?location: Location) -> IfNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { if_keyword_loc: Location?, predicate: Prism::node, then_keyword_loc: Location?, statements: StatementsNode?, consequent: Prism::node?, end_keyword_loc: Location?, location: Location }
+    def if_keyword: () -> String?
+    def then_keyword: () -> String?
+    def end_keyword: () -> String?
+    def type: () -> :if_node
+            | ...
+    def self.type: () -> :if_node
+  end
+
+  # Represents an imaginary number literal.
+  #
+  #     1.0i
+  #     ^^^^
+  class ImaginaryNode < Node
+    include _Node
+
+    attr_reader numeric: FloatNode | IntegerNode | RationalNode
+
+    def initialize: (Source source, FloatNode | IntegerNode | RationalNode numeric, Location location) -> void
+    def copy: (?numeric: FloatNode | IntegerNode | RationalNode, ?location: Location) -> ImaginaryNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { numeric: FloatNode | IntegerNode | RationalNode, location: Location }
+    def type: () -> :imaginary_node
+            | ...
+    def self.type: () -> :imaginary_node
+  end
+
+  # Represents a node that is implicitly being added to the tree but doesn't correspond directly to a node in the source.
+  #
+  #     { foo: }
+  #       ^^^^
+  #
+  #     { Foo: }
+  #       ^^^^
+  #
+  #     foo in { bar: }
+  #              ^^^^
+  class ImplicitNode < Node
+    include _Node
+
+    attr_reader value: Prism::node
+
+    def initialize: (Source source, Prism::node value, Location location) -> void
+    def copy: (?value: Prism::node, ?location: Location) -> ImplicitNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { value: Prism::node, location: Location }
+    def type: () -> :implicit_node
+            | ...
+    def self.type: () -> :implicit_node
+  end
+
+  # Represents using a trailing comma to indicate an implicit rest parameter.
+  #
+  #     foo { |bar,| }
+  #               ^
+  #
+  #     foo in [bar,]
+  #                ^
+  #
+  #     for foo, in bar do end
+  #            ^
+  #
+  #     foo, = bar
+  #        ^
+  class ImplicitRestNode < Node
+    include _Node
+
+
+    def initialize: (Source source, Location location) -> void
+    def copy: (?location: Location) -> ImplicitRestNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+    def type: () -> :implicit_rest_node
+            | ...
+    def self.type: () -> :implicit_rest_node
+  end
+
+  # Represents the use of the `in` keyword in a case statement.
+  #
+  #     case a; in b then c end
+  #             ^^^^^^^^^^^
+  class InNode < Node
+    include _Node
+
+    attr_reader pattern: Prism::node
+    attr_reader statements: StatementsNode?
+    attr_reader in_loc: Location
+    attr_reader then_loc: Location?
+
+    def initialize: (Source source, Prism::node pattern, StatementsNode? statements, Location in_loc, Location? then_loc, Location location) -> void
+    def copy: (?pattern: Prism::node, ?statements: StatementsNode?, ?in_loc: Location, ?then_loc: Location?, ?location: Location) -> InNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { pattern: Prism::node, statements: StatementsNode?, in_loc: Location, then_loc: Location?, location: Location }
+    def in: () -> String
+    def then: () -> String?
+    def type: () -> :in_node
+            | ...
+    def self.type: () -> :in_node
+  end
+
+  # Represents the use of the `&&=` operator on a call to the `[]` method.
+  #
+  #     foo.bar[baz] &&= value
+  #     ^^^^^^^^^^^^^^^^^^^^^^
+  class IndexAndWriteNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader receiver: Prism::node?
+    attr_reader call_operator_loc: Location?
+    attr_reader opening_loc: Location
+    attr_reader arguments: ArgumentsNode?
+    attr_reader closing_loc: Location
+    attr_reader block: Prism::node?
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+
+    def initialize: (Source source, Integer flags, Prism::node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Prism::node? block, Location operator_loc, Prism::node value, Location location) -> void
+    def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: Prism::node?, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> IndexAndWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Prism::node?, operator_loc: Location, value: Prism::node, location: Location }
+    def safe_navigation?: () -> bool
+    def variable_call?: () -> bool
+    def attribute_write?: () -> bool
+    def ignore_visibility?: () -> bool
+    def call_operator: () -> String?
+    def opening: () -> String
+    def closing: () -> String
+    def operator: () -> String
+    def type: () -> :index_and_write_node
+            | ...
+    def self.type: () -> :index_and_write_node
+  end
+
+  # Represents the use of an assignment operator on a call to `[]`.
+  #
+  #     foo.bar[baz] += value
+  #     ^^^^^^^^^^^^^^^^^^^^^
+  class IndexOperatorWriteNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader receiver: Prism::node?
+    attr_reader call_operator_loc: Location?
+    attr_reader opening_loc: Location
+    attr_reader arguments: ArgumentsNode?
+    attr_reader closing_loc: Location
+    attr_reader block: Prism::node?
+    attr_reader operator: Symbol
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+
+    def initialize: (Source source, Integer flags, Prism::node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Prism::node? block, Symbol operator, Location operator_loc, Prism::node value, Location location) -> void
+    def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: Prism::node?, ?operator: Symbol, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> IndexOperatorWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Prism::node?, operator: Symbol, operator_loc: Location, value: Prism::node, location: Location }
+    def safe_navigation?: () -> bool
+    def variable_call?: () -> bool
+    def attribute_write?: () -> bool
+    def ignore_visibility?: () -> bool
+    def call_operator: () -> String?
+    def opening: () -> String
+    def closing: () -> String
+    def type: () -> :index_operator_write_node
+            | ...
+    def self.type: () -> :index_operator_write_node
+  end
+
+  # Represents the use of the `||=` operator on a call to `[]`.
+  #
+  #     foo.bar[baz] ||= value
+  #     ^^^^^^^^^^^^^^^^^^^^^^
+  class IndexOrWriteNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader receiver: Prism::node?
+    attr_reader call_operator_loc: Location?
+    attr_reader opening_loc: Location
+    attr_reader arguments: ArgumentsNode?
+    attr_reader closing_loc: Location
+    attr_reader block: Prism::node?
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+
+    def initialize: (Source source, Integer flags, Prism::node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Prism::node? block, Location operator_loc, Prism::node value, Location location) -> void
+    def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: Prism::node?, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> IndexOrWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Prism::node?, operator_loc: Location, value: Prism::node, location: Location }
+    def safe_navigation?: () -> bool
+    def variable_call?: () -> bool
+    def attribute_write?: () -> bool
+    def ignore_visibility?: () -> bool
+    def call_operator: () -> String?
+    def opening: () -> String
+    def closing: () -> String
+    def operator: () -> String
+    def type: () -> :index_or_write_node
+            | ...
+    def self.type: () -> :index_or_write_node
+  end
+
+  # Represents assigning to an index.
+  #
+  #     foo[bar], = 1
+  #     ^^^^^^^^
+  #
+  #     begin
+  #     rescue => foo[bar]
+  #               ^^^^^^^^
+  #     end
+  #
+  #     for foo[bar] in baz do end
+  #         ^^^^^^^^
+  class IndexTargetNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader receiver: Prism::node
+    attr_reader opening_loc: Location
+    attr_reader arguments: ArgumentsNode?
+    attr_reader closing_loc: Location
+    attr_reader block: Prism::node?
+
+    def initialize: (Source source, Integer flags, Prism::node receiver, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Prism::node? block, Location location) -> void
+    def copy: (?flags: Integer, ?receiver: Prism::node, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: Prism::node?, ?location: Location) -> IndexTargetNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Prism::node?, location: Location }
+    def safe_navigation?: () -> bool
+    def variable_call?: () -> bool
+    def attribute_write?: () -> bool
+    def ignore_visibility?: () -> bool
+    def opening: () -> String
+    def closing: () -> String
+    def type: () -> :index_target_node
+            | ...
+    def self.type: () -> :index_target_node
+  end
+
+  # Represents the use of the `&&=` operator for assignment to an instance variable.
+  #
+  #     @target &&= value
+  #     ^^^^^^^^^^^^^^^^^
+  class InstanceVariableAndWriteNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+
+    def initialize: (Source source, Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
+    def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> InstanceVariableAndWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, location: Location }
+    def operator: () -> String
+    def type: () -> :instance_variable_and_write_node
+            | ...
+    def self.type: () -> :instance_variable_and_write_node
+  end
+
+  # Represents assigning to an instance variable using an operator that isn't `=`.
+  #
+  #     @target += value
+  #     ^^^^^^^^^^^^^^^^
+  class InstanceVariableOperatorWriteNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+    attr_reader operator: Symbol
+
+    def initialize: (Source source, Symbol name, Location name_loc, Location operator_loc, Prism::node value, Symbol operator, Location location) -> void
+    def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?operator: Symbol, ?location: Location) -> InstanceVariableOperatorWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, operator: Symbol, location: Location }
+    def type: () -> :instance_variable_operator_write_node
+            | ...
+    def self.type: () -> :instance_variable_operator_write_node
+  end
+
+  # Represents the use of the `||=` operator for assignment to an instance variable.
+  #
+  #     @target ||= value
+  #     ^^^^^^^^^^^^^^^^^
+  class InstanceVariableOrWriteNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+
+    def initialize: (Source source, Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
+    def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> InstanceVariableOrWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, location: Location }
+    def operator: () -> String
+    def type: () -> :instance_variable_or_write_node
+            | ...
+    def self.type: () -> :instance_variable_or_write_node
+  end
+
+  # Represents referencing an instance variable.
+  #
+  #     @foo
+  #     ^^^^
+  class InstanceVariableReadNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+
+    def initialize: (Source source, Symbol name, Location location) -> void
+    def copy: (?name: Symbol, ?location: Location) -> InstanceVariableReadNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
+    def type: () -> :instance_variable_read_node
+            | ...
+    def self.type: () -> :instance_variable_read_node
+  end
+
+  # Represents writing to an instance variable in a context that doesn't have an explicit value.
+  #
+  #     @foo, @bar = baz
+  #     ^^^^  ^^^^
+  class InstanceVariableTargetNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+
+    def initialize: (Source source, Symbol name, Location location) -> void
+    def copy: (?name: Symbol, ?location: Location) -> InstanceVariableTargetNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, location: Location }
+    def type: () -> :instance_variable_target_node
+            | ...
+    def self.type: () -> :instance_variable_target_node
+  end
+
+  # Represents writing to an instance variable.
+  #
+  #     @foo = 1
+  #     ^^^^^^^^
+  class InstanceVariableWriteNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader value: Prism::node
+    attr_reader operator_loc: Location
+
+    def initialize: (Source source, Symbol name, Location name_loc, Prism::node value, Location operator_loc, Location location) -> void
+    def copy: (?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location, ?location: Location) -> InstanceVariableWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location, location: Location }
+    def operator: () -> String
+    def type: () -> :instance_variable_write_node
+            | ...
+    def self.type: () -> :instance_variable_write_node
+  end
+
+  # Represents an integer number literal.
+  #
+  #     1
+  #     ^
+  class IntegerNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader value: Integer
+
+    def initialize: (Source source, Integer flags, Integer value, Location location) -> void
+    def copy: (?flags: Integer, ?value: Integer, ?location: Location) -> IntegerNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, value: Integer, location: Location }
+    def binary?: () -> bool
+    def decimal?: () -> bool
+    def octal?: () -> bool
+    def hexadecimal?: () -> bool
+    def type: () -> :integer_node
+            | ...
+    def self.type: () -> :integer_node
+  end
+
+  # Represents a regular expression literal that contains interpolation that is being used in the predicate of a conditional to implicitly match against the last line read by an IO object.
+  #
+  #     if /foo #{bar} baz/ then end
+  #        ^^^^^^^^^^^^^^^^
+  class InterpolatedMatchLastLineNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader opening_loc: Location
+    attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
+    attr_reader closing_loc: Location
+
+    def initialize: (Source source, Integer flags, Location opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] parts, Location closing_loc, Location location) -> void
+    def copy: (?flags: Integer, ?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location, ?location: Location) -> InterpolatedMatchLastLineNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location, location: Location }
+    def ignore_case?: () -> bool
+    def extended?: () -> bool
+    def multi_line?: () -> bool
+    def once?: () -> bool
+    def euc_jp?: () -> bool
+    def ascii_8bit?: () -> bool
+    def windows_31j?: () -> bool
+    def utf_8?: () -> bool
+    def forced_utf8_encoding?: () -> bool
+    def forced_binary_encoding?: () -> bool
+    def forced_us_ascii_encoding?: () -> bool
+    def opening: () -> String
+    def closing: () -> String
+    def type: () -> :interpolated_match_last_line_node
+            | ...
+    def self.type: () -> :interpolated_match_last_line_node
+  end
+
+  # Represents a regular expression literal that contains interpolation.
+  #
+  #     /foo #{bar} baz/
+  #     ^^^^^^^^^^^^^^^^
+  class InterpolatedRegularExpressionNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader opening_loc: Location
+    attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
+    attr_reader closing_loc: Location
+
+    def initialize: (Source source, Integer flags, Location opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] parts, Location closing_loc, Location location) -> void
+    def copy: (?flags: Integer, ?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location, ?location: Location) -> InterpolatedRegularExpressionNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location, location: Location }
+    def ignore_case?: () -> bool
+    def extended?: () -> bool
+    def multi_line?: () -> bool
+    def once?: () -> bool
+    def euc_jp?: () -> bool
+    def ascii_8bit?: () -> bool
+    def windows_31j?: () -> bool
+    def utf_8?: () -> bool
+    def forced_utf8_encoding?: () -> bool
+    def forced_binary_encoding?: () -> bool
+    def forced_us_ascii_encoding?: () -> bool
+    def opening: () -> String
+    def closing: () -> String
+    def type: () -> :interpolated_regular_expression_node
+            | ...
+    def self.type: () -> :interpolated_regular_expression_node
+  end
+
+  # Represents a string literal that contains interpolation.
+  #
+  #     "foo #{bar} baz"
+  #     ^^^^^^^^^^^^^^^^
+  class InterpolatedStringNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader opening_loc: Location?
+    attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode]
+    attr_reader closing_loc: Location?
+
+    def initialize: (Source source, Integer flags, Location? opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode] parts, Location? closing_loc, Location location) -> void
+    def copy: (?flags: Integer, ?opening_loc: Location?, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode], ?closing_loc: Location?, ?location: Location) -> InterpolatedStringNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location?, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode], closing_loc: Location?, location: Location }
+    def frozen?: () -> bool
+    def mutable?: () -> bool
+    def opening: () -> String?
+    def closing: () -> String?
+    def type: () -> :interpolated_string_node
+            | ...
+    def self.type: () -> :interpolated_string_node
+  end
+
+  # Represents a symbol literal that contains interpolation.
+  #
+  #     :"foo #{bar} baz"
+  #     ^^^^^^^^^^^^^^^^^
+  class InterpolatedSymbolNode < Node
+    include _Node
+
+    attr_reader opening_loc: Location?
+    attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
+    attr_reader closing_loc: Location?
+
+    def initialize: (Source source, Location? opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] parts, Location? closing_loc, Location location) -> void
+    def copy: (?opening_loc: Location?, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location?, ?location: Location) -> InterpolatedSymbolNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { opening_loc: Location?, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location?, location: Location }
+    def opening: () -> String?
+    def closing: () -> String?
+    def type: () -> :interpolated_symbol_node
+            | ...
+    def self.type: () -> :interpolated_symbol_node
+  end
+
+  # Represents an xstring literal that contains interpolation.
+  #
+  #     `foo #{bar} baz`
+  #     ^^^^^^^^^^^^^^^^
+  class InterpolatedXStringNode < Node
+    include _Node
+
+    attr_reader opening_loc: Location
+    attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode]
+    attr_reader closing_loc: Location
+
+    def initialize: (Source source, Location opening_loc, Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] parts, Location closing_loc, Location location) -> void
+    def copy: (?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location, ?location: Location) -> InterpolatedXStringNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location, location: Location }
+    def opening: () -> String
+    def closing: () -> String
+    def type: () -> :interpolated_x_string_node
+            | ...
+    def self.type: () -> :interpolated_x_string_node
+  end
+
+  # Represents an implicit set of parameters through the use of the `it` keyword within a block or lambda.
+  #
+  #     -> { it + it }
+  #     ^^^^^^^^^^^^^^
+  class ItParametersNode < Node
+    include _Node
+
+
+    def initialize: (Source source, Location location) -> void
+    def copy: (?location: Location) -> ItParametersNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+    def type: () -> :it_parameters_node
+            | ...
+    def self.type: () -> :it_parameters_node
+  end
+
+  # Represents a hash literal without opening and closing braces.
+  #
+  #     foo(a: b)
+  #         ^^^^
+  class KeywordHashNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader elements: Array[AssocNode | AssocSplatNode]
+
+    def initialize: (Source source, Integer flags, Array[AssocNode | AssocSplatNode] elements, Location location) -> void
+    def copy: (?flags: Integer, ?elements: Array[AssocNode | AssocSplatNode], ?location: Location) -> KeywordHashNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, elements: Array[AssocNode | AssocSplatNode], location: Location }
+    def symbol_keys?: () -> bool
+    def type: () -> :keyword_hash_node
+            | ...
+    def self.type: () -> :keyword_hash_node
+  end
+
+  # Represents a keyword rest parameter to a method, block, or lambda definition.
+  #
+  #     def a(**b)
+  #           ^^^
+  #     end
+  class KeywordRestParameterNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader name: Symbol?
+    attr_reader name_loc: Location?
+    attr_reader operator_loc: Location
+
+    def initialize: (Source source, Integer flags, Symbol? name, Location? name_loc, Location operator_loc, Location location) -> void
+    def copy: (?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location, ?location: Location) -> KeywordRestParameterNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location }
+    def repeated_parameter?: () -> bool
+    def operator: () -> String
+    def type: () -> :keyword_rest_parameter_node
+            | ...
+    def self.type: () -> :keyword_rest_parameter_node
+  end
+
+  # Represents using a lambda literal (not the lambda method call).
+  #
+  #     ->(value) { value * 2 }
+  #     ^^^^^^^^^^^^^^^^^^^^^^^
+  class LambdaNode < Node
+    include _Node
+
+    attr_reader locals: Array[Symbol]
+    attr_reader operator_loc: Location
+    attr_reader opening_loc: Location
+    attr_reader closing_loc: Location
+    attr_reader parameters: Prism::node?
+    attr_reader body: Prism::node?
+
+    def initialize: (Source source, Array[Symbol] locals, Location operator_loc, Location opening_loc, Location closing_loc, Prism::node? parameters, Prism::node? body, Location location) -> void
+    def copy: (?locals: Array[Symbol], ?operator_loc: Location, ?opening_loc: Location, ?closing_loc: Location, ?parameters: Prism::node?, ?body: Prism::node?, ?location: Location) -> LambdaNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: Prism::node?, body: Prism::node?, location: Location }
+    def operator: () -> String
+    def opening: () -> String
+    def closing: () -> String
+    def type: () -> :lambda_node
+            | ...
+    def self.type: () -> :lambda_node
+  end
+
+  # Represents the use of the `&&=` operator for assignment to a local variable.
+  #
+  #     target &&= value
+  #     ^^^^^^^^^^^^^^^^
+  class LocalVariableAndWriteNode < Node
+    include _Node
+
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+    attr_reader name: Symbol
+    attr_reader depth: Integer
+
+    def initialize: (Source source, Location name_loc, Location operator_loc, Prism::node value, Symbol name, Integer depth, Location location) -> void
+    def copy: (?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?depth: Integer, ?location: Location) -> LocalVariableAndWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name_loc: Location, operator_loc: Location, value: Prism::node, name: Symbol, depth: Integer, location: Location }
+    def operator: () -> String
+    def type: () -> :local_variable_and_write_node
+            | ...
+    def self.type: () -> :local_variable_and_write_node
+  end
+
+  # Represents assigning to a local variable using an operator that isn't `=`.
+  #
+  #     target += value
+  #     ^^^^^^^^^^^^^^^
+  class LocalVariableOperatorWriteNode < Node
+    include _Node
+
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+    attr_reader name: Symbol
+    attr_reader operator: Symbol
+    attr_reader depth: Integer
+
+    def initialize: (Source source, Location name_loc, Location operator_loc, Prism::node value, Symbol name, Symbol operator, Integer depth, Location location) -> void
+    def copy: (?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?operator: Symbol, ?depth: Integer, ?location: Location) -> LocalVariableOperatorWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name_loc: Location, operator_loc: Location, value: Prism::node, name: Symbol, operator: Symbol, depth: Integer, location: Location }
+    def type: () -> :local_variable_operator_write_node
+            | ...
+    def self.type: () -> :local_variable_operator_write_node
+  end
+
+  # Represents the use of the `||=` operator for assignment to a local variable.
+  #
+  #     target ||= value
+  #     ^^^^^^^^^^^^^^^^
+  class LocalVariableOrWriteNode < Node
+    include _Node
+
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+    attr_reader name: Symbol
+    attr_reader depth: Integer
+
+    def initialize: (Source source, Location name_loc, Location operator_loc, Prism::node value, Symbol name, Integer depth, Location location) -> void
+    def copy: (?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?depth: Integer, ?location: Location) -> LocalVariableOrWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name_loc: Location, operator_loc: Location, value: Prism::node, name: Symbol, depth: Integer, location: Location }
+    def operator: () -> String
+    def type: () -> :local_variable_or_write_node
+            | ...
+    def self.type: () -> :local_variable_or_write_node
+  end
+
+  # Represents reading a local variable. Note that this requires that a local variable of the same name has already been written to in the same scope, otherwise it is parsed as a method call.
+  #
+  #     foo
+  #     ^^^
+  class LocalVariableReadNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+    attr_reader depth: Integer
+
+    def initialize: (Source source, Symbol name, Integer depth, Location location) -> void
+    def copy: (?name: Symbol, ?depth: Integer, ?location: Location) -> LocalVariableReadNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, depth: Integer, location: Location }
+    def type: () -> :local_variable_read_node
+            | ...
+    def self.type: () -> :local_variable_read_node
+  end
+
+  # Represents writing to a local variable in a context that doesn't have an explicit value.
+  #
+  #     foo, bar = baz
+  #     ^^^  ^^^
+  class LocalVariableTargetNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+    attr_reader depth: Integer
+
+    def initialize: (Source source, Symbol name, Integer depth, Location location) -> void
+    def copy: (?name: Symbol, ?depth: Integer, ?location: Location) -> LocalVariableTargetNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, depth: Integer, location: Location }
+    def type: () -> :local_variable_target_node
+            | ...
+    def self.type: () -> :local_variable_target_node
+  end
+
+  # Represents writing to a local variable.
+  #
+  #     foo = 1
+  #     ^^^^^^^
+  class LocalVariableWriteNode < Node
+    include _Node
+
+    attr_reader name: Symbol
+    attr_reader depth: Integer
+    attr_reader name_loc: Location
+    attr_reader value: Prism::node
+    attr_reader operator_loc: Location
+
+    def initialize: (Source source, Symbol name, Integer depth, Location name_loc, Prism::node value, Location operator_loc, Location location) -> void
+    def copy: (?name: Symbol, ?depth: Integer, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location, ?location: Location) -> LocalVariableWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, depth: Integer, name_loc: Location, value: Prism::node, operator_loc: Location, location: Location }
+    def operator: () -> String
+    def type: () -> :local_variable_write_node
+            | ...
+    def self.type: () -> :local_variable_write_node
+  end
+
+  # Represents a regular expression literal used in the predicate of a conditional to implicitly match against the last line read by an IO object.
+  #
+  #     if /foo/i then end
+  #        ^^^^^^
+  class MatchLastLineNode < Node
+    include _Node
+
+    private 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: (Source source, Integer flags, Location opening_loc, Location content_loc, Location closing_loc, String unescaped, Location location) -> void
+    def copy: (?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String, ?location: Location) -> MatchLastLineNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location }
+    def ignore_case?: () -> bool
+    def extended?: () -> bool
+    def multi_line?: () -> bool
+    def once?: () -> bool
+    def euc_jp?: () -> bool
+    def ascii_8bit?: () -> bool
+    def windows_31j?: () -> bool
+    def utf_8?: () -> bool
+    def forced_utf8_encoding?: () -> bool
+    def forced_binary_encoding?: () -> bool
+    def forced_us_ascii_encoding?: () -> bool
+    def opening: () -> String
+    def content: () -> String
+    def closing: () -> String
+    def type: () -> :match_last_line_node
+            | ...
+    def self.type: () -> :match_last_line_node
+  end
+
+  # Represents the use of the modifier `in` operator.
+  #
+  #     foo in bar
+  #     ^^^^^^^^^^
+  class MatchPredicateNode < Node
+    include _Node
+
+    attr_reader value: Prism::node
+    attr_reader pattern: Prism::node
+    attr_reader operator_loc: Location
+
+    def initialize: (Source source, Prism::node value, Prism::node pattern, Location operator_loc, Location location) -> void
+    def copy: (?value: Prism::node, ?pattern: Prism::node, ?operator_loc: Location, ?location: Location) -> MatchPredicateNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { value: Prism::node, pattern: Prism::node, operator_loc: Location, location: Location }
+    def operator: () -> String
+    def type: () -> :match_predicate_node
+            | ...
+    def self.type: () -> :match_predicate_node
+  end
+
+  # Represents the use of the `=>` operator.
+  #
+  #     foo => bar
+  #     ^^^^^^^^^^
+  class MatchRequiredNode < Node
+    include _Node
+
+    attr_reader value: Prism::node
+    attr_reader pattern: Prism::node
+    attr_reader operator_loc: Location
+
+    def initialize: (Source source, Prism::node value, Prism::node pattern, Location operator_loc, Location location) -> void
+    def copy: (?value: Prism::node, ?pattern: Prism::node, ?operator_loc: Location, ?location: Location) -> MatchRequiredNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { value: Prism::node, pattern: Prism::node, operator_loc: Location, location: Location }
+    def operator: () -> String
+    def type: () -> :match_required_node
+            | ...
+    def self.type: () -> :match_required_node
+  end
+
+  # Represents writing local variables using a regular expression match with named capture groups.
+  #
+  #     /(?<foo>bar)/ =~ baz
+  #     ^^^^^^^^^^^^^^^^^^^^
+  class MatchWriteNode < Node
+    include _Node
+
+    attr_reader call: CallNode
+    attr_reader targets: Array[LocalVariableTargetNode]
+
+    def initialize: (Source source, CallNode call, Array[LocalVariableTargetNode] targets, Location location) -> void
+    def copy: (?call: CallNode, ?targets: Array[LocalVariableTargetNode], ?location: Location) -> MatchWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { call: CallNode, targets: Array[LocalVariableTargetNode], location: Location }
+    def type: () -> :match_write_node
+            | ...
+    def self.type: () -> :match_write_node
+  end
+
+  # Represents a node that is missing from the source and results in a syntax error.
+  class MissingNode < Node
+    include _Node
+
+
+    def initialize: (Source source, Location location) -> void
+    def copy: (?location: Location) -> MissingNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+    def type: () -> :missing_node
+            | ...
+    def self.type: () -> :missing_node
+  end
+
+  # Represents a module declaration involving the `module` keyword.
+  #
+  #     module Foo end
+  #     ^^^^^^^^^^^^^^
+  class ModuleNode < Node
+    include _Node
+
+    attr_reader locals: Array[Symbol]
+    attr_reader module_keyword_loc: Location
+    attr_reader constant_path: Prism::node
+    attr_reader body: Prism::node?
+    attr_reader end_keyword_loc: Location
+    attr_reader name: Symbol
+
+    def initialize: (Source source, Array[Symbol] locals, Location module_keyword_loc, Prism::node constant_path, Prism::node? body, Location end_keyword_loc, Symbol name, Location location) -> void
+    def copy: (?locals: Array[Symbol], ?module_keyword_loc: Location, ?constant_path: Prism::node, ?body: Prism::node?, ?end_keyword_loc: Location, ?name: Symbol, ?location: Location) -> ModuleNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], module_keyword_loc: Location, constant_path: Prism::node, body: Prism::node?, end_keyword_loc: Location, name: Symbol, location: Location }
+    def module_keyword: () -> String
+    def end_keyword: () -> String
+    def type: () -> :module_node
+            | ...
+    def self.type: () -> :module_node
+  end
+
+  # Represents a multi-target expression.
+  #
+  #     a, (b, c) = 1, 2, 3
+  #        ^^^^^^
+  class MultiTargetNode < Node
+    include _Node
+
+    attr_reader lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode]
+    attr_reader rest: Prism::node?
+    attr_reader rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode]
+    attr_reader lparen_loc: Location?
+    attr_reader rparen_loc: Location?
+
+    def initialize: (Source source, Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode] lefts, Prism::node? rest, Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode] rights, Location? lparen_loc, Location? rparen_loc, Location location) -> void
+    def copy: (?lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], ?rest: Prism::node?, ?rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode], ?lparen_loc: Location?, ?rparen_loc: Location?, ?location: Location) -> MultiTargetNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], rest: Prism::node?, rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode], lparen_loc: Location?, rparen_loc: Location?, location: Location }
+    def lparen: () -> String?
+    def rparen: () -> String?
+    def type: () -> :multi_target_node
+            | ...
+    def self.type: () -> :multi_target_node
+  end
+
+  # Represents a write to a multi-target expression.
+  #
+  #     a, b, c = 1, 2, 3
+  #     ^^^^^^^^^^^^^^^^^
+  class MultiWriteNode < Node
+    include _Node
+
+    attr_reader lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode]
+    attr_reader rest: Prism::node?
+    attr_reader rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode]
+    attr_reader lparen_loc: Location?
+    attr_reader rparen_loc: Location?
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+
+    def initialize: (Source source, Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode] lefts, Prism::node? rest, Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode] rights, Location? lparen_loc, Location? rparen_loc, Location operator_loc, Prism::node value, Location location) -> void
+    def copy: (?lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode], ?rest: Prism::node?, ?rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode], ?lparen_loc: Location?, ?rparen_loc: Location?, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> MultiWriteNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode], rest: Prism::node?, rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode], lparen_loc: Location?, rparen_loc: Location?, operator_loc: Location, value: Prism::node, location: Location }
+    def lparen: () -> String?
+    def rparen: () -> String?
+    def operator: () -> String
+    def type: () -> :multi_write_node
+            | ...
+    def self.type: () -> :multi_write_node
+  end
+
+  # Represents the use of the `next` keyword.
+  #
+  #     next 1
+  #     ^^^^^^
+  class NextNode < Node
+    include _Node
+
+    attr_reader arguments: ArgumentsNode?
+    attr_reader keyword_loc: Location
+
+    def initialize: (Source source, ArgumentsNode? arguments, Location keyword_loc, Location location) -> void
+    def copy: (?arguments: ArgumentsNode?, ?keyword_loc: Location, ?location: Location) -> NextNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { arguments: ArgumentsNode?, keyword_loc: Location, location: Location }
+    def keyword: () -> String
+    def type: () -> :next_node
+            | ...
+    def self.type: () -> :next_node
+  end
+
+  # Represents the use of the `nil` keyword.
+  #
+  #     nil
+  #     ^^^
+  class NilNode < Node
+    include _Node
+
+
+    def initialize: (Source source, Location location) -> void
+    def copy: (?location: Location) -> NilNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+    def type: () -> :nil_node
+            | ...
+    def self.type: () -> :nil_node
+  end
+
+  # Represents the use of `**nil` inside method arguments.
+  #
+  #     def a(**nil)
+  #           ^^^^^
+  #     end
+  class NoKeywordsParameterNode < Node
+    include _Node
+
+    attr_reader operator_loc: Location
+    attr_reader keyword_loc: Location
+
+    def initialize: (Source source, Location operator_loc, Location keyword_loc, Location location) -> void
+    def copy: (?operator_loc: Location, ?keyword_loc: Location, ?location: Location) -> NoKeywordsParameterNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { operator_loc: Location, keyword_loc: Location, location: Location }
+    def operator: () -> String
+    def keyword: () -> String
+    def type: () -> :no_keywords_parameter_node
+            | ...
+    def self.type: () -> :no_keywords_parameter_node
+  end
+
+  # Represents an implicit set of parameters through the use of numbered parameters within a block or lambda.
+  #
+  #     -> { _1 + _2 }
+  #     ^^^^^^^^^^^^^^
+  class NumberedParametersNode < Node
+    include _Node
+
+    attr_reader maximum: Integer
+
+    def initialize: (Source source, Integer maximum, Location location) -> void
+    def copy: (?maximum: Integer, ?location: Location) -> NumberedParametersNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { maximum: Integer, location: Location }
+    def type: () -> :numbered_parameters_node
+            | ...
+    def self.type: () -> :numbered_parameters_node
+  end
+
+  # Represents reading a numbered reference to a capture in the previous match.
+  #
+  #     $1
+  #     ^^
+  class NumberedReferenceReadNode < Node
+    include _Node
+
+    attr_reader number: Integer
+
+    def initialize: (Source source, Integer number, Location location) -> void
+    def copy: (?number: Integer, ?location: Location) -> NumberedReferenceReadNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { number: Integer, location: Location }
+    def type: () -> :numbered_reference_read_node
+            | ...
+    def self.type: () -> :numbered_reference_read_node
+  end
+
+  # Represents an optional keyword parameter to a method, block, or lambda definition.
+  #
+  #     def a(b: 1)
+  #           ^^^^
+  #     end
+  class OptionalKeywordParameterNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader value: Prism::node
+
+    def initialize: (Source source, Integer flags, Symbol name, Location name_loc, Prism::node value, Location location) -> void
+    def copy: (?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?location: Location) -> OptionalKeywordParameterNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol, name_loc: Location, value: Prism::node, location: Location }
+    def repeated_parameter?: () -> bool
+    def type: () -> :optional_keyword_parameter_node
+            | ...
+    def self.type: () -> :optional_keyword_parameter_node
+  end
+
+  # Represents an optional parameter to a method, block, or lambda definition.
+  #
+  #     def a(b = 1)
+  #           ^^^^^
+  #     end
+  class OptionalParameterNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader value: Prism::node
+
+    def initialize: (Source source, Integer flags, Symbol name, Location name_loc, Location operator_loc, Prism::node value, Location location) -> void
+    def copy: (?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> OptionalParameterNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, location: Location }
+    def repeated_parameter?: () -> bool
+    def operator: () -> String
+    def type: () -> :optional_parameter_node
+            | ...
+    def self.type: () -> :optional_parameter_node
+  end
+
+  # Represents the use of the `||` operator or the `or` keyword.
+  #
+  #     left or right
+  #     ^^^^^^^^^^^^^
+  class OrNode < Node
+    include _Node
+
+    attr_reader left: Prism::node
+    attr_reader right: Prism::node
+    attr_reader operator_loc: Location
+
+    def initialize: (Source source, Prism::node left, Prism::node right, Location operator_loc, Location location) -> void
+    def copy: (?left: Prism::node, ?right: Prism::node, ?operator_loc: Location, ?location: Location) -> OrNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { left: Prism::node, right: Prism::node, operator_loc: Location, location: Location }
+    def operator: () -> String
+    def type: () -> :or_node
+            | ...
+    def self.type: () -> :or_node
+  end
+
+  # Represents the list of parameters on a method, block, or lambda definition.
+  #
+  #     def a(b, c, d)
+  #           ^^^^^^^
+  #     end
+  class ParametersNode < Node
+    include _Node
+
+    attr_reader requireds: Array[RequiredParameterNode | MultiTargetNode]
+    attr_reader optionals: Array[OptionalParameterNode]
+    attr_reader rest: RestParameterNode | ImplicitRestNode | nil
+    attr_reader posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode]
+    attr_reader keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode]
+    attr_reader keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil
+    attr_reader block: BlockParameterNode?
+
+    def initialize: (Source source, Array[RequiredParameterNode | MultiTargetNode] requireds, Array[OptionalParameterNode] optionals, RestParameterNode | ImplicitRestNode | nil rest, Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode] posts, Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode] keywords, KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil keyword_rest, BlockParameterNode? block, Location location) -> void
+    def copy: (?requireds: Array[RequiredParameterNode | MultiTargetNode], ?optionals: Array[OptionalParameterNode], ?rest: RestParameterNode | ImplicitRestNode | nil, ?posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode], ?keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], ?keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, ?block: BlockParameterNode?, ?location: Location) -> ParametersNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { requireds: Array[RequiredParameterNode | MultiTargetNode], optionals: Array[OptionalParameterNode], rest: RestParameterNode | ImplicitRestNode | nil, posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode], keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, block: BlockParameterNode?, location: Location }
+    def type: () -> :parameters_node
+            | ...
+    def self.type: () -> :parameters_node
+  end
+
+  # Represents a parenthesized expression
+  #
+  #     (10 + 34)
+  #     ^^^^^^^^^
+  class ParenthesesNode < Node
+    include _Node
+
+    attr_reader body: Prism::node?
+    attr_reader opening_loc: Location
+    attr_reader closing_loc: Location
+
+    def initialize: (Source source, Prism::node? body, Location opening_loc, Location closing_loc, Location location) -> void
+    def copy: (?body: Prism::node?, ?opening_loc: Location, ?closing_loc: Location, ?location: Location) -> ParenthesesNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { body: Prism::node?, opening_loc: Location, closing_loc: Location, location: Location }
+    def opening: () -> String
+    def closing: () -> String
+    def type: () -> :parentheses_node
+            | ...
+    def self.type: () -> :parentheses_node
+  end
+
+  # Represents the use of the `^` operator for pinning an expression in a pattern matching expression.
+  #
+  #     foo in ^(bar)
+  #            ^^^^^^
+  class PinnedExpressionNode < Node
+    include _Node
+
+    attr_reader expression: Prism::node
+    attr_reader operator_loc: Location
+    attr_reader lparen_loc: Location
+    attr_reader rparen_loc: Location
+
+    def initialize: (Source source, Prism::node expression, Location operator_loc, Location lparen_loc, Location rparen_loc, Location location) -> void
+    def copy: (?expression: Prism::node, ?operator_loc: Location, ?lparen_loc: Location, ?rparen_loc: Location, ?location: Location) -> PinnedExpressionNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { expression: Prism::node, operator_loc: Location, lparen_loc: Location, rparen_loc: Location, location: Location }
+    def operator: () -> String
+    def lparen: () -> String
+    def rparen: () -> String
+    def type: () -> :pinned_expression_node
+            | ...
+    def self.type: () -> :pinned_expression_node
+  end
+
+  # Represents the use of the `^` operator for pinning a variable in a pattern matching expression.
+  #
+  #     foo in ^bar
+  #            ^^^^
+  class PinnedVariableNode < Node
+    include _Node
+
+    attr_reader variable: Prism::node
+    attr_reader operator_loc: Location
+
+    def initialize: (Source source, Prism::node variable, Location operator_loc, Location location) -> void
+    def copy: (?variable: Prism::node, ?operator_loc: Location, ?location: Location) -> PinnedVariableNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { variable: Prism::node, operator_loc: Location, location: Location }
+    def operator: () -> String
+    def type: () -> :pinned_variable_node
+            | ...
+    def self.type: () -> :pinned_variable_node
+  end
+
+  # Represents the use of the `END` keyword.
+  #
+  #     END { foo }
+  #     ^^^^^^^^^^^
+  class PostExecutionNode < Node
+    include _Node
+
+    attr_reader statements: StatementsNode?
+    attr_reader keyword_loc: Location
+    attr_reader opening_loc: Location
+    attr_reader closing_loc: Location
+
+    def initialize: (Source source, StatementsNode? statements, Location keyword_loc, Location opening_loc, Location closing_loc, Location location) -> void
+    def copy: (?statements: StatementsNode?, ?keyword_loc: Location, ?opening_loc: Location, ?closing_loc: Location, ?location: Location) -> PostExecutionNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location }
+    def keyword: () -> String
+    def opening: () -> String
+    def closing: () -> String
+    def type: () -> :post_execution_node
+            | ...
+    def self.type: () -> :post_execution_node
+  end
+
+  # Represents the use of the `BEGIN` keyword.
+  #
+  #     BEGIN { foo }
+  #     ^^^^^^^^^^^^^
+  class PreExecutionNode < Node
+    include _Node
+
+    attr_reader statements: StatementsNode?
+    attr_reader keyword_loc: Location
+    attr_reader opening_loc: Location
+    attr_reader closing_loc: Location
+
+    def initialize: (Source source, StatementsNode? statements, Location keyword_loc, Location opening_loc, Location closing_loc, Location location) -> void
+    def copy: (?statements: StatementsNode?, ?keyword_loc: Location, ?opening_loc: Location, ?closing_loc: Location, ?location: Location) -> PreExecutionNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location }
+    def keyword: () -> String
+    def opening: () -> String
+    def closing: () -> String
+    def type: () -> :pre_execution_node
+            | ...
+    def self.type: () -> :pre_execution_node
+  end
+
+  # The top level node of any parse tree.
+  class ProgramNode < Node
+    include _Node
+
+    attr_reader locals: Array[Symbol]
+    attr_reader statements: StatementsNode
+
+    def initialize: (Source source, Array[Symbol] locals, StatementsNode statements, Location location) -> void
+    def copy: (?locals: Array[Symbol], ?statements: StatementsNode, ?location: Location) -> ProgramNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], statements: StatementsNode, location: Location }
+    def type: () -> :program_node
+            | ...
+    def self.type: () -> :program_node
+  end
+
+  # Represents the use of the `..` or `...` operators.
+  #
+  #     1..2
+  #     ^^^^
+  #
+  #     c if a =~ /left/ ... b =~ /right/
+  #          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  class RangeNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader left: Prism::node?
+    attr_reader right: Prism::node?
+    attr_reader operator_loc: Location
+
+    def initialize: (Source source, Integer flags, Prism::node? left, Prism::node? right, Location operator_loc, Location location) -> void
+    def copy: (?flags: Integer, ?left: Prism::node?, ?right: Prism::node?, ?operator_loc: Location, ?location: Location) -> RangeNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, left: Prism::node?, right: Prism::node?, operator_loc: Location, location: Location }
+    def exclude_end?: () -> bool
+    def operator: () -> String
+    def type: () -> :range_node
+            | ...
+    def self.type: () -> :range_node
+  end
+
+  # Represents a rational number literal.
+  #
+  #     1.0r
+  #     ^^^^
+  class RationalNode < Node
+    include _Node
+
+    attr_reader numeric: Prism::node
+
+    def initialize: (Source source, Prism::node numeric, Location location) -> void
+    def copy: (?numeric: Prism::node, ?location: Location) -> RationalNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { numeric: Prism::node, location: Location }
+    def type: () -> :rational_node
+            | ...
+    def self.type: () -> :rational_node
+  end
+
+  # Represents the use of the `redo` keyword.
+  #
+  #     redo
+  #     ^^^^
+  class RedoNode < Node
+    include _Node
+
+
+    def initialize: (Source source, Location location) -> void
+    def copy: (?location: Location) -> RedoNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+    def type: () -> :redo_node
+            | ...
+    def self.type: () -> :redo_node
+  end
+
+  # Represents a regular expression literal with no interpolation.
+  #
+  #     /foo/i
+  #     ^^^^^^
+  class RegularExpressionNode < Node
+    include _Node
+
+    private 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: (Source source, Integer flags, Location opening_loc, Location content_loc, Location closing_loc, String unescaped, Location location) -> void
+    def copy: (?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String, ?location: Location) -> RegularExpressionNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location }
+    def ignore_case?: () -> bool
+    def extended?: () -> bool
+    def multi_line?: () -> bool
+    def once?: () -> bool
+    def euc_jp?: () -> bool
+    def ascii_8bit?: () -> bool
+    def windows_31j?: () -> bool
+    def utf_8?: () -> bool
+    def forced_utf8_encoding?: () -> bool
+    def forced_binary_encoding?: () -> bool
+    def forced_us_ascii_encoding?: () -> bool
+    def opening: () -> String
+    def content: () -> String
+    def closing: () -> String
+    def type: () -> :regular_expression_node
+            | ...
+    def self.type: () -> :regular_expression_node
+  end
+
+  # Represents a required keyword parameter to a method, block, or lambda definition.
+  #
+  #     def a(b: )
+  #           ^^
+  #     end
+  class RequiredKeywordParameterNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader name: Symbol
+    attr_reader name_loc: Location
+
+    def initialize: (Source source, Integer flags, Symbol name, Location name_loc, Location location) -> void
+    def copy: (?flags: Integer, ?name: Symbol, ?name_loc: Location, ?location: Location) -> RequiredKeywordParameterNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol, name_loc: Location, location: Location }
+    def repeated_parameter?: () -> bool
+    def type: () -> :required_keyword_parameter_node
+            | ...
+    def self.type: () -> :required_keyword_parameter_node
+  end
+
+  # Represents a required parameter to a method, block, or lambda definition.
+  #
+  #     def a(b)
+  #           ^
+  #     end
+  class RequiredParameterNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader name: Symbol
+
+    def initialize: (Source source, Integer flags, Symbol name, Location location) -> void
+    def copy: (?flags: Integer, ?name: Symbol, ?location: Location) -> RequiredParameterNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol, location: Location }
+    def repeated_parameter?: () -> bool
+    def type: () -> :required_parameter_node
+            | ...
+    def self.type: () -> :required_parameter_node
+  end
+
+  # Represents an expression modified with a rescue.
+  #
+  #     foo rescue nil
+  #     ^^^^^^^^^^^^^^
+  class RescueModifierNode < Node
+    include _Node
+
+    attr_reader expression: Prism::node
+    attr_reader keyword_loc: Location
+    attr_reader rescue_expression: Prism::node
+
+    def initialize: (Source source, Prism::node expression, Location keyword_loc, Prism::node rescue_expression, Location location) -> void
+    def copy: (?expression: Prism::node, ?keyword_loc: Location, ?rescue_expression: Prism::node, ?location: Location) -> RescueModifierNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { expression: Prism::node, keyword_loc: Location, rescue_expression: Prism::node, location: Location }
+    def keyword: () -> String
+    def type: () -> :rescue_modifier_node
+            | ...
+    def self.type: () -> :rescue_modifier_node
+  end
+
+  # Represents a rescue statement.
+  #
+  #     begin
+  #     rescue Foo, *splat, Bar => ex
+  #       foo
+  #     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+  #     end
+  #
+  # `Foo, *splat, Bar` are in the `exceptions` field. `ex` is in the `exception` field.
+  class RescueNode < Node
+    include _Node
+
+    attr_reader keyword_loc: Location
+    attr_reader exceptions: Array[Prism::node]
+    attr_reader operator_loc: Location?
+    attr_reader reference: Prism::node?
+    attr_reader statements: StatementsNode?
+    attr_reader consequent: RescueNode?
+
+    def initialize: (Source source, Location keyword_loc, Array[Prism::node] exceptions, Location? operator_loc, Prism::node? reference, StatementsNode? statements, RescueNode? consequent, Location location) -> void
+    def copy: (?keyword_loc: Location, ?exceptions: Array[Prism::node], ?operator_loc: Location?, ?reference: Prism::node?, ?statements: StatementsNode?, ?consequent: RescueNode?, ?location: Location) -> RescueNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, exceptions: Array[Prism::node], operator_loc: Location?, reference: Prism::node?, statements: StatementsNode?, consequent: RescueNode?, location: Location }
+    def keyword: () -> String
+    def operator: () -> String?
+    def type: () -> :rescue_node
+            | ...
+    def self.type: () -> :rescue_node
+  end
+
+  # Represents a rest parameter to a method, block, or lambda definition.
+  #
+  #     def a(*b)
+  #           ^^
+  #     end
+  class RestParameterNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader name: Symbol?
+    attr_reader name_loc: Location?
+    attr_reader operator_loc: Location
+
+    def initialize: (Source source, Integer flags, Symbol? name, Location? name_loc, Location operator_loc, Location location) -> void
+    def copy: (?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location, ?location: Location) -> RestParameterNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, name: Symbol?, name_loc: Location?, operator_loc: Location, location: Location }
+    def repeated_parameter?: () -> bool
+    def operator: () -> String
+    def type: () -> :rest_parameter_node
+            | ...
+    def self.type: () -> :rest_parameter_node
+  end
+
+  # Represents the use of the `retry` keyword.
+  #
+  #     retry
+  #     ^^^^^
+  class RetryNode < Node
+    include _Node
+
+
+    def initialize: (Source source, Location location) -> void
+    def copy: (?location: Location) -> RetryNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+    def type: () -> :retry_node
+            | ...
+    def self.type: () -> :retry_node
+  end
+
+  # Represents the use of the `return` keyword.
+  #
+  #     return 1
+  #     ^^^^^^^^
+  class ReturnNode < Node
+    include _Node
+
+    attr_reader keyword_loc: Location
+    attr_reader arguments: ArgumentsNode?
+
+    def initialize: (Source source, Location keyword_loc, ArgumentsNode? arguments, Location location) -> void
+    def copy: (?keyword_loc: Location, ?arguments: ArgumentsNode?, ?location: Location) -> ReturnNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, arguments: ArgumentsNode?, location: Location }
+    def keyword: () -> String
+    def type: () -> :return_node
+            | ...
+    def self.type: () -> :return_node
+  end
+
+  # Represents the `self` keyword.
+  #
+  #     self
+  #     ^^^^
+  class SelfNode < Node
+    include _Node
+
+
+    def initialize: (Source source, Location location) -> void
+    def copy: (?location: Location) -> SelfNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+    def type: () -> :self_node
+            | ...
+    def self.type: () -> :self_node
+  end
+
+  # This node wraps a constant write to indicate that when the value is written, it should have its shareability state modified.
+  #
+  #     # shareable_constant_value: literal
+  #     C = { a: 1 }
+  #     ^^^^^^^^^^^^
+  class ShareableConstantNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader write: ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode
+
+    def initialize: (Source source, Integer flags, ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode write, Location location) -> void
+    def copy: (?flags: Integer, ?write: ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode, ?location: Location) -> ShareableConstantNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, write: ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode, location: Location }
+    def literal?: () -> bool
+    def experimental_everything?: () -> bool
+    def experimental_copy?: () -> bool
+    def type: () -> :shareable_constant_node
+            | ...
+    def self.type: () -> :shareable_constant_node
+  end
+
+  # Represents a singleton class declaration involving the `class` keyword.
+  #
+  #     class << self end
+  #     ^^^^^^^^^^^^^^^^^
+  class SingletonClassNode < Node
+    include _Node
+
+    attr_reader locals: Array[Symbol]
+    attr_reader class_keyword_loc: Location
+    attr_reader operator_loc: Location
+    attr_reader expression: Prism::node
+    attr_reader body: Prism::node?
+    attr_reader end_keyword_loc: Location
+
+    def initialize: (Source source, Array[Symbol] locals, Location class_keyword_loc, Location operator_loc, Prism::node expression, Prism::node? body, Location end_keyword_loc, Location location) -> void
+    def copy: (?locals: Array[Symbol], ?class_keyword_loc: Location, ?operator_loc: Location, ?expression: Prism::node, ?body: Prism::node?, ?end_keyword_loc: Location, ?location: Location) -> SingletonClassNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { locals: Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Prism::node, body: Prism::node?, end_keyword_loc: Location, location: Location }
+    def class_keyword: () -> String
+    def operator: () -> String
+    def end_keyword: () -> String
+    def type: () -> :singleton_class_node
+            | ...
+    def self.type: () -> :singleton_class_node
+  end
+
+  # Represents the use of the `__ENCODING__` keyword.
+  #
+  #     __ENCODING__
+  #     ^^^^^^^^^^^^
+  class SourceEncodingNode < Node
+    include _Node
+
+
+    def initialize: (Source source, Location location) -> void
+    def copy: (?location: Location) -> SourceEncodingNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+    def type: () -> :source_encoding_node
+            | ...
+    def self.type: () -> :source_encoding_node
+  end
+
+  # Represents the use of the `__FILE__` keyword.
+  #
+  #     __FILE__
+  #     ^^^^^^^^
+  class SourceFileNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader filepath: String
+
+    def initialize: (Source source, Integer flags, String filepath, Location location) -> void
+    def copy: (?flags: Integer, ?filepath: String, ?location: Location) -> SourceFileNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, filepath: String, location: Location }
+    def forced_utf8_encoding?: () -> bool
+    def forced_binary_encoding?: () -> bool
+    def frozen?: () -> bool
+    def mutable?: () -> bool
+    def type: () -> :source_file_node
+            | ...
+    def self.type: () -> :source_file_node
+  end
+
+  # Represents the use of the `__LINE__` keyword.
+  #
+  #     __LINE__
+  #     ^^^^^^^^
+  class SourceLineNode < Node
+    include _Node
+
+
+    def initialize: (Source source, Location location) -> void
+    def copy: (?location: Location) -> SourceLineNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+    def type: () -> :source_line_node
+            | ...
+    def self.type: () -> :source_line_node
+  end
+
+  # Represents the use of the splat operator.
+  #
+  #     [*a]
+  #      ^^
+  class SplatNode < Node
+    include _Node
+
+    attr_reader operator_loc: Location
+    attr_reader expression: Prism::node?
+
+    def initialize: (Source source, Location operator_loc, Prism::node? expression, Location location) -> void
+    def copy: (?operator_loc: Location, ?expression: Prism::node?, ?location: Location) -> SplatNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { operator_loc: Location, expression: Prism::node?, location: Location }
+    def operator: () -> String
+    def type: () -> :splat_node
+            | ...
+    def self.type: () -> :splat_node
+  end
+
+  # Represents a set of statements contained within some scope.
+  #
+  #     foo; bar; baz
+  #     ^^^^^^^^^^^^^
+  class StatementsNode < Node
+    include _Node
+
+    attr_reader body: Array[Prism::node]
+
+    def initialize: (Source source, Array[Prism::node] body, Location location) -> void
+    def copy: (?body: Array[Prism::node], ?location: Location) -> StatementsNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { body: Array[Prism::node], location: Location }
+    def type: () -> :statements_node
+            | ...
+    def self.type: () -> :statements_node
+  end
+
+  # Represents a string literal, a string contained within a `%w` list, or plain string content within an interpolated string.
+  #
+  #     "foo"
+  #     ^^^^^
+  #
+  #     %w[foo]
+  #        ^^^
+  #
+  #     "foo #{bar} baz"
+  #      ^^^^      ^^^^
+  class StringNode < Node
+    include _Node
+
+    private 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: (Source source, Integer flags, Location? opening_loc, Location content_loc, Location? closing_loc, String unescaped, Location location) -> void
+    def copy: (?flags: Integer, ?opening_loc: Location?, ?content_loc: Location, ?closing_loc: Location?, ?unescaped: String, ?location: Location) -> StringNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location?, content_loc: Location, closing_loc: Location?, unescaped: String, location: Location }
+    def forced_utf8_encoding?: () -> bool
+    def forced_binary_encoding?: () -> bool
+    def frozen?: () -> bool
+    def mutable?: () -> bool
+    def opening: () -> String?
+    def content: () -> String
+    def closing: () -> String?
+    def type: () -> :string_node
+            | ...
+    def self.type: () -> :string_node
+  end
+
+  # Represents the use of the `super` keyword with parentheses or arguments.
+  #
+  #     super()
+  #     ^^^^^^^
+  #
+  #     super foo, bar
+  #     ^^^^^^^^^^^^^^
+  class SuperNode < Node
+    include _Node
+
+    attr_reader keyword_loc: Location
+    attr_reader lparen_loc: Location?
+    attr_reader arguments: ArgumentsNode?
+    attr_reader rparen_loc: Location?
+    attr_reader block: Prism::node?
+
+    def initialize: (Source source, Location keyword_loc, Location? lparen_loc, ArgumentsNode? arguments, Location? rparen_loc, Prism::node? block, Location location) -> void
+    def copy: (?keyword_loc: Location, ?lparen_loc: Location?, ?arguments: ArgumentsNode?, ?rparen_loc: Location?, ?block: Prism::node?, ?location: Location) -> SuperNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, block: Prism::node?, location: Location }
+    def keyword: () -> String
+    def lparen: () -> String?
+    def rparen: () -> String?
+    def type: () -> :super_node
+            | ...
+    def self.type: () -> :super_node
+  end
+
+  # Represents a symbol literal or a symbol contained within a `%i` list.
+  #
+  #     :foo
+  #     ^^^^
+  #
+  #     %i[foo]
+  #        ^^^
+  class SymbolNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader opening_loc: Location?
+    attr_reader value_loc: Location?
+    attr_reader closing_loc: Location?
+    attr_reader unescaped: String
+
+    def initialize: (Source source, Integer flags, Location? opening_loc, Location? value_loc, Location? closing_loc, String unescaped, Location location) -> void
+    def copy: (?flags: Integer, ?opening_loc: Location?, ?value_loc: Location?, ?closing_loc: Location?, ?unescaped: String, ?location: Location) -> SymbolNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location?, value_loc: Location?, closing_loc: Location?, unescaped: String, location: Location }
+    def forced_utf8_encoding?: () -> bool
+    def forced_binary_encoding?: () -> bool
+    def forced_us_ascii_encoding?: () -> bool
+    def opening: () -> String?
+    def value: () -> String?
+    def closing: () -> String?
+    def type: () -> :symbol_node
+            | ...
+    def self.type: () -> :symbol_node
+  end
+
+  # Represents the use of the literal `true` keyword.
+  #
+  #     true
+  #     ^^^^
+  class TrueNode < Node
+    include _Node
+
+
+    def initialize: (Source source, Location location) -> void
+    def copy: (?location: Location) -> TrueNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { location: Location }
+    def type: () -> :true_node
+            | ...
+    def self.type: () -> :true_node
+  end
+
+  # Represents the use of the `undef` keyword.
+  #
+  #     undef :foo, :bar, :baz
+  #     ^^^^^^^^^^^^^^^^^^^^^^
+  class UndefNode < Node
+    include _Node
+
+    attr_reader names: Array[SymbolNode | InterpolatedSymbolNode]
+    attr_reader keyword_loc: Location
+
+    def initialize: (Source source, Array[SymbolNode | InterpolatedSymbolNode] names, Location keyword_loc, Location location) -> void
+    def copy: (?names: Array[SymbolNode | InterpolatedSymbolNode], ?keyword_loc: Location, ?location: Location) -> UndefNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { names: Array[SymbolNode | InterpolatedSymbolNode], keyword_loc: Location, location: Location }
+    def keyword: () -> String
+    def type: () -> :undef_node
+            | ...
+    def self.type: () -> :undef_node
+  end
+
+  # Represents the use of the `unless` keyword, either in the block form or the modifier form.
+  #
+  #     bar unless foo
+  #     ^^^^^^^^^^^^^^
+  #
+  #     unless foo then bar end
+  #     ^^^^^^^^^^^^^^^^^^^^^^^
+  class UnlessNode < Node
+    include _Node
+
+    attr_reader keyword_loc: Location
+    attr_reader predicate: Prism::node
+    attr_reader then_keyword_loc: Location?
+    attr_reader statements: StatementsNode?
+    attr_reader consequent: ElseNode?
+    attr_reader end_keyword_loc: Location?
+
+    def initialize: (Source source, Location keyword_loc, Prism::node predicate, Location? then_keyword_loc, StatementsNode? statements, ElseNode? consequent, Location? end_keyword_loc, Location location) -> void
+    def copy: (?keyword_loc: Location, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?consequent: ElseNode?, ?end_keyword_loc: Location?, ?location: Location) -> UnlessNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, predicate: Prism::node, then_keyword_loc: Location?, statements: StatementsNode?, consequent: ElseNode?, end_keyword_loc: Location?, location: Location }
+    def keyword: () -> String
+    def then_keyword: () -> String?
+    def end_keyword: () -> String?
+    def type: () -> :unless_node
+            | ...
+    def self.type: () -> :unless_node
+  end
+
+  # Represents the use of the `until` keyword, either in the block form or the modifier form.
+  #
+  #     bar until foo
+  #     ^^^^^^^^^^^^^
+  #
+  #     until foo do bar end
+  #     ^^^^^^^^^^^^^^^^^^^^
+  class UntilNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader keyword_loc: Location
+    attr_reader closing_loc: Location?
+    attr_reader predicate: Prism::node
+    attr_reader statements: StatementsNode?
+
+    def initialize: (Source source, Integer flags, Location keyword_loc, Location? closing_loc, Prism::node predicate, StatementsNode? statements, Location location) -> void
+    def copy: (?flags: Integer, ?keyword_loc: Location, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?, ?location: Location) -> UntilNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, keyword_loc: Location, closing_loc: Location?, predicate: Prism::node, statements: StatementsNode?, location: Location }
+    def begin_modifier?: () -> bool
+    def keyword: () -> String
+    def closing: () -> String?
+    def type: () -> :until_node
+            | ...
+    def self.type: () -> :until_node
+  end
+
+  # Represents the use of the `when` keyword within a case statement.
+  #
+  #     case true
+  #     when true
+  #     ^^^^^^^^^
+  #     end
+  class WhenNode < Node
+    include _Node
+
+    attr_reader keyword_loc: Location
+    attr_reader conditions: Array[Prism::node]
+    attr_reader then_keyword_loc: Location?
+    attr_reader statements: StatementsNode?
+
+    def initialize: (Source source, Location keyword_loc, Array[Prism::node] conditions, Location? then_keyword_loc, StatementsNode? statements, Location location) -> void
+    def copy: (?keyword_loc: Location, ?conditions: Array[Prism::node], ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?location: Location) -> WhenNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, conditions: Array[Prism::node], then_keyword_loc: Location?, statements: StatementsNode?, location: Location }
+    def keyword: () -> String
+    def then_keyword: () -> String?
+    def type: () -> :when_node
+            | ...
+    def self.type: () -> :when_node
+  end
+
+  # Represents the use of the `while` keyword, either in the block form or the modifier form.
+  #
+  #     bar while foo
+  #     ^^^^^^^^^^^^^
+  #
+  #     while foo do bar end
+  #     ^^^^^^^^^^^^^^^^^^^^
+  class WhileNode < Node
+    include _Node
+
+    private attr_reader flags: Integer
+    attr_reader keyword_loc: Location
+    attr_reader closing_loc: Location?
+    attr_reader predicate: Prism::node
+    attr_reader statements: StatementsNode?
+
+    def initialize: (Source source, Integer flags, Location keyword_loc, Location? closing_loc, Prism::node predicate, StatementsNode? statements, Location location) -> void
+    def copy: (?flags: Integer, ?keyword_loc: Location, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?, ?location: Location) -> WhileNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, keyword_loc: Location, closing_loc: Location?, predicate: Prism::node, statements: StatementsNode?, location: Location }
+    def begin_modifier?: () -> bool
+    def keyword: () -> String
+    def closing: () -> String?
+    def type: () -> :while_node
+            | ...
+    def self.type: () -> :while_node
+  end
+
+  # Represents an xstring literal with no interpolation.
+  #
+  #     `foo`
+  #     ^^^^^
+  class XStringNode < Node
+    include _Node
+
+    private 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: (Source source, Integer flags, Location opening_loc, Location content_loc, Location closing_loc, String unescaped, Location location) -> void
+    def copy: (?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String, ?location: Location) -> XStringNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String, location: Location }
+    def forced_utf8_encoding?: () -> bool
+    def forced_binary_encoding?: () -> bool
+    def opening: () -> String
+    def content: () -> String
+    def closing: () -> String
+    def type: () -> :x_string_node
+            | ...
+    def self.type: () -> :x_string_node
+  end
+
+  # Represents the use of the `yield` keyword.
+  #
+  #     yield 1
+  #     ^^^^^^^
+  class YieldNode < Node
+    include _Node
+
+    attr_reader keyword_loc: Location
+    attr_reader lparen_loc: Location?
+    attr_reader arguments: ArgumentsNode?
+    attr_reader rparen_loc: Location?
+
+    def initialize: (Source source, Location keyword_loc, Location? lparen_loc, ArgumentsNode? arguments, Location? rparen_loc, Location location) -> void
+    def copy: (?keyword_loc: Location, ?lparen_loc: Location?, ?arguments: ArgumentsNode?, ?rparen_loc: Location?, ?location: Location) -> YieldNode
+    def deconstruct_keys: (Array[Symbol] keys) -> { keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, location: Location }
+    def keyword: () -> String
+    def lparen: () -> String?
+    def rparen: () -> String?
+    def type: () -> :yield_node
+            | ...
+    def self.type: () -> :yield_node
+  end
+
+  # Flags for arguments nodes.
+  module ArgumentsNodeFlags
+    # if arguments contain keyword splat
+    CONTAINS_KEYWORD_SPLAT: Integer
+  end
+
+  # Flags for array nodes.
+  module ArrayNodeFlags
+    # if array contains splat nodes
+    CONTAINS_SPLAT: Integer
+  end
+
+  # Flags for call nodes.
+  module CallNodeFlags
+    # &. operator
+    SAFE_NAVIGATION: Integer
+    # a call that could have been a local variable
+    VARIABLE_CALL: Integer
+    # a call that is an attribute write, so the value being written should be returned
+    ATTRIBUTE_WRITE: Integer
+    # a call that ignores method visibility
+    IGNORE_VISIBILITY: Integer
+  end
+
+  # Flags for nodes that have unescaped content.
+  module EncodingFlags
+    # internal bytes forced the encoding to UTF-8
+    FORCED_UTF8_ENCODING: Integer
+    # internal bytes forced the encoding to binary
+    FORCED_BINARY_ENCODING: Integer
+  end
+
+  # Flags for integer nodes that correspond to the base of the integer.
+  module IntegerBaseFlags
+    # 0b prefix
+    BINARY: Integer
+    # 0d or no prefix
+    DECIMAL: Integer
+    # 0o or 0 prefix
+    OCTAL: Integer
+    # 0x prefix
+    HEXADECIMAL: Integer
+  end
+
+  # Flags for interpolated string nodes that indicated mutability if they are also marked as literals.
+  module InterpolatedStringNodeFlags
+    # frozen by virtue of a `frozen_string_literal: true` comment or `--enable-frozen-string-literal`; only for adjacent string literals like `'a' 'b'`
+    FROZEN: Integer
+    # mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal`; only for adjacent string literals like `'a' 'b'`
+    MUTABLE: Integer
+  end
+
+  # Flags for keyword hash nodes.
+  module KeywordHashNodeFlags
+    # a keyword hash which only has `AssocNode` elements all with symbol keys, which means the elements can be treated as keyword arguments
+    SYMBOL_KEYS: Integer
+  end
+
+  # Flags for while and until loop nodes.
+  module LoopFlags
+    # a loop after a begin statement, so the body is executed first before the condition
+    BEGIN_MODIFIER: Integer
+  end
+
+  # Flags for parameter nodes.
+  module ParameterFlags
+    # a parameter name that has been repeated in the method signature
+    REPEATED_PARAMETER: Integer
+  end
+
+  # Flags for range and flip-flop nodes.
+  module RangeFlags
+    # ... operator
+    EXCLUDE_END: Integer
+  end
+
+  # Flags for regular expression and match last line nodes.
+  module RegularExpressionFlags
+    # i - ignores the case of characters when matching
+    IGNORE_CASE: Integer
+    # x - ignores whitespace and allows comments in regular expressions
+    EXTENDED: Integer
+    # m - allows $ to match the end of lines within strings
+    MULTI_LINE: Integer
+    # o - only interpolates values into the regular expression once
+    ONCE: Integer
+    # e - forces the EUC-JP encoding
+    EUC_JP: Integer
+    # n - forces the ASCII-8BIT encoding
+    ASCII_8BIT: Integer
+    # s - forces the Windows-31J encoding
+    WINDOWS_31J: Integer
+    # u - forces the UTF-8 encoding
+    UTF_8: Integer
+    # internal bytes forced the encoding to UTF-8
+    FORCED_UTF8_ENCODING: Integer
+    # internal bytes forced the encoding to binary
+    FORCED_BINARY_ENCODING: Integer
+    # internal bytes forced the encoding to US-ASCII
+    FORCED_US_ASCII_ENCODING: Integer
+  end
+
+  # Flags for shareable constant nodes.
+  module ShareableConstantNodeFlags
+    # constant writes that should be modified with shareable constant value literal
+    LITERAL: Integer
+    # constant writes that should be modified with shareable constant value experimental everything
+    EXPERIMENTAL_EVERYTHING: Integer
+    # constant writes that should be modified with shareable constant value experimental copy
+    EXPERIMENTAL_COPY: Integer
+  end
+
+  # Flags for string nodes.
+  module StringFlags
+    # internal bytes forced the encoding to UTF-8
+    FORCED_UTF8_ENCODING: Integer
+    # internal bytes forced the encoding to binary
+    FORCED_BINARY_ENCODING: Integer
+    # frozen by virtue of a `frozen_string_literal: true` comment or `--enable-frozen-string-literal`
+    FROZEN: Integer
+    # mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal`
+    MUTABLE: Integer
+  end
+
+  # Flags for symbol nodes.
+  module SymbolFlags
+    # internal bytes forced the encoding to UTF-8
+    FORCED_UTF8_ENCODING: Integer
+    # internal bytes forced the encoding to binary
+    FORCED_BINARY_ENCODING: Integer
+    # internal bytes forced the encoding to US-ASCII
+    FORCED_US_ASCII_ENCODING: Integer
+  end
+end