# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `rubocop-ast` gem.
# Please instead update this file by running `tapioca generate --exclude json`.

# typed: true

module RuboCop
end

module RuboCop::AST
end

class RuboCop::AST::AliasNode < ::RuboCop::AST::Node
  def new_identifier; end
  def old_identifier; end
end

class RuboCop::AST::AndNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::BinaryOperatorNode)
  include(::RuboCop::AST::PredicateOperatorNode)

  def alternate_operator; end
  def inverse_operator; end
end

class RuboCop::AST::ArgsNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::CollectionNode)

  def empty_and_without_delimiters?; end
end

class RuboCop::AST::ArrayNode < ::RuboCop::AST::Node
  def bracketed?; end
  def each_value(&block); end
  def percent_literal?(type = T.unsafe(nil)); end
  def square_brackets?; end
  def values; end
end

RuboCop::AST::ArrayNode::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), Hash)

module RuboCop::AST::BasicLiteralNode
  def value; end
end

module RuboCop::AST::BinaryOperatorNode
  def conditions; end
  def lhs; end
  def rhs; end
end

class RuboCop::AST::BlockNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::MethodIdentifierPredicates)

  def arguments; end
  def arguments?; end
  def body; end
  def braces?; end
  def closing_delimiter; end
  def delimiters; end
  def keywords?; end
  def lambda?; end
  def method_name; end
  def multiline?; end
  def opening_delimiter; end
  def send_node; end
  def single_line?; end
  def void_context?; end
end

RuboCop::AST::BlockNode::VOID_CONTEXT_METHODS = T.let(T.unsafe(nil), Array)

class RuboCop::AST::BreakNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::ParameterizedNode)
  include(::RuboCop::AST::ParameterizedNode::WrappedArguments)
end

class RuboCop::AST::Builder < ::Parser::Builders::Default
  def n(type, children, source_map); end
  def string_value(token); end

  private

  def node_klass(type); end
end

RuboCop::AST::Builder::NODE_MAP = T.let(T.unsafe(nil), Hash)

class RuboCop::AST::CaseMatchNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::ConditionalNode)

  def each_in_pattern(&block); end
  def else?; end
  def else_branch; end
  def in_pattern_branches; end
  def keyword; end
end

class RuboCop::AST::CaseNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::ConditionalNode)

  def branches; end
  def each_when(&block); end
  def else?; end
  def else_branch; end
  def keyword; end
  def when_branches; end
end

class RuboCop::AST::ClassNode < ::RuboCop::AST::Node
  def body; end
  def identifier; end
  def parent_class; end
end

module RuboCop::AST::CollectionNode
  extend(::Forwardable)

  def &(*args, &block); end
  def *(*args, &block); end
  def +(*args, &block); end
  def -(*args, &block); end
  def <<(*args, &block); end
  def [](*args, &block); end
  def []=(*args, &block); end
  def all?(*args, &block); end
  def any?(*args, &block); end
  def append(*args, &block); end
  def assoc(*args, &block); end
  def at(*args, &block); end
  def bsearch(*args, &block); end
  def bsearch_index(*args, &block); end
  def chain(*args, &block); end
  def chunk(*args, &block); end
  def chunk_while(*args, &block); end
  def clear(*args, &block); end
  def collect(*args, &block); end
  def collect!(*args, &block); end
  def collect_concat(*args, &block); end
  def combination(*args, &block); end
  def compact(*args, &block); end
  def compact!(*args, &block); end
  def concat(*args, &block); end
  def count(*args, &block); end
  def cycle(*args, &block); end
  def delete(*args, &block); end
  def delete_at(*args, &block); end
  def delete_if(*args, &block); end
  def detect(*args, &block); end
  def difference(*args, &block); end
  def dig(*args, &block); end
  def drop(*args, &block); end
  def drop_while(*args, &block); end
  def each(*args, &block); end
  def each_cons(*args, &block); end
  def each_entry(*args, &block); end
  def each_index(*args, &block); end
  def each_slice(*args, &block); end
  def each_with_index(*args, &block); end
  def each_with_object(*args, &block); end
  def empty?(*args, &block); end
  def entries(*args, &block); end
  def fetch(*args, &block); end
  def fill(*args, &block); end
  def filter(*args, &block); end
  def filter!(*args, &block); end
  def find(*args, &block); end
  def find_all(*args, &block); end
  def find_index(*args, &block); end
  def first(*args, &block); end
  def flat_map(*args, &block); end
  def flatten(*args, &block); end
  def flatten!(*args, &block); end
  def grep(*args, &block); end
  def grep_v(*args, &block); end
  def group_by(*args, &block); end
  def include?(*args, &block); end
  def index(*args, &block); end
  def inject(*args, &block); end
  def insert(*args, &block); end
  def join(*args, &block); end
  def keep_if(*args, &block); end
  def last(*args, &block); end
  def lazy(*args, &block); end
  def length(*args, &block); end
  def map(*args, &block); end
  def map!(*args, &block); end
  def max(*args, &block); end
  def max_by(*args, &block); end
  def member?(*args, &block); end
  def min(*args, &block); end
  def min_by(*args, &block); end
  def minmax(*args, &block); end
  def minmax_by(*args, &block); end
  def none?(*args, &block); end
  def one?(*args, &block); end
  def pack(*args, &block); end
  def partition(*args, &block); end
  def permutation(*args, &block); end
  def pop(*args, &block); end
  def prepend(*args, &block); end
  def product(*args, &block); end
  def push(*args, &block); end
  def rassoc(*args, &block); end
  def reduce(*args, &block); end
  def reject(*args, &block); end
  def reject!(*args, &block); end
  def repeated_combination(*args, &block); end
  def repeated_permutation(*args, &block); end
  def replace(*args, &block); end
  def reverse(*args, &block); end
  def reverse!(*args, &block); end
  def reverse_each(*args, &block); end
  def rindex(*args, &block); end
  def rotate(*args, &block); end
  def rotate!(*args, &block); end
  def sample(*args, &block); end
  def select(*args, &block); end
  def select!(*args, &block); end
  def shelljoin(*args, &block); end
  def shift(*args, &block); end
  def shuffle(*args, &block); end
  def shuffle!(*args, &block); end
  def size(*args, &block); end
  def slice(*args, &block); end
  def slice!(*args, &block); end
  def slice_after(*args, &block); end
  def slice_before(*args, &block); end
  def slice_when(*args, &block); end
  def sort(*args, &block); end
  def sort!(*args, &block); end
  def sort_by(*args, &block); end
  def sort_by!(*args, &block); end
  def sum(*args, &block); end
  def take(*args, &block); end
  def take_while(*args, &block); end
  def to_ary(*args, &block); end
  def to_h(*args, &block); end
  def to_set(*args, &block); end
  def transpose(*args, &block); end
  def union(*args, &block); end
  def uniq(*args, &block); end
  def uniq!(*args, &block); end
  def unshift(*args, &block); end
  def values_at(*args, &block); end
  def zip(*args, &block); end
  def |(*args, &block); end
end

RuboCop::AST::CollectionNode::ARRAY_METHODS = T.let(T.unsafe(nil), Array)

module RuboCop::AST::ConditionalNode
  def body; end
  def condition; end
  def multiline_condition?; end
  def single_line_condition?; end
end

class RuboCop::AST::DefNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::ParameterizedNode)
  include(::RuboCop::AST::MethodIdentifierPredicates)

  def argument_forwarding?; end
  def arguments; end
  def body; end
  def method_name; end
  def receiver; end
  def void_context?; end
end

class RuboCop::AST::DefinedNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::ParameterizedNode)
  include(::RuboCop::AST::MethodIdentifierPredicates)
  include(::RuboCop::AST::MethodDispatchNode)

  def arguments; end
  def node_parts; end
end

class RuboCop::AST::EnsureNode < ::RuboCop::AST::Node
  def body; end
end

module RuboCop::AST::Ext
end

module RuboCop::AST::Ext::Range
  def line_span(exclude_end: T.unsafe(nil)); end
end

class RuboCop::AST::FloatNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::BasicLiteralNode)
  include(::RuboCop::AST::NumericNode)
end

class RuboCop::AST::ForNode < ::RuboCop::AST::Node
  def body; end
  def collection; end
  def do?; end
  def keyword; end
  def variable; end
  def void_context?; end
end

class RuboCop::AST::ForwardArgsNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::CollectionNode)

  def to_a; end
end

module RuboCop::AST::HashElementNode
  def delimiter_delta(other); end
  def key; end
  def key_delta(other, alignment = T.unsafe(nil)); end
  def same_line?(other); end
  def value; end
  def value_delta(other); end
end

class RuboCop::AST::HashNode < ::RuboCop::AST::Node
  def braces?; end
  def each_key(&block); end
  def each_pair; end
  def each_value(&block); end
  def empty?; end
  def keys; end
  def mixed_delimiters?; end
  def pairs; end
  def pairs_on_same_line?; end
  def values; end
end

class RuboCop::AST::IfNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::ConditionalNode)
  include(::RuboCop::AST::ModifierNode)

  def branches; end
  def each_branch(&block); end
  def else?; end
  def else_branch; end
  def elsif?; end
  def elsif_conditional?; end
  def if?; end
  def if_branch; end
  def inverse_keyword; end
  def keyword; end
  def modifier_form?; end
  def nested_conditional?; end
  def node_parts; end
  def ternary?; end
  def unless?; end
end

class RuboCop::AST::IndexNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::ParameterizedNode)
  include(::RuboCop::AST::ParameterizedNode::RestArguments)
  include(::RuboCop::AST::MethodIdentifierPredicates)
  include(::RuboCop::AST::MethodDispatchNode)

  def assignment_method?; end
  def attribute_accessor?; end
  def method_name; end

  private

  def first_argument_index; end
end

class RuboCop::AST::IndexasgnNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::ParameterizedNode)
  include(::RuboCop::AST::ParameterizedNode::RestArguments)
  include(::RuboCop::AST::MethodIdentifierPredicates)
  include(::RuboCop::AST::MethodDispatchNode)

  def assignment_method?; end
  def attribute_accessor?; end
  def method_name; end

  private

  def first_argument_index; end
end

class RuboCop::AST::IntNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::BasicLiteralNode)
  include(::RuboCop::AST::NumericNode)
end

class RuboCop::AST::KeywordSplatNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::HashElementNode)

  def colon?; end
  def hash_rocket?; end
  def node_parts; end
  def operator; end
end

RuboCop::AST::KeywordSplatNode::DOUBLE_SPLAT = T.let(T.unsafe(nil), String)

class RuboCop::AST::LambdaNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::ParameterizedNode)
  include(::RuboCop::AST::ParameterizedNode::RestArguments)
  include(::RuboCop::AST::MethodIdentifierPredicates)
  include(::RuboCop::AST::MethodDispatchNode)

  def assignment_method?; end
  def attribute_accessor?; end
  def lambda?; end
  def lambda_literal?; end
  def method_name; end
  def receiver; end

  private

  def first_argument_index; end
end

module RuboCop::AST::MethodDispatchNode
  include(::RuboCop::AST::MethodIdentifierPredicates)
  extend(::RuboCop::AST::NodePattern::Macros)

  def access_modifier?; end
  def adjacent_def_modifier?(node = T.unsafe(nil)); end
  def arithmetic_operation?; end
  def assignment?; end
  def bare_access_modifier?; end
  def bare_access_modifier_declaration?(node = T.unsafe(nil)); end
  def binary_operation?; end
  def block_literal?; end
  def block_node; end
  def command?(name); end
  def const_receiver?; end
  def def_modifier?; end
  def dot?; end
  def double_colon?; end
  def implicit_call?; end
  def lambda?; end
  def lambda_literal?; end
  def macro?; end
  def macro_scope?(node = T.unsafe(nil)); end
  def method_name; end
  def non_bare_access_modifier?; end
  def non_bare_access_modifier_declaration?(node = T.unsafe(nil)); end
  def receiver; end
  def safe_navigation?; end
  def self_receiver?; end
  def setter_method?; end
  def special_modifier?; end
  def unary_operation?; end

  private

  def macro_kwbegin_wrapper?(parent); end
  def root_node?(node); end
end

RuboCop::AST::MethodDispatchNode::ARITHMETIC_OPERATORS = T.let(T.unsafe(nil), Array)

RuboCop::AST::MethodDispatchNode::SPECIAL_MODIFIERS = T.let(T.unsafe(nil), Array)

module RuboCop::AST::MethodIdentifierPredicates
  def assignment_method?; end
  def bang_method?; end
  def camel_case_method?; end
  def comparison_method?; end
  def const_receiver?; end
  def enumerable_method?; end
  def enumerator_method?; end
  def method?(name); end
  def negation_method?; end
  def nonmutating_array_method?; end
  def nonmutating_binary_operator_method?; end
  def nonmutating_hash_method?; end
  def nonmutating_operator_method?; end
  def nonmutating_string_method?; end
  def nonmutating_unary_operator_method?; end
  def operator_method?; end
  def predicate_method?; end
  def prefix_bang?; end
  def prefix_not?; end
  def self_receiver?; end
end

RuboCop::AST::MethodIdentifierPredicates::ENUMERABLE_METHODS = T.let(T.unsafe(nil), Set)

RuboCop::AST::MethodIdentifierPredicates::ENUMERATOR_METHODS = T.let(T.unsafe(nil), Set)

RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_ARRAY_METHODS = T.let(T.unsafe(nil), Set)

RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_BINARY_OPERATOR_METHODS = T.let(T.unsafe(nil), Set)

RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_HASH_METHODS = T.let(T.unsafe(nil), Set)

RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_OPERATOR_METHODS = T.let(T.unsafe(nil), Set)

RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_STRING_METHODS = T.let(T.unsafe(nil), Set)

RuboCop::AST::MethodIdentifierPredicates::NONMUTATING_UNARY_OPERATOR_METHODS = T.let(T.unsafe(nil), Set)

RuboCop::AST::MethodIdentifierPredicates::OPERATOR_METHODS = T.let(T.unsafe(nil), Set)

module RuboCop::AST::ModifierNode
  def modifier_form?; end
end

class RuboCop::AST::ModuleNode < ::RuboCop::AST::Node
  def body; end
  def identifier; end
end

class RuboCop::AST::NextNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::ParameterizedNode)
  include(::RuboCop::AST::ParameterizedNode::WrappedArguments)
end

class RuboCop::AST::Node < ::Parser::AST::Node
  include(::RuboCop::AST::Sexp)
  include(::RuboCop::RSpec::Node)
  extend(::RuboCop::AST::NodePattern::Macros)

  def initialize(type, children = T.unsafe(nil), properties = T.unsafe(nil)); end

  def __ENCODING___type?; end
  def __FILE___type?; end
  def __LINE___type?; end
  def alias_type?; end
  def ancestors; end
  def and_asgn_type?; end
  def and_type?; end
  def arg_expr_type?; end
  def arg_type?; end
  def args_type?; end
  def argument?; end
  def argument_type?; end
  def array_pattern_type?; end
  def array_pattern_with_tail_type?; end
  def array_type?; end
  def assignment?; end
  def assignment_or_similar?(node = T.unsafe(nil)); end
  def back_ref_type?; end
  def basic_conditional?; end
  def basic_literal?; end
  def begin_type?; end
  def block_pass_type?; end
  def block_type?; end
  def blockarg_expr_type?; end
  def blockarg_type?; end
  def boolean_type?; end
  def break_type?; end
  def call_type?; end
  def case_match_type?; end
  def case_type?; end
  def casgn_type?; end
  def cbase_type?; end
  def chained?; end
  def child_nodes; end
  def class_constructor?(node = T.unsafe(nil)); end
  def class_definition?(node = T.unsafe(nil)); end
  def class_type?; end
  def complete!; end
  def complete?; end
  def complex_type?; end
  def conditional?; end
  def const_name; end
  def const_pattern_type?; end
  def const_type?; end
  def csend_type?; end
  def cvar_type?; end
  def cvasgn_type?; end
  def def_e_type?; end
  def def_type?; end
  def defined_module; end
  def defined_module_name; end
  def defined_type?; end
  def defs_e_type?; end
  def defs_type?; end
  def descendants; end
  def dstr_type?; end
  def dsym_type?; end
  def each_ancestor(*types, &block); end
  def each_child_node(*types); end
  def each_descendant(*types, &block); end
  def each_node(*types, &block); end
  def eflipflop_type?; end
  def empty_else_type?; end
  def empty_source?; end
  def ensure_type?; end
  def equals_asgn?; end
  def erange_type?; end
  def false_type?; end
  def falsey_literal?; end
  def find_pattern_type?; end
  def first_line; end
  def float_type?; end
  def for_type?; end
  def forward_arg_type?; end
  def forward_args_type?; end
  def forwarded_args_type?; end
  def global_const?(node = T.unsafe(nil), param1); end
  def guard_clause?; end
  def gvar_type?; end
  def gvasgn_type?; end
  def hash_pattern_type?; end
  def hash_type?; end
  def ident_type?; end
  def if_guard_type?; end
  def if_type?; end
  def iflipflop_type?; end
  def immutable_literal?; end
  def in_match_type?; end
  def in_pattern_type?; end
  def index_type?; end
  def indexasgn_type?; end
  def int_type?; end
  def irange_type?; end
  def ivar_type?; end
  def ivasgn_type?; end
  def keyword?; end
  def kwarg_type?; end
  def kwbegin_type?; end
  def kwnilarg_type?; end
  def kwoptarg_type?; end
  def kwrestarg_type?; end
  def kwsplat_type?; end
  def lambda?(node = T.unsafe(nil)); end
  def lambda_or_proc?(node = T.unsafe(nil)); end
  def lambda_type?; end
  def last_line; end
  def line_count; end
  def literal?; end
  def loop_keyword?; end
  def lvar_type?; end
  def lvasgn_type?; end
  def masgn_type?; end
  def match_alt_type?; end
  def match_as_type?; end
  def match_current_line_type?; end
  def match_guard_clause?(node = T.unsafe(nil)); end
  def match_nil_pattern_type?; end
  def match_rest_type?; end
  def match_var_type?; end
  def match_with_lvasgn_type?; end
  def match_with_trailing_comma_type?; end
  def mlhs_type?; end
  def module_definition?(node = T.unsafe(nil)); end
  def module_type?; end
  def mrasgn_type?; end
  def multiline?; end
  def mutable_literal?; end
  def new_class_or_module_block?(node = T.unsafe(nil)); end
  def next_type?; end
  def nil_type?; end
  def node_parts; end
  def nonempty_line_count; end
  def not_type?; end
  def nth_ref_type?; end
  def numargs_type?; end
  def numblock_type?; end
  def numeric_type?; end
  def objc_kwarg_type?; end
  def objc_restarg_type?; end
  def objc_varargs_type?; end
  def op_asgn_type?; end
  def operator_keyword?; end
  def optarg_type?; end
  def or_asgn_type?; end
  def or_type?; end
  def pair_type?; end
  def parent; end
  def parent_module_name; end
  def parenthesized_call?; end
  def pin_type?; end
  def post_condition_loop?; end
  def postexe_type?; end
  def preexe_type?; end
  def proc?(node = T.unsafe(nil)); end
  def procarg0_type?; end
  def pure?; end
  def range_type?; end
  def rasgn_type?; end
  def rational_type?; end
  def receiver(node = T.unsafe(nil)); end
  def recursive_basic_literal?; end
  def recursive_literal?; end
  def redo_type?; end
  def reference?; end
  def regexp_type?; end
  def regopt_type?; end
  def resbody_type?; end
  def rescue_type?; end
  def restarg_expr_type?; end
  def restarg_type?; end
  def retry_type?; end
  def return_type?; end
  def root_type?; end
  def sclass_type?; end
  def self_type?; end
  def send_type?; end
  def shadowarg_type?; end
  def shorthand_asgn?; end
  def sibling_index; end
  def single_line?; end
  def source; end
  def source_length; end
  def source_range; end
  def special_keyword?; end
  def splat_type?; end
  def str_content(node = T.unsafe(nil)); end
  def str_type?; end
  def struct_constructor?(node = T.unsafe(nil)); end
  def super_type?; end
  def sym_type?; end
  def true_type?; end
  def truthy_literal?; end
  def undef_type?; end
  def unless_guard_type?; end
  def until_post_type?; end
  def until_type?; end
  def updated(type = T.unsafe(nil), children = T.unsafe(nil), properties = T.unsafe(nil)); end
  def value_used?; end
  def variable?; end
  def when_type?; end
  def while_post_type?; end
  def while_type?; end
  def xstr_type?; end
  def yield_type?; end
  def zsuper_type?; end

  protected

  def parent=(node); end
  def visit_descendants(types, &block); end

  private

  def begin_value_used?; end
  def case_if_value_used?; end
  def defined_module0(node = T.unsafe(nil)); end
  def for_value_used?; end
  def parent_module_name_for_block(ancestor); end
  def parent_module_name_for_sclass(sclass_node); end
  def parent_module_name_part(node); end
  def visit_ancestors(types); end
  def while_until_value_used?; end
end

RuboCop::AST::Node::ARGUMENT_TYPES = T.let(T.unsafe(nil), Array)

RuboCop::AST::Node::ASSIGNMENTS = T.let(T.unsafe(nil), Array)

RuboCop::AST::Node::BASIC_CONDITIONALS = T.let(T.unsafe(nil), Array)

RuboCop::AST::Node::BASIC_LITERALS = T.let(T.unsafe(nil), Array)

RuboCop::AST::Node::COMPARISON_OPERATORS = T.let(T.unsafe(nil), Array)

RuboCop::AST::Node::COMPOSITE_LITERALS = T.let(T.unsafe(nil), Array)

RuboCop::AST::Node::CONDITIONALS = T.let(T.unsafe(nil), Array)

RuboCop::AST::Node::EQUALS_ASSIGNMENTS = T.let(T.unsafe(nil), Array)

RuboCop::AST::Node::FALSEY_LITERALS = T.let(T.unsafe(nil), Array)

RuboCop::AST::Node::IMMUTABLE_LITERALS = T.let(T.unsafe(nil), Array)

RuboCop::AST::Node::KEYWORDS = T.let(T.unsafe(nil), Array)

RuboCop::AST::Node::LITERALS = T.let(T.unsafe(nil), Array)

RuboCop::AST::Node::LOOP_TYPES = T.let(T.unsafe(nil), Array)

RuboCop::AST::Node::MUTABLE_LITERALS = T.let(T.unsafe(nil), Array)

RuboCop::AST::Node::OPERATOR_KEYWORDS = T.let(T.unsafe(nil), Array)

RuboCop::AST::Node::POST_CONDITION_LOOP_TYPES = T.let(T.unsafe(nil), Array)

RuboCop::AST::Node::REFERENCES = T.let(T.unsafe(nil), Array)

RuboCop::AST::Node::SHORTHAND_ASSIGNMENTS = T.let(T.unsafe(nil), Array)

RuboCop::AST::Node::SPECIAL_KEYWORDS = T.let(T.unsafe(nil), Array)

RuboCop::AST::Node::TRUTHY_LITERALS = T.let(T.unsafe(nil), Array)

RuboCop::AST::Node::VARIABLES = T.let(T.unsafe(nil), Array)

class RuboCop::AST::NodePattern
  def initialize(str); end

  def ==(other); end
  def eql?(other); end
  def marshal_dump; end
  def marshal_load(pattern); end
  def match(*args, **rest); end
  def pattern; end
  def to_s; end

  class << self
    def descend(element, &block); end
  end
end

class RuboCop::AST::NodePattern::Invalid < ::StandardError
end

module RuboCop::AST::NodePattern::Macros
  def def_node_matcher(method_name, pattern_str, **keyword_defaults); end
  def def_node_search(method_name, pattern_str, **keyword_defaults); end
end

class RuboCop::AST::NodePattern::Matcher
  def initialize(&block); end

  def ===(compare); end
end

module RuboCop::AST::NumericNode
  def sign?; end
end

RuboCop::AST::NumericNode::SIGN_REGEX = T.let(T.unsafe(nil), Regexp)

class RuboCop::AST::OrNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::BinaryOperatorNode)
  include(::RuboCop::AST::PredicateOperatorNode)

  def alternate_operator; end
  def inverse_operator; end
end

class RuboCop::AST::PairNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::HashElementNode)

  def colon?; end
  def delimiter(*deprecated, with_spacing: T.unsafe(nil)); end
  def hash_rocket?; end
  def inverse_delimiter(*deprecated, with_spacing: T.unsafe(nil)); end
  def value_on_new_line?; end
end

RuboCop::AST::PairNode::COLON = T.let(T.unsafe(nil), String)

RuboCop::AST::PairNode::HASH_ROCKET = T.let(T.unsafe(nil), String)

RuboCop::AST::PairNode::SPACED_COLON = T.let(T.unsafe(nil), String)

RuboCop::AST::PairNode::SPACED_HASH_ROCKET = T.let(T.unsafe(nil), String)

module RuboCop::AST::ParameterizedNode
  def arguments?; end
  def block_argument?; end
  def first_argument; end
  def last_argument; end
  def parenthesized?; end
  def rest_argument?; end
  def splat_argument?; end
end

module RuboCop::AST::ParameterizedNode::RestArguments
  include(::RuboCop::AST::ParameterizedNode)

  def arguments; end
  def arguments?; end
  def first_argument; end
  def last_argument; end
end

module RuboCop::AST::ParameterizedNode::WrappedArguments
  include(::RuboCop::AST::ParameterizedNode)

  def arguments; end
end

module RuboCop::AST::PredicateOperatorNode
  def logical_operator?; end
  def operator; end
  def semantic_operator?; end
end

RuboCop::AST::PredicateOperatorNode::LOGICAL_AND = T.let(T.unsafe(nil), String)

RuboCop::AST::PredicateOperatorNode::LOGICAL_OR = T.let(T.unsafe(nil), String)

RuboCop::AST::PredicateOperatorNode::SEMANTIC_AND = T.let(T.unsafe(nil), String)

RuboCop::AST::PredicateOperatorNode::SEMANTIC_OR = T.let(T.unsafe(nil), String)

class RuboCop::AST::ProcessedSource
  include(::RuboCop::Ext::ProcessedSource)

  def initialize(source, ruby_version, path = T.unsafe(nil)); end

  def [](*args); end
  def ast; end
  def ast_with_comments; end
  def blank?; end
  def buffer; end
  def checksum; end
  def comment_at_line(line); end
  def commented?(source_range); end
  def comments; end
  def comments_before_line(line); end
  def contains_comment?(source_range); end
  def current_line(token); end
  def diagnostics; end
  def each_comment(&block); end
  def each_comment_in_lines(line_range); end
  def each_token(&block); end
  def file_path; end
  def find_comment(&block); end
  def find_token(&block); end
  def following_line(token); end
  def line_indentation(line_number); end
  def line_with_comment?(line); end
  def lines; end
  def parser_error; end
  def path; end
  def preceding_line(token); end
  def raw_source; end
  def ruby_version; end
  def start_with?(string); end
  def tokens; end
  def valid_syntax?; end

  private

  def comment_index; end
  def create_parser(ruby_version); end
  def parse(source, ruby_version); end
  def parser_class(ruby_version); end
  def tokenize(parser); end

  class << self
    def from_file(path, ruby_version); end
  end
end

RuboCop::AST::ProcessedSource::STRING_SOURCE_NAME = T.let(T.unsafe(nil), String)

class RuboCop::AST::RangeNode < ::RuboCop::AST::Node
  def begin; end
  def end; end
end

class RuboCop::AST::RegexpNode < ::RuboCop::AST::Node
  def content; end
  def delimiter?(char); end
  def delimiters; end
  def extended?; end
  def ignore_case?; end
  def interpolation?; end
  def multiline_mode?; end
  def no_encoding?; end
  def percent_r_literal?; end
  def regopt; end
  def single_interpolation?; end
  def slash_literal?; end
  def to_regexp; end

  private

  def regopt_include?(option); end
end

RuboCop::AST::RegexpNode::OPTIONS = T.let(T.unsafe(nil), Hash)

class RuboCop::AST::ResbodyNode < ::RuboCop::AST::Node
  def body; end
  def exception_variable; end
end

class RuboCop::AST::ReturnNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::ParameterizedNode)
  include(::RuboCop::AST::ParameterizedNode::WrappedArguments)
end

class RuboCop::AST::SelfClassNode < ::RuboCop::AST::Node
  def body; end
  def identifier; end
end

class RuboCop::AST::SendNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::ParameterizedNode)
  include(::RuboCop::AST::ParameterizedNode::RestArguments)
  include(::RuboCop::AST::MethodIdentifierPredicates)
  include(::RuboCop::AST::MethodDispatchNode)

  def attribute_accessor?(node = T.unsafe(nil)); end

  private

  def first_argument_index; end
end

module RuboCop::AST::Sexp
  def s(type, *children); end
end

class RuboCop::AST::StrNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::BasicLiteralNode)

  def heredoc?; end
end

class RuboCop::AST::SuperNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::ParameterizedNode)
  include(::RuboCop::AST::MethodIdentifierPredicates)
  include(::RuboCop::AST::MethodDispatchNode)

  def arguments; end
  def node_parts; end
end

class RuboCop::AST::SymbolNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::BasicLiteralNode)
end

class RuboCop::AST::Token
  def initialize(pos, type, text); end

  def begin_pos; end
  def column; end
  def comma?; end
  def comment?; end
  def end?; end
  def end_pos; end
  def equal_sign?; end
  def left_array_bracket?; end
  def left_brace?; end
  def left_bracket?; end
  def left_curly_brace?; end
  def left_parens?; end
  def left_ref_bracket?; end
  def line; end
  def pos; end
  def rescue_modifier?; end
  def right_bracket?; end
  def right_curly_brace?; end
  def right_parens?; end
  def semicolon?; end
  def space_after?; end
  def space_before?; end
  def text; end
  def to_s; end
  def type; end

  class << self
    def from_parser_token(parser_token); end
  end
end

module RuboCop::AST::Traversal
  def on___ENCODING__(node); end
  def on_alias(node); end
  def on_and(node); end
  def on_and_asgn(node); end
  def on_arg(node); end
  def on_arg_expr(node); end
  def on_args(node); end
  def on_array(node); end
  def on_array_pattern(node); end
  def on_array_pattern_with_tail(node); end
  def on_back_ref(node); end
  def on_begin(node); end
  def on_block(node); end
  def on_block_pass(node); end
  def on_blockarg(node); end
  def on_break(node); end
  def on_case(node); end
  def on_case_match(node); end
  def on_casgn(node); end
  def on_cbase(node); end
  def on_class(node); end
  def on_complex(node); end
  def on_const(node); end
  def on_const_pattern(node); end
  def on_csend(node); end
  def on_cvar(node); end
  def on_cvasgn(node); end
  def on_def(node); end
  def on_defined?(node); end
  def on_defs(node); end
  def on_dstr(node); end
  def on_dsym(node); end
  def on_eflipflop(node); end
  def on_empty_else(node); end
  def on_ensure(node); end
  def on_erange(node); end
  def on_false(node); end
  def on_find_pattern(node); end
  def on_float(node); end
  def on_for(node); end
  def on_forward_arg(node); end
  def on_forward_args(node); end
  def on_forwarded_args(node); end
  def on_gvar(node); end
  def on_gvasgn(node); end
  def on_hash(node); end
  def on_hash_pattern(node); end
  def on_if(node); end
  def on_if_guard(node); end
  def on_iflipflop(node); end
  def on_in_match(node); end
  def on_in_pattern(node); end
  def on_index(node); end
  def on_indexasgn(node); end
  def on_int(node); end
  def on_irange(node); end
  def on_ivar(node); end
  def on_ivasgn(node); end
  def on_kwarg(node); end
  def on_kwbegin(node); end
  def on_kwoptarg(node); end
  def on_kwrestarg(node); end
  def on_kwsplat(node); end
  def on_lambda(node); end
  def on_lvar(node); end
  def on_lvasgn(node); end
  def on_masgn(node); end
  def on_match_alt(node); end
  def on_match_as(node); end
  def on_match_current_line(node); end
  def on_match_nil_pattern(node); end
  def on_match_rest(node); end
  def on_match_var(node); end
  def on_match_with_lvasgn(node); end
  def on_match_with_trailing_comma(node); end
  def on_mlhs(node); end
  def on_module(node); end
  def on_next(node); end
  def on_nil(node); end
  def on_not(node); end
  def on_nth_ref(node); end
  def on_numblock(node); end
  def on_op_asgn(node); end
  def on_optarg(node); end
  def on_or(node); end
  def on_or_asgn(node); end
  def on_pair(node); end
  def on_pin(node); end
  def on_postexe(node); end
  def on_preexe(node); end
  def on_procarg0(node); end
  def on_rational(node); end
  def on_redo(node); end
  def on_regexp(node); end
  def on_regopt(node); end
  def on_resbody(node); end
  def on_rescue(node); end
  def on_restarg(node); end
  def on_retry(node); end
  def on_return(node); end
  def on_sclass(node); end
  def on_self(node); end
  def on_send(node); end
  def on_shadowarg(node); end
  def on_splat(node); end
  def on_str(node); end
  def on_super(node); end
  def on_sym(node); end
  def on_true(node); end
  def on_undef(node); end
  def on_unless_guard(node); end
  def on_until(node); end
  def on_until_post(node); end
  def on_when(node); end
  def on_while(node); end
  def on_while_post(node); end
  def on_xstr(node); end
  def on_yield(node); end
  def on_zsuper(node); end
  def walk(node); end
end

RuboCop::AST::Traversal::MANY_CHILD_NODES = T.let(T.unsafe(nil), Array)

RuboCop::AST::Traversal::NO_CHILD_NODES = T.let(T.unsafe(nil), Array)

RuboCop::AST::Traversal::ONE_CHILD_NODE = T.let(T.unsafe(nil), Array)

RuboCop::AST::Traversal::SECOND_CHILD_ONLY = T.let(T.unsafe(nil), Array)

class RuboCop::AST::UntilNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::ConditionalNode)
  include(::RuboCop::AST::ModifierNode)

  def do?; end
  def inverse_keyword; end
  def keyword; end
end

module RuboCop::AST::Version
end

RuboCop::AST::Version::STRING = T.let(T.unsafe(nil), String)

class RuboCop::AST::WhenNode < ::RuboCop::AST::Node
  def body; end
  def branch_index; end
  def conditions; end
  def each_condition(&block); end
  def then?; end
end

class RuboCop::AST::WhileNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::ConditionalNode)
  include(::RuboCop::AST::ModifierNode)

  def do?; end
  def inverse_keyword; end
  def keyword; end
end

class RuboCop::AST::YieldNode < ::RuboCop::AST::Node
  include(::RuboCop::AST::ParameterizedNode)
  include(::RuboCop::AST::MethodIdentifierPredicates)
  include(::RuboCop::AST::MethodDispatchNode)

  def arguments; end
  def node_parts; end
end

RuboCop::NodePattern = RuboCop::AST::NodePattern

RuboCop::ProcessedSource = RuboCop::AST::ProcessedSource

RuboCop::Token = RuboCop::AST::Token

RuboCop::AST::NodePattern::Compiler::ANY_ORDER_TEMPLATE = T.let(T.unsafe(nil), ERB)

RuboCop::AST::NodePattern::Compiler::CAPTURED_REST = T.let(T.unsafe(nil), String)

RuboCop::AST::NodePattern::Compiler::CLOSING = T.let(T.unsafe(nil), Regexp)

RuboCop::AST::NodePattern::Compiler::COMMENT = T.let(T.unsafe(nil), Regexp)

RuboCop::AST::NodePattern::Compiler::CONST = T.let(T.unsafe(nil), Regexp)

RuboCop::AST::NodePattern::Compiler::CUR_ELEMENT = T.let(T.unsafe(nil), String)

RuboCop::AST::NodePattern::Compiler::CUR_NODE = T.let(T.unsafe(nil), String)

RuboCop::AST::NodePattern::Compiler::CUR_PLACEHOLDER = T.let(T.unsafe(nil), String)

RuboCop::AST::NodePattern::Compiler::FUNCALL = T.let(T.unsafe(nil), Regexp)

RuboCop::AST::NodePattern::Compiler::IDENTIFIER = T.let(T.unsafe(nil), Regexp)

RuboCop::AST::NodePattern::Compiler::KEYWORD = T.let(T.unsafe(nil), Regexp)

RuboCop::AST::NodePattern::Compiler::KEYWORD_NAME = T.let(T.unsafe(nil), Regexp)

RuboCop::AST::NodePattern::Compiler::LITERAL = T.let(T.unsafe(nil), Regexp)

RuboCop::AST::NodePattern::Compiler::META = T.let(T.unsafe(nil), Regexp)

RuboCop::AST::NodePattern::Compiler::METHOD_NAME = T.let(T.unsafe(nil), Regexp)

RuboCop::AST::NodePattern::Compiler::MULTIPLE_CUR_PLACEHOLDER = T.let(T.unsafe(nil), Regexp)

RuboCop::AST::NodePattern::Compiler::NODE = T.let(T.unsafe(nil), Regexp)

RuboCop::AST::NodePattern::Compiler::NUMBER = T.let(T.unsafe(nil), Regexp)

RuboCop::AST::NodePattern::Compiler::ONLY_SEPARATOR = T.let(T.unsafe(nil), Regexp)

RuboCop::AST::NodePattern::Compiler::PARAM = T.let(T.unsafe(nil), Regexp)

RuboCop::AST::NodePattern::Compiler::PARAM_CONST = T.let(T.unsafe(nil), Regexp)

RuboCop::AST::NodePattern::Compiler::PARAM_NUMBER = T.let(T.unsafe(nil), Regexp)

RuboCop::AST::NodePattern::Compiler::PREDICATE = T.let(T.unsafe(nil), Regexp)

RuboCop::AST::NodePattern::Compiler::REPEATED_TEMPLATE = T.let(T.unsafe(nil), ERB)

RuboCop::AST::NodePattern::Compiler::REST = T.let(T.unsafe(nil), String)

RuboCop::AST::NodePattern::Compiler::SEPARATORS = T.let(T.unsafe(nil), Regexp)

RuboCop::AST::NodePattern::Compiler::SEQ_HEAD_GUARD = T.let(T.unsafe(nil), String)

RuboCop::AST::NodePattern::Compiler::SEQ_HEAD_INDEX = T.let(T.unsafe(nil), Integer)

RuboCop::AST::NodePattern::Compiler::STRING = T.let(T.unsafe(nil), Regexp)

RuboCop::AST::NodePattern::Compiler::SYMBOL = T.let(T.unsafe(nil), Regexp)

RuboCop::AST::NodePattern::Compiler::TOKEN = T.let(T.unsafe(nil), Regexp)

RuboCop::AST::NodePattern::Compiler::TOKENS = T.let(T.unsafe(nil), Regexp)

RuboCop::AST::NodePattern::Compiler::WILDCARD = T.let(T.unsafe(nil), Regexp)