clean-architecture 3.0.0 → 3.0.1

data/sorbet/rbi/gems/rspec-core.rbi

@@ -7,7 +7,8 @@
 #
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-core/all/rspec-core.rbi
 #
-# rspec-core-3.9.0
+# rspec-core-3.9.1
+
 module RSpec
   def self.clear_examples; end
   def self.configuration; end
@@ -564,6 +565,7 @@ module RSpec::Core::HashImitatable
   def all?(*args, &block); end
   def any?(*args, &block); end
   def assoc(*args, &block); end
+  def chain(*args, &block); end
   def chunk(*args, &block); end
   def chunk_while(*args, &block); end
   def clear(*args, &block); end
@@ -575,6 +577,8 @@ module RSpec::Core::HashImitatable
   def compare_by_identity?(*args, &block); end
   def count(*args, &block); end
   def cycle(*args, &block); end
+  def deep_merge!(*args, &block); end
+  def deep_merge(*args, &block); end
   def default(*args, &block); end
   def default=(*args, &block); end
   def default_proc(*args, &block); end
@@ -597,9 +601,15 @@ module RSpec::Core::HashImitatable
   def each_with_object(*args, &block); end
   def empty?(*args, &block); end
   def entries(*args, &block); end
+  def except!(*args, &block); end
+  def except(*args, &block); end
   def extra_hash_attributes; end
+  def extract!(*args, &block); end
+  def extractable_options?(*args, &block); end
   def fetch(*args, &block); end
   def fetch_values(*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
@@ -650,6 +660,7 @@ module RSpec::Core::HashImitatable
   def set_value(name, value); end
   def shift(*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
@@ -1420,7 +1431,9 @@ class RSpec::Core::Example
   def with_around_example_hooks; end
 end
 class RSpec::Core::Example::Procsy
+  def <<(*a, &b); end
   def ===(*a, &b); end
+  def >>(*a, &b); end
   def [](*a, &b); end
   def arity(*a, &b); end
   def binding(*a, &b); end

data/sorbet/rbi/gems/rspec-expectations.rbi

@@ -8,6 +8,7 @@
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-expectations/all/rspec-expectations.rbi
 #
 # rspec-expectations-3.9.0
+
 module RSpec
 end
 module RSpec::Matchers
@@ -344,7 +345,7 @@ end
 module RSpec::Expectations::Configuration::NullBacktraceFormatter
   def self.format_backtrace(backtrace); end
 end
-class InvalidName___Class_0x00___Differ_106
+class InvalidName___Class_0x00___Differ_101
 end
 module RSpec::Expectations::ExpectationHelper
   def self.check_message(msg); end
@@ -395,36 +396,3 @@ class RSpec::Core::ExampleGroup
   include RSpec::Core::MockingAdapters::RSpec
   include RSpec::Matchers
 end
-class RSpec::ExampleGroups::DuckfaceActsAsInterface::CleanArchitectureInterfacesUseCase < RSpec::ExampleGroups::DuckfaceActsAsInterface
-  include RSpec::ExampleGroups::DuckfaceActsAsInterface::CleanArchitectureInterfacesUseCase::LetDefinitions
-end
-class RSpec::ExampleGroups::DuckfaceActsAsInterface::CleanArchitectureInterfacesUseCase::BehavesLikeAnInterface < RSpec::ExampleGroups::DuckfaceActsAsInterface::CleanArchitectureInterfacesUseCase
-  include RSpec::ExampleGroups::DuckfaceActsAsInterface::CleanArchitectureInterfacesUseCase::BehavesLikeAnInterface::LetDefinitions
-end
-class Dummy
-  def initialize; end
-end
-class RSpec::ExampleGroups::DuckfaceActsAsInterface::CleanArchitectureInterfacesUseCase::BehavesLikeAnInterface::WhenAllMethodsRaiseNotImplementedError < RSpec::ExampleGroups::DuckfaceActsAsInterface::CleanArchitectureInterfacesUseCase::BehavesLikeAnInterface
-  def dummy; end
-  include RSpec::ExampleGroups::DuckfaceActsAsInterface::CleanArchitectureInterfacesUseCase::BehavesLikeAnInterface::WhenAllMethodsRaiseNotImplementedError::LetDefinitions
-end
-module RSpec::ExampleGroups::DuckfaceActsAsInterface::CleanArchitectureInterfacesUseCase::BehavesLikeAnInterface::WhenAllMethodsRaiseNotImplementedError::NamedSubjectPreventSuper
-end
-module RSpec::ExampleGroups::DuckfaceActsAsInterface::CleanArchitectureInterfacesUseCase::BehavesLikeAnInterface::WhenAllMethodsRaiseNotImplementedError::LetDefinitions
-  def dummy; end
-  include RSpec::ExampleGroups::DuckfaceActsAsInterface::CleanArchitectureInterfacesUseCase::BehavesLikeAnInterface::WhenAllMethodsRaiseNotImplementedError::NamedSubjectPreventSuper
-end
-module RSpec::ExampleGroups::DuckfaceActsAsInterface::CleanArchitectureInterfacesUseCase::BehavesLikeAnInterface::NamedSubjectPreventSuper
-end
-module RSpec::ExampleGroups::DuckfaceActsAsInterface::CleanArchitectureInterfacesUseCase::BehavesLikeAnInterface::LetDefinitions
-  include RSpec::ExampleGroups::DuckfaceActsAsInterface::CleanArchitectureInterfacesUseCase::BehavesLikeAnInterface::NamedSubjectPreventSuper
-end
-module RSpec::ExampleGroups::DuckfaceActsAsInterface::CleanArchitectureInterfacesUseCase::NamedSubjectPreventSuper
-end
-module RSpec::ExampleGroups::DuckfaceActsAsInterface::CleanArchitectureInterfacesUseCase::LetDefinitions
-  include RSpec::ExampleGroups::DuckfaceActsAsInterface::CleanArchitectureInterfacesUseCase::NamedSubjectPreventSuper
-end
-class RSpec::ExampleGroups::DuckfaceActsAsInterface::CleanArchitectureSerializersSuccessCollectionPayload < RSpec::ExampleGroups::DuckfaceActsAsInterface
-end
-class RSpec::ExampleGroups::DuckfaceActsAsInterface::CleanArchitectureSerializersSuccessCollectionPayload::BehavesLikeItImplements < RSpec::ExampleGroups::DuckfaceActsAsInterface::CleanArchitectureSerializersSuccessCollectionPayload
-end

data/sorbet/rbi/gems/rspec-mocks.rbi

@@ -7,7 +7,8 @@
 #
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-mocks/all/rspec-mocks.rbi
 #
-# rspec-mocks-3.9.0
+# rspec-mocks-3.9.1
+
 module RSpec
 end
 module RSpec::Mocks
@@ -813,3 +814,134 @@ module RSpec::Mocks::Matchers
 end
 module RSpec::Mocks::Matchers::Matcher
 end
+module RSpec::Mocks::AnyInstance
+  def self.error_generator; end
+end
+class RSpec::Mocks::AnyInstance::Chain
+  def constrained_to_any_of?(*constraints); end
+  def expectation_fulfilled!; end
+  def initialize(recorder, *args, &block); end
+  def last_message; end
+  def matches_args?(*args); end
+  def messages; end
+  def negated?; end
+  def never; end
+  def playback!(instance); end
+  def record(rspec_method_name, *args, &block); end
+  def with(*args, &block); end
+  include RSpec::Mocks::AnyInstance::Chain::Customizations
+end
+module RSpec::Mocks::AnyInstance::Chain::Customizations
+  def and_call_original(*args, &block); end
+  def and_raise(*args, &block); end
+  def and_return(*args, &block); end
+  def and_throw(*args, &block); end
+  def and_wrap_original(*args, &block); end
+  def and_yield(*args, &block); end
+  def at_least(*args, &block); end
+  def at_most(*args, &block); end
+  def exactly(*args, &block); end
+  def never(*args, &block); end
+  def once(*args, &block); end
+  def self.record(method_name); end
+  def thrice(*args, &block); end
+  def time(*args, &block); end
+  def times(*args, &block); end
+  def twice(*args, &block); end
+  def with(*args, &block); end
+end
+class RSpec::Mocks::AnyInstance::ErrorGenerator < RSpec::Mocks::ErrorGenerator
+  def raise_does_not_implement_error(klass, method_name); end
+  def raise_message_already_received_by_other_instance_error(method_name, object_inspect, invoked_instance); end
+  def raise_not_supported_with_prepend_error(method_name, problem_mod); end
+  def raise_second_instance_received_message_error(unfulfilled_expectations); end
+end
+class RSpec::Mocks::AnyInstance::StubChain < RSpec::Mocks::AnyInstance::Chain
+  def create_message_expectation_on(instance); end
+  def expectation_fulfilled?; end
+  def invocation_order; end
+  def verify_invocation_order(rspec_method_name, *_args, &_block); end
+end
+class RSpec::Mocks::AnyInstance::StubChainChain < RSpec::Mocks::AnyInstance::StubChain
+  def create_message_expectation_on(instance); end
+  def initialize(*args); end
+  def invocation_order; end
+end
+class RSpec::Mocks::AnyInstance::ExpectChainChain < RSpec::Mocks::AnyInstance::StubChain
+  def create_message_expectation_on(instance); end
+  def expectation_fulfilled?; end
+  def initialize(*args); end
+  def invocation_order; end
+  def playback!(instance); end
+end
+class RSpec::Mocks::AnyInstance::ExpectationChain < RSpec::Mocks::AnyInstance::Chain
+  def expectation_fulfilled?; end
+  def initialize(*args, &block); end
+  def verify_invocation_order(_rspec_method_name, *_args, &_block); end
+end
+class RSpec::Mocks::AnyInstance::PositiveExpectationChain < RSpec::Mocks::AnyInstance::ExpectationChain
+  def create_message_expectation_on(instance); end
+  def invocation_order; end
+end
+class RSpec::Mocks::AnyInstance::MessageChains
+  def [](method_name); end
+  def add(method_name, chain); end
+  def all_expectations_fulfilled?; end
+  def each_unfulfilled_expectation_matching(method_name, *args); end
+  def has_expectation?(method_name); end
+  def initialize; end
+  def playback!(instance, method_name); end
+  def raise_if_second_instance_to_receive_message(instance); end
+  def received_expected_message!(method_name); end
+  def remove_stub_chains_for!(method_name); end
+  def unfulfilled_expectations; end
+end
+class RSpec::Mocks::AnyInstance::Recorder
+  def allow_no_prepended_module_definition_of(method_name); end
+  def already_observing?(method_name); end
+  def ancestor_is_an_observer?(method_name); end
+  def backup_method!(method_name); end
+  def build_alias_method_name(method_name); end
+  def expect_chain(*method_names_and_optional_return_values, &block); end
+  def initialize(klass); end
+  def instance_that_received(method_name); end
+  def klass; end
+  def mark_invoked!(method_name); end
+  def message_chains; end
+  def normalize_chain(*args); end
+  def notify_received_message(_object, message, args, _blk); end
+  def observe!(method_name); end
+  def playback!(instance, method_name); end
+  def public_protected_or_private_method_defined?(method_name); end
+  def received_expected_message!(method_name); end
+  def remove_dummy_method!(method_name); end
+  def restore_method!(method_name); end
+  def restore_original_method!(method_name); end
+  def should_not_receive(method_name, &block); end
+  def should_receive(method_name, &block); end
+  def stop_all_observation!; end
+  def stop_observing!(method_name); end
+  def stub(method_name, &block); end
+  def stub_chain(*method_names_and_optional_return_values, &block); end
+  def stubs; end
+  def super_class_observers_for(method_name); end
+  def super_class_observing?(method_name); end
+  def unstub(method_name); end
+  def verify; end
+end
+class RSpec::Mocks::AnyInstance::Proxy
+  def expect_chain(*chain, &block); end
+  def initialize(recorder, target_proxies); end
+  def klass; end
+  def perform_proxying(method_name, args, block, &target_proxy_block); end
+  def should_not_receive(method_name, &block); end
+  def should_receive(method_name, &block); end
+  def stub(method_name_or_method_map, &block); end
+  def stub_chain(*chain, &block); end
+  def unstub(method_name); end
+end
+class RSpec::Mocks::AnyInstance::FluentInterfaceProxy
+  def initialize(targets); end
+  def method_missing(*args, &block); end
+  def respond_to_missing?(method_name, include_private = nil); end
+end

data/sorbet/rbi/gems/rspec-support.rbi

@@ -7,7 +7,8 @@
 #
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-support/all/rspec-support.rbi
 #
-# rspec-support-3.9.0
+# rspec-support-3.9.2
+
 module RSpec
   extend RSpec::Support::Warnings
 end
@@ -77,8 +78,10 @@ module RSpec::Support::RubyFeatures
   def self.ripper_supported?; end
   def self.supports_exception_cause?; end
   def self.supports_rebinding_module_methods?; end
+  def self.supports_taint?; end
   def supports_exception_cause?; end
   def supports_rebinding_module_methods?; end
+  def supports_taint?; end
 end
 module RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue
   def self.===(exception); end

data/sorbet/rbi/gems/rspec.rbi

@@ -8,6 +8,7 @@
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec/all/rspec.rbi
 #
 # rspec-3.9.0
+
 module RSpec
 end
 module RSpec::Version

data/sorbet/rbi/gems/rubocop-rspec.rbi

@@ -7,7 +7,8 @@
 #
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rubocop-rspec/all/rubocop-rspec.rbi
 #
-# rubocop-rspec-1.36.0
+# rubocop-rspec-1.38.1
+
 module RuboCop
 end
 module RuboCop::RSpec
@@ -70,6 +71,8 @@ module RuboCop::RSpec::Language::Examples
 end
 module RuboCop::RSpec::Language::Hooks
 end
+module RuboCop::RSpec::Language::Hooks::Scopes
+end
 module RuboCop::RSpec::Language::Helpers
 end
 module RuboCop::RSpec::Language::Subject
@@ -121,12 +124,16 @@ class RuboCop::RSpec::Example < RuboCop::RSpec::Concept
 end
 class RuboCop::RSpec::Hook < RuboCop::RSpec::Concept
   def example?; end
+  def extract_metadata(node = nil); end
   def knowable_scope?; end
+  def metadata; end
   def name; end
   def scope; end
   def scope_argument; end
   def scope_name; end
-  def valid_scope?; end
+  def transform_metadata(meta); end
+  def transform_true(node); end
+  def valid_scope?(node); end
 end
 module RuboCop::Cop
 end
@@ -146,8 +153,11 @@ class RuboCop::Cop::WorkaroundCop
   def duplicate_location?(location); end
   def enabled_line?(line_number); end
   def excluded_file?(file); end
+  def external_dependency_checksum; end
   def file_name_matches_any?(file, parameter, default_result); end
   def find_location(node, loc); end
+  def find_message(node, message); end
+  def find_severity(_node, severity); end
   def initialize(config = nil, options = nil); end
   def join_force?(_force_class); end
   def message(_node = nil); end
@@ -276,6 +286,12 @@ class RuboCop::Cop::RSpec::FactoryBot::CreateList::CreateListCorrector < RuboCop
   def initialize(node); end
   def node; end
 end
+class RuboCop::Cop::RSpec::FactoryBot::FactoryClassName < RuboCop::Cop::RSpec::Cop
+  def allowed?(const_name); end
+  def autocorrect(node); end
+  def class_name(node = nil); end
+  def on_send(node); end
+end
 class RuboCop::Cop::RSpec::AlignLeftLetBrace < RuboCop::Cop::RSpec::Cop
   def autocorrect(let); end
   def investigate(_processed_source); end
@@ -363,6 +379,10 @@ class RuboCop::Cop::RSpec::DescribedClass < RuboCop::Cop::RSpec::Cop
   def skippable_block?(node); end
   include RuboCop::Cop::ConfigurableEnforcedStyle
 end
+class RuboCop::Cop::RSpec::DescribedClassModuleWrapping < RuboCop::Cop::RSpec::Cop
+  def find_rspec_blocks(node0); end
+  def on_module(node); end
+end
 class RuboCop::Cop::RSpec::Dialect < RuboCop::Cop::RSpec::Cop
   def autocorrect(node); end
   def message(node); end
@@ -427,11 +447,13 @@ class RuboCop::Cop::RSpec::ExampleWording < RuboCop::Cop::RSpec::Cop
   def text(node); end
 end
 class RuboCop::Cop::RSpec::ExpectActual < RuboCop::Cop::RSpec::Cop
+  def autocorrect(node); end
   def complex_literal?(node); end
   def expect_literal(node = nil); end
   def literal?(node); end
   def on_send(node); end
   def simple_literal?(node); end
+  def swap(corrector, actual, expected); end
 end
 class RuboCop::Cop::RSpec::ExpectChange < RuboCop::Cop::RSpec::Cop
   def autocorrect(node); end
@@ -533,12 +555,13 @@ class RuboCop::Cop::RSpec::InstanceSpy < RuboCop::Cop::RSpec::Cop
 end
 class RuboCop::Cop::RSpec::InstanceVariable < RuboCop::Cop::RSpec::Cop
   def assignment_only?; end
+  def custom_matcher?(node = nil); end
   def dynamic_class?(node = nil); end
-  def inside_dynamic_class?(node); end
   def ivar_assigned?(node0, param1); end
   def ivar_usage(node0); end
   def on_block(node); end
   def spec_group?(node = nil); end
+  def valid_usage?(node); end
 end
 class RuboCop::Cop::RSpec::InvalidPredicateMatcher < RuboCop::Cop::RSpec::Cop
   def invalid_predicate_matcher?(node = nil); end
@@ -701,6 +724,7 @@ module RuboCop::Cop::RSpec::InflectedHelper
   include RuboCop::RSpec::Language
 end
 module RuboCop::Cop::RSpec::ExplicitHelper
+  def allowed_explicit_matchers; end
   def autocorrect_explicit(node); end
   def autocorrect_explicit_block(node); end
   def autocorrect_explicit_send(node); end
@@ -741,6 +765,7 @@ class RuboCop::Cop::RSpec::ReceiveNever < RuboCop::Cop::RSpec::Cop
   def on_send(node); end
 end
 class RuboCop::Cop::RSpec::RepeatedDescription < RuboCop::Cop::RSpec::Cop
+  def example_signature(example); end
   def on_block(node); end
   def repeated_descriptions(node); end
 end
@@ -749,6 +774,27 @@ class RuboCop::Cop::RSpec::RepeatedExample < RuboCop::Cop::RSpec::Cop
   def on_block(node); end
   def repeated_examples(node); end
 end
+class RuboCop::Cop::RSpec::RepeatedExampleGroupBody < RuboCop::Cop::RSpec::Cop
+  def add_repeated_lines(groups); end
+  def body(node = nil); end
+  def message(group, repeats); end
+  def metadata(node = nil); end
+  def on_begin(node); end
+  def repeated_group_bodies(node); end
+  def several_example_groups?(node = nil); end
+  def signature_keys(group); end
+  def skip_or_pending?(node = nil); end
+end
+class RuboCop::Cop::RSpec::RepeatedExampleGroupDescription < RuboCop::Cop::RSpec::Cop
+  def add_repeated_lines(groups); end
+  def doc_string_and_metadata(node = nil); end
+  def empty_description?(node = nil); end
+  def message(group, repeats); end
+  def on_begin(node); end
+  def repeated_group_descriptions(node); end
+  def several_example_groups?(node = nil); end
+  def skip_or_pending?(node = nil); end
+end
 class RuboCop::Cop::RSpec::ReturnFromStub < RuboCop::Cop::RSpec::Cop
   def and_return_value(node0); end
   def autocorrect(node); end
@@ -784,8 +830,9 @@ class RuboCop::Cop::RSpec::ScatteredLet < RuboCop::Cop::RSpec::Cop
   def on_block(node); end
 end
 class RuboCop::Cop::RSpec::ScatteredSetup < RuboCop::Cop::RSpec::Cop
-  def analyzable_hooks(node); end
+  def lines_msg(numbers); end
   def on_block(node); end
+  def repeated_hooks(node); end
 end
 class RuboCop::Cop::RSpec::SharedContext < RuboCop::Cop::RSpec::Cop
   def add_shared_item_offense(node, message); end

data/sorbet/rbi/gems/rubocop.rbi

@@ -7,14 +7,14 @@
 #
 #   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rubocop/all/rubocop.rbi
 #
-# rubocop-0.75.1
+# rubocop-0.80.0
+
 module RuboCop
 end
 module RuboCop::Version
   def self.version(debug = nil); end
 end
 class String
-  def blank?; end
 end
 module RuboCop::PathUtil
   def absolute?(path); end
@@ -58,11 +58,13 @@ class RuboCop::NodePattern
   def marshal_load(pattern); end
   def match(*args); end
   def pattern; end
+  def self.descend(element, &block); end
   def to_s; end
 end
 class RuboCop::NodePattern::Invalid < StandardError
 end
 class RuboCop::NodePattern::Compiler
+  def access_unify(name); end
   def auto_use_temp_node?(code); end
   def captures; end
   def compile_any_order(capture_all = nil); end
@@ -71,6 +73,7 @@ class RuboCop::NodePattern::Compiler
   def compile_ascend; end
   def compile_capture; end
   def compile_captured_ellipsis; end
+  def compile_descend; end
   def compile_ellipsis; end
   def compile_expr(token = nil); end
   def compile_funcall(method); end
@@ -91,6 +94,7 @@ class RuboCop::NodePattern::Compiler
   def emit_trailing_params; end
   def emit_yield_capture(when_no_capture = nil); end
   def fail_due_to(message); end
+  def forbid_unification(*names); end
   def get_param(number); end
   def initialize(str, node_var = nil); end
   def insure_same_captures(enum, what); end
@@ -105,6 +109,7 @@ class RuboCop::NodePattern::Compiler
   def substitute_cur_node(code, cur_node, first_cur_node: nil); end
   def tokens; end
   def tokens_until(stop, what); end
+  def unify_in_union(enum); end
   def variadic_seq_term; end
   def with_child_context(code, child_index); end
   def with_context(code, cur_node, use_temp_node: nil); end
@@ -162,6 +167,8 @@ class RuboCop::AST::Node < Parser::AST::Node
   def arg_type?; end
   def args_type?; end
   def argument?; 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 = nil); end
@@ -174,9 +181,11 @@ class RuboCop::AST::Node < Parser::AST::Node
   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_if_value_used?; end
+  def case_match_type?; end
   def case_type?; end
   def casgn_type?; end
   def cbase_type?; end
@@ -189,6 +198,7 @@ class RuboCop::AST::Node < Parser::AST::Node
   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
@@ -217,14 +227,20 @@ class RuboCop::AST::Node < Parser::AST::Node
   def float_type?; end
   def for_type?; end
   def for_value_used?; end
+  def forward_args_type?; end
+  def forwarded_args_type?; end
   def guard_clause?(node = nil); 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 initialize(type, children = nil, properties = nil); end
@@ -248,9 +264,14 @@ class RuboCop::AST::Node < Parser::AST::Node
   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_nil_pattern_type?; end
+  def match_rest_type?; end
+  def match_var_type?; end
   def match_with_lvasgn_type?; end
-  def meth_ref_type?; end
+  def match_with_trailing_comma_type?; end
   def mlhs_type?; end
   def module_type?; end
   def multiline?; end
@@ -265,7 +286,6 @@ class RuboCop::AST::Node < Parser::AST::Node
   def numargs_type?; end
   def numblock_type?; end
   def numeric_type?; end
-  def numparam_type?; end
   def objc_kwarg_type?; end
   def objc_restarg_type?; end
   def objc_varargs_type?; end
@@ -282,6 +302,7 @@ class RuboCop::AST::Node < Parser::AST::Node
   def parent_module_name_for_sclass(sclass_node); end
   def parent_module_name_part(node); end
   def parenthesized_call?; end
+  def pin_type?; end
   def postexe_type?; end
   def preexe_type?; end
   def proc?(node = nil); end
@@ -322,6 +343,7 @@ class RuboCop::AST::Node < Parser::AST::Node
   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 = nil, children = nil, properties = nil); end
@@ -374,6 +396,7 @@ module RuboCop::AST::CollectionNode
   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
@@ -390,6 +413,7 @@ module RuboCop::AST::CollectionNode
   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
@@ -402,8 +426,11 @@ module RuboCop::AST::CollectionNode
   def each_with_object(*args, &block); end
   def empty?(*args, &block); end
   def entries(*args, &block); end
+  def extract_options!(*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
@@ -478,6 +505,7 @@ module RuboCop::AST::CollectionNode
   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
@@ -603,6 +631,7 @@ class RuboCop::AST::BlockNode < RuboCop::AST::Node
   def send_node; end
   def single_line?; end
   def void_context?; end
+  include RuboCop::AST::MethodIdentifierPredicates
 end
 class RuboCop::AST::BreakNode < RuboCop::AST::Node
   def arguments; end
@@ -623,6 +652,7 @@ class RuboCop::AST::ClassNode < RuboCop::AST::Node
   def parent_class; end
 end
 class RuboCop::AST::DefNode < RuboCop::AST::Node
+  def argument_forwarding?; end
   def arguments; end
   def body; end
   def method_name; end
@@ -648,6 +678,10 @@ class RuboCop::AST::ForNode < RuboCop::AST::Node
   def variable; end
   def void_context?; end
 end
+class RuboCop::AST::ForwardArgsNode < RuboCop::AST::Node
+  def to_a; end
+  include RuboCop::AST::CollectionNode
+end
 class RuboCop::AST::FloatNode < RuboCop::AST::Node
   include RuboCop::AST::NumericNode
 end
@@ -728,6 +762,11 @@ class RuboCop::AST::RetryNode < RuboCop::AST::Node
   include RuboCop::AST::MethodDispatchNode
   include RuboCop::AST::ParameterizedNode
 end
+class RuboCop::AST::ReturnNode < RuboCop::AST::Node
+  def arguments; end
+  include RuboCop::AST::MethodDispatchNode
+  include RuboCop::AST::ParameterizedNode
+end
 class RuboCop::AST::SelfClassNode < RuboCop::AST::Node
   def body; end
   def identifier; end
@@ -787,6 +826,8 @@ module RuboCop::AST::Traversal
   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
@@ -794,11 +835,13 @@ module RuboCop::AST::Traversal
   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
@@ -813,11 +856,17 @@ module RuboCop::AST::Traversal
   def on_false(node); end
   def on_float(node); end
   def on_for(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_int(node); end
   def on_irange(node); end
   def on_ivar(node); end
@@ -831,19 +880,27 @@ module RuboCop::AST::Traversal
   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_rational(node); end
@@ -865,6 +922,7 @@ module RuboCop::AST::Traversal
   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
@@ -932,6 +990,7 @@ class RuboCop::Cop::Offense
   def column_length; end
   def column_range; end
   def cop_name; end
+  def correctable?; end
   def corrected?; end
   def corrected_with_todo?; end
   def disabled?; end
@@ -988,6 +1047,7 @@ module RuboCop::Cop::AutocorrectLogic
   def max_line_length; end
   def range_by_lines(range); end
   def range_of_first_line(range); end
+  def safe_autocorrect?; end
   def support_autocorrect?; end
 end
 class RuboCop::Cop::Badge
@@ -1053,8 +1113,11 @@ class RuboCop::Cop::Cop
   def duplicate_location?(location); end
   def enabled_line?(line_number); end
   def excluded_file?(file); end
+  def external_dependency_checksum; end
   def file_name_matches_any?(file, parameter, default_result); end
   def find_location(node, loc); end
+  def find_message(node, message); end
+  def find_severity(_node, severity); end
   def initialize(config = nil, options = nil); end
   def join_force?(_force_class); end
   def message(_node = nil); end
@@ -1110,6 +1173,8 @@ class RuboCop::Cop::Commissioner
   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
@@ -1117,11 +1182,13 @@ class RuboCop::Cop::Commissioner
   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
@@ -1136,11 +1203,17 @@ class RuboCop::Cop::Commissioner
   def on_false(node); end
   def on_float(node); end
   def on_for(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_int(node); end
   def on_irange(node); end
   def on_ivar(node); end
@@ -1154,19 +1227,27 @@ class RuboCop::Cop::Commissioner
   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_rational(node); end
@@ -1188,6 +1269,7 @@ class RuboCop::Cop::Commissioner
   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
@@ -1200,6 +1282,8 @@ class RuboCop::Cop::Commissioner
   def remove_irrelevant_cops(filename); end
   def reset_callbacks; end
   def reset_errors; end
+  def support_target_rails_version?(cop); end
+  def support_target_ruby_version?(cop); end
   def trigger_responding_cops(callback, node); end
   def with_cop_error_handling(cop, node = nil); end
   include RuboCop::AST::Traversal
@@ -1316,6 +1400,7 @@ class RuboCop::Cop::VariableForce < RuboCop::Cop::Force
   def scanned_node?(node); end
   def scanned_nodes; end
   def skip_children!; end
+  def twisted_nodes(node); end
   def variable_table; end
 end
 class RuboCop::Cop::VariableForce::VariableReference < Struct
@@ -1608,6 +1693,7 @@ module RuboCop::Cop::ConfigurableEnforcedStyle
   def no_acceptable_style?; end
   def opposite_style_detected; end
   def style; end
+  def style_configured?; end
   def style_detected(detected); end
   def style_parameter_name; end
   def supported_styles; end
@@ -1717,25 +1803,26 @@ module RuboCop::Cop::FirstElementLineBreak
 end
 module RuboCop::Cop::FrozenStringLiteral
   def frozen_string_literal_comment_exists?; end
+  def frozen_string_literal_specified?; end
   def frozen_string_literals_enabled?; end
   def leading_comment_lines; end
   def self.frozen_string_literal_comment_exists?; end
 end
-module RuboCop::Cop::HashAlignment
+module RuboCop::Cop::HashAlignmentStyles
 end
-class RuboCop::Cop::HashAlignment::KeyAlignment
+class RuboCop::Cop::HashAlignmentStyles::KeyAlignment
   def checkable_layout?(_node); end
   def deltas(first_pair, current_pair); end
   def deltas_for_first_pair(first_pair, _node); end
   def separator_delta(pair); end
   def value_delta(pair); end
 end
-module RuboCop::Cop::HashAlignment::ValueAlignment
+module RuboCop::Cop::HashAlignmentStyles::ValueAlignment
   def checkable_layout?(node); end
   def deltas(first_pair, current_pair); end
   def separator_delta(first_pair, current_pair, key_delta); end
 end
-class RuboCop::Cop::HashAlignment::TableAlignment
+class RuboCop::Cop::HashAlignmentStyles::TableAlignment
   def deltas_for_first_pair(first_pair, node); end
   def hash_rocket_delta(first_pair, current_pair); end
   def initialize; end
@@ -1743,14 +1830,63 @@ class RuboCop::Cop::HashAlignment::TableAlignment
   def max_key_width; end
   def max_key_width=(arg0); end
   def value_delta(first_pair, current_pair); end
-  include RuboCop::Cop::HashAlignment::ValueAlignment
+  include RuboCop::Cop::HashAlignmentStyles::ValueAlignment
 end
-class RuboCop::Cop::HashAlignment::SeparatorAlignment
+class RuboCop::Cop::HashAlignmentStyles::SeparatorAlignment
   def deltas_for_first_pair(*_nodes); end
   def hash_rocket_delta(first_pair, current_pair); end
   def key_delta(first_pair, current_pair); end
   def value_delta(first_pair, current_pair); end
-  include RuboCop::Cop::HashAlignment::ValueAlignment
+  include RuboCop::Cop::HashAlignmentStyles::ValueAlignment
+end
+module RuboCop::Cop::HashTransformMethod
+  def autocorrect(node); end
+  def execute_correction(corrector, node, correction); end
+  def extract_captures(_match); end
+  def handle_possible_offense(node, match, match_desc); end
+  def new_method_name; end
+  def on_bad_each_with_object(_node); end
+  def on_bad_hash_brackets_map(_node); end
+  def on_bad_map_to_h(_node); end
+  def on_block(node); end
+  def on_csend(node); end
+  def on_send(node); end
+  def prepare_correction(node); end
+end
+class RuboCop::Cop::HashTransformMethod::Captures < Struct
+  def noop_transformation?; end
+  def self.[](*arg0); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def transformation_uses_both_args?; end
+  def transformed_argname; end
+  def transformed_argname=(_); end
+  def transforming_body_expr; end
+  def transforming_body_expr=(_); end
+  def unchanged_body_expr; end
+  def unchanged_body_expr=(_); end
+end
+class RuboCop::Cop::HashTransformMethod::Autocorrection < Struct
+  def block_node; end
+  def block_node=(_); end
+  def leading; end
+  def leading=(_); end
+  def match; end
+  def match=(_); end
+  def self.[](*arg0); end
+  def self.from_each_with_object(node, match); end
+  def self.from_hash_brackets_map(node, match); end
+  def self.from_map_to_h(node, match); end
+  def self.inspect; end
+  def self.members; end
+  def self.new(*arg0); end
+  def set_new_arg_name(transformed_argname, corrector); end
+  def set_new_body_expression(transforming_body_expr, corrector); end
+  def set_new_method_name(new_method_name, corrector); end
+  def strip_prefix_and_suffix(node, corrector); end
+  def trailing; end
+  def trailing=(_); end
 end
 module RuboCop::Cop::IgnoredPattern
   def ignored_line?(line); end
@@ -1771,6 +1907,20 @@ module RuboCop::Cop::Interpolation
   def on_regexp(node); end
   def on_xstr(node); end
 end
+module RuboCop::Cop::LineLengthHelp
+  def allow_uri?; end
+  def allowed_uri_position?(line, uri_range); end
+  def directive_on_source_line?(line_index); end
+  def find_excessive_uri_range(line); end
+  def ignore_cop_directives?; end
+  def indentation_difference(line); end
+  def line_length(line); end
+  def line_length_without_directive(line); end
+  def match_uris(string); end
+  def tab_indentation_width; end
+  def uri_regexp; end
+  def valid_uri?(uri_ish_string); end
+end
 module RuboCop::Cop::MatchRange
   def each_match_range(range, regex); end
   def match_range(range, match); end
@@ -1866,9 +2016,9 @@ module RuboCop::Cop::Heredoc
   def on_xstr(node); end
 end
 module RuboCop::Cop::NilMethods
+  def allowed_methods; end
   def nil_methods; end
   def other_stdlib_methods; end
-  def whitelist; end
 end
 module RuboCop::Cop::OnNormalIfUnless
   def on_if(node); end
@@ -1936,6 +2086,10 @@ class RuboCop::Cop::PreferredDelimiters
   def preferred_delimiters_config; end
   def type; end
 end
+module RuboCop::Cop::RationalLiteral
+  def rational_literal?(node = nil); end
+  extend RuboCop::NodePattern::Macros
+end
 module RuboCop::Cop::RescueNode
   def investigate(processed_source); end
   def rescue_modifier?(node); end
@@ -1947,11 +2101,6 @@ module RuboCop::Cop::SafeAssignment
   def setter_method?(node = nil); end
   extend RuboCop::NodePattern::Macros
 end
-module RuboCop::Cop::SafeMode
-  def rails?; end
-  def rails_safe_mode?; end
-  def safe_mode?; end
-end
 module RuboCop::Cop::SpaceAfterPunctuation
   def allowed_type?(token); end
   def each_missing_space(tokens); end
@@ -2027,12 +2176,12 @@ module RuboCop::Cop::TrailingComma
   def allowed_multiline_argument?(node); end
   def any_heredoc?(items); end
   def autocorrect_range(item); end
-  def avoid_autocorrect?(_nodes); end
   def avoid_comma(kind, comma_begin_pos, extra_info); end
   def brackets?(node); end
   def check(node, items, kind, begin_pos, end_pos); end
   def check_comma(node, kind, comma_pos); end
   def check_literal(node, kind); end
+  def comma_offset(items, range); end
   def elements(node); end
   def extra_avoid_comma_info; end
   def heredoc?(node); end
@@ -2042,7 +2191,7 @@ module RuboCop::Cop::TrailingComma
   def multiline?(node); end
   def no_elements_on_same_line?(node); end
   def on_same_line?(range1, range2); end
-  def put_comma(node, items, kind); end
+  def put_comma(items, kind); end
   def should_have_comma?(style, node); end
   def style_parameter_name; end
   include RuboCop::Cop::ConfigurableEnforcedStyle
@@ -2088,7 +2237,7 @@ class RuboCop::Cop::Utils::FormatString::FormatSequence
   def begin_pos; end
   def end_pos; end
   def flags; end
-  def initialize(string, **opts); end
+  def initialize(match); end
   def max_digit_dollar_num; end
   def name; end
   def percent?; end
@@ -2104,6 +2253,8 @@ class RuboCop::Cop::Migration::DepartmentName < RuboCop::Cop::Cop
   def autocorrect(range); end
   def check_cop_name(name, comment, offset); end
   def investigate(processed_source); end
+  def qualified_legacy_cop_name(cop_name); end
+  def valid_content_token?(content_token); end
   include RuboCop::Cop::RangeHelp
 end
 class RuboCop::Cop::AlignmentCorrector
@@ -2272,11 +2423,11 @@ end
 class RuboCop::Cop::Bundler::GemComment < RuboCop::Cop::Cop
   def commented?(node); end
   def gem_declaration?(node = nil); end
+  def ignored_gem?(node); end
   def on_send(node); end
   def precede?(node1, node2); end
   def preceding_comment?(node1, node2); end
   def preceding_lines(node); end
-  def whitelisted_gem?(node); end
   include RuboCop::Cop::DefNode
 end
 class RuboCop::Cop::Bundler::InsecureProtocolSource < RuboCop::Cop::Cop
@@ -2342,7 +2493,7 @@ class RuboCop::Cop::Layout::AccessModifierIndentation < RuboCop::Cop::Cop
   include RuboCop::Cop::ConfigurableEnforcedStyle
   include RuboCop::Cop::RangeHelp
 end
-class RuboCop::Cop::Layout::AlignArguments < RuboCop::Cop::Cop
+class RuboCop::Cop::Layout::ArgumentAlignment < RuboCop::Cop::Cop
   def autocorrect(node); end
   def base_column(node, args); end
   def fixed_indentation?; end
@@ -2352,47 +2503,17 @@ class RuboCop::Cop::Layout::AlignArguments < RuboCop::Cop::Cop
   def target_method_lineno(node); end
   include RuboCop::Cop::Alignment
 end
-class RuboCop::Cop::Layout::AlignArray < RuboCop::Cop::Cop
+class RuboCop::Cop::Layout::ArrayAlignment < RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_array(node); end
   include RuboCop::Cop::Alignment
 end
-class RuboCop::Cop::Layout::AlignHash < RuboCop::Cop::Cop
-  def add_offences; end
-  def adjust(corrector, delta, range); end
-  def alignment_for(pair); end
-  def alignment_for_colons; end
-  def alignment_for_hash_rockets; end
-  def autocorrect(node); end
-  def check_delta(delta, node:, alignment:); end
-  def check_pairs(node); end
-  def column_deltas; end
-  def column_deltas=(arg0); end
-  def correct_key_value(delta, key, value, separator); end
-  def correct_no_value(key_delta, key); end
-  def correct_node(node, delta); end
-  def double_splat?(node); end
-  def good_alignment?(column_deltas); end
-  def ignore_hash_argument?(node); end
-  def new_alignment(key); end
-  def offences_by; end
-  def offences_by=(arg0); end
-  def on_hash(node); end
-  def on_send(node); end
-  def on_super(node); end
-  def on_yield(node); end
-  include RuboCop::Cop::HashAlignment
-  include RuboCop::Cop::RangeHelp
-end
-class RuboCop::Cop::Layout::AlignParameters < RuboCop::Cop::Cop
+class RuboCop::Cop::Layout::AssignmentIndentation < RuboCop::Cop::Cop
   def autocorrect(node); end
-  def base_column(node, args); end
-  def fixed_indentation?; end
-  def message(_node); end
-  def on_def(node); end
-  def on_defs(node); end
-  def target_method_lineno(node); end
+  def check_assignment(node, rhs); end
+  def leftmost_multiple_assignment(node); end
   include RuboCop::Cop::Alignment
+  include RuboCop::Cop::CheckAssignment
 end
 class RuboCop::Cop::Layout::BlockAlignment < RuboCop::Cop::Cop
   def add_space_before(loc, delta); end
@@ -2506,7 +2627,7 @@ class RuboCop::Cop::Layout::CommentIndentation < RuboCop::Cop::Cop
   def line_after_comment(comment); end
   def message(column, correct_comment_indentation); end
   def own_line_comment?(comment); end
-  def should_correct?(comment, column, line_no); end
+  def should_correct?(preceding_comment, reference_comment); end
   def two_alternatives?(line); end
   include RuboCop::Cop::Alignment
 end
@@ -2558,7 +2679,7 @@ class RuboCop::Cop::Layout::EmptyComment < RuboCop::Cop::Cop
   def autocorrect(node); end
   def comment_text(comment); end
   def concat_consecutive_comments(comments); end
-  def current_token(node); end
+  def current_token(comment); end
   def empty_comment_only?(comment_text); end
   def investigate(processed_source); end
   def previous_token(node); end
@@ -2712,6 +2833,7 @@ class RuboCop::Cop::Layout::EndAlignment < RuboCop::Cop::Cop
 end
 class RuboCop::Cop::Layout::EndOfLine < RuboCop::Cop::Cop
   def investigate(processed_source); end
+  def last_line(processed_source); end
   def offense_message(line); end
   def unimportant_missing_cr?(index, last_line, line); end
   include RuboCop::Cop::ConfigurableEnforcedStyle
@@ -2740,12 +2862,58 @@ class RuboCop::Cop::Layout::ExtraSpacing < RuboCop::Cop::Cop
   include RuboCop::Cop::PrecedingFollowingAlignment
   include RuboCop::Cop::RangeHelp
 end
+class RuboCop::Cop::Layout::FirstArgumentIndentation < RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def base_indentation(node); end
+  def base_range(send_node, arg_node); end
+  def column_of(range); end
+  def comment_lines; end
+  def eligible_method_call?(node = nil); end
+  def message(arg_node); end
+  def on_csend(node); end
+  def on_send(node); end
+  def previous_code_line(line_number); end
+  def special_inner_call_indentation?(node); end
+  include RuboCop::Cop::Alignment
+  include RuboCop::Cop::ConfigurableEnforcedStyle
+  include RuboCop::Cop::RangeHelp
+end
+class RuboCop::Cop::Layout::FirstArrayElementIndentation < RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def base_description(left_parenthesis); end
+  def brace_alignment_style; end
+  def check(array_node, left_parenthesis); end
+  def check_right_bracket(right_bracket, left_bracket, left_parenthesis); end
+  def message(base_description); end
+  def on_array(node); end
+  def on_csend(node); end
+  def on_send(node); end
+  include RuboCop::Cop::Alignment
+  include RuboCop::Cop::ConfigurableEnforcedStyle
+  include RuboCop::Cop::MultilineElementIndentation
+end
 class RuboCop::Cop::Layout::FirstArrayElementLineBreak < RuboCop::Cop::Cop
   def assignment_on_same_line?(node); end
   def autocorrect(node); end
   def on_array(node); end
   include RuboCop::Cop::FirstElementLineBreak
 end
+class RuboCop::Cop::Layout::FirstHashElementIndentation < RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def base_description(left_parenthesis); end
+  def brace_alignment_style; end
+  def check(hash_node, left_parenthesis); end
+  def check_based_on_longest_key(hash_node, left_brace, left_parenthesis); end
+  def check_right_brace(right_brace, left_brace, left_parenthesis); end
+  def message(base_description); end
+  def on_csend(node); end
+  def on_hash(node); end
+  def on_send(node); end
+  def separator_style?(first_pair); end
+  include RuboCop::Cop::Alignment
+  include RuboCop::Cop::ConfigurableEnforcedStyle
+  include RuboCop::Cop::MultilineElementIndentation
+end
 class RuboCop::Cop::Layout::FirstHashElementLineBreak < RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_hash(node); end
@@ -2764,6 +2932,46 @@ class RuboCop::Cop::Layout::FirstMethodParameterLineBreak < RuboCop::Cop::Cop
   def on_defs(node); end
   include RuboCop::Cop::FirstElementLineBreak
 end
+class RuboCop::Cop::Layout::FirstParameterIndentation < RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def base_description(_); end
+  def brace_alignment_style; end
+  def check(def_node); end
+  def message(base_description); end
+  def on_def(node); end
+  def on_defs(node); end
+  include RuboCop::Cop::Alignment
+  include RuboCop::Cop::ConfigurableEnforcedStyle
+  include RuboCop::Cop::MultilineElementIndentation
+end
+class RuboCop::Cop::Layout::HashAlignment < RuboCop::Cop::Cop
+  def add_offences; end
+  def adjust(corrector, delta, range); end
+  def alignment_for(pair); end
+  def alignment_for_colons; end
+  def alignment_for_hash_rockets; end
+  def autocorrect(node); end
+  def check_delta(delta, node:, alignment:); end
+  def check_pairs(node); end
+  def column_deltas; end
+  def column_deltas=(arg0); end
+  def correct_key_value(delta, key, value, separator); end
+  def correct_no_value(key_delta, key); end
+  def correct_node(node, delta); end
+  def double_splat?(node); end
+  def good_alignment?(column_deltas); end
+  def ignore_hash_argument?(node); end
+  def new_alignment(key); end
+  def offences_by; end
+  def offences_by=(arg0); end
+  def on_hash(node); end
+  def on_send(node); end
+  def on_super(node); end
+  def on_yield(node); end
+  def reset!; end
+  include RuboCop::Cop::HashAlignmentStyles
+  include RuboCop::Cop::RangeHelp
+end
 class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis < RuboCop::Cop::Cop
   def add_correct_closing_paren(node, corrector); end
   def add_correct_external_trailing_comma(node, corrector); end
@@ -2791,12 +2999,33 @@ class RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis < RuboCop::Cop::Co
   def space?(pos); end
   include RuboCop::Cop::RangeHelp
 end
-class RuboCop::Cop::Layout::IndentAssignment < RuboCop::Cop::Cop
+class RuboCop::Cop::Layout::HeredocIndentation < RuboCop::Cop::Cop
+  def adjust_minus(corrector, node); end
+  def adjust_squiggly(corrector, node); end
   def autocorrect(node); end
-  def check_assignment(node, rhs); end
-  def leftmost_multiple_assignment(node); end
-  include RuboCop::Cop::Alignment
-  include RuboCop::Cop::CheckAssignment
+  def base_indent_level(node); end
+  def check_style!; end
+  def correct_by_library(node); end
+  def correct_by_squiggly(node); end
+  def heredoc_body(node); end
+  def heredoc_end(node); end
+  def heredoc_indent_type(node); end
+  def indent_level(str); end
+  def indentation_width; end
+  def indented_body(node); end
+  def indented_end(node); end
+  def library_message(indentation_width, method); end
+  def line_too_long?(node); end
+  def longest_line(lines); end
+  def max_line_length; end
+  def message(node); end
+  def on_heredoc(node); end
+  def ruby23_message(indentation_width, current_indent_type); end
+  def ruby23_type_message(indentation_width, current_indent_type); end
+  def ruby23_width_message(indentation_width); end
+  def unlimited_heredoc_length?; end
+  include RuboCop::Cop::ConfigurableEnforcedStyle
+  include RuboCop::Cop::Heredoc
 end
 class RuboCop::Cop::Layout::IndentationConsistency < RuboCop::Cop::Cop
   def autocorrect(node); end
@@ -2857,119 +3086,74 @@ class RuboCop::Cop::Layout::IndentationWidth < RuboCop::Cop::Cop
   include RuboCop::Cop::IgnoredPattern
   include RuboCop::Cop::RangeHelp
 end
-class RuboCop::Cop::Layout::IndentFirstArgument < RuboCop::Cop::Cop
+class RuboCop::Cop::Layout::InitialIndentation < RuboCop::Cop::Cop
+  def autocorrect(range); end
+  def first_token; end
+  def investigate(_processed_source); end
+  def space_before(token); end
+  include RuboCop::Cop::RangeHelp
+end
+class RuboCop::Cop::Layout::LeadingCommentSpace < RuboCop::Cop::Cop
+  def allow_doxygen_comment?; end
+  def allow_gemfile_ruby_comment?; end
+  def allowed_on_first_line?(comment); end
+  def autocorrect(comment); end
+  def doxygen_comment_style?(comment); end
+  def gemfile?; end
+  def gemfile_ruby_comment?(comment); end
+  def investigate(processed_source); end
+  def rackup_config_file?; end
+  def rackup_options?(comment); end
+  def ruby_comment_in_gemfile?(comment); end
+  def shebang?(comment); end
+  include RuboCop::Cop::RangeHelp
+end
+class RuboCop::Cop::Layout::LeadingEmptyLines < RuboCop::Cop::Cop
   def autocorrect(node); end
-  def base_indentation(node); end
-  def base_range(send_node, arg_node); end
-  def column_of(range); end
-  def eligible_method_call?(node = nil); end
-  def message(arg_node); end
-  def on_csend(node); end
+  def investigate(processed_source); end
+end
+class RuboCop::Cop::Layout::LineLength < RuboCop::Cop::Cop
+  def allow_heredoc?; end
+  def allowed_heredoc; end
+  def autocorrect(range); end
+  def breakable_block_range(block_node); end
+  def breakable_range_after_semicolon(semicolon_token); end
+  def breakable_range_by_line_index; end
+  def check_directive_line(line, line_index); end
+  def check_for_breakable_block(block_node); end
+  def check_for_breakable_node(node); end
+  def check_for_breakable_semicolons(processed_source); end
+  def check_line(line, line_index); end
+  def check_uri_line(line, line_index); end
+  def excess_range(uri_range, line, line_index); end
+  def extract_heredocs(ast); end
+  def heredocs; end
+  def highlight_start(line); end
+  def ignored_line?(line, line_index); end
+  def investigate(processed_source); end
+  def investigate_post_walk(processed_source); end
+  def line_in_heredoc?(line_number); end
+  def line_in_permitted_heredoc?(line_number); end
+  def max; end
+  def on_array(node); end
+  def on_block(node); end
+  def on_hash(node); end
+  def on_potential_breakable_node(node); end
   def on_send(node); end
-  def previous_code_line(line_number); end
-  def special_inner_call_indentation?(node); end
-  include RuboCop::Cop::Alignment
-  include RuboCop::Cop::ConfigurableEnforcedStyle
+  def register_offense(loc, line, line_index); end
+  def shebang?(line, line_index); end
+  include RuboCop::Cop::CheckLineBreakable
+  include RuboCop::Cop::ConfigurableMax
+  include RuboCop::Cop::IgnoredPattern
+  include RuboCop::Cop::LineLengthHelp
   include RuboCop::Cop::RangeHelp
 end
-class RuboCop::Cop::Layout::IndentFirstArrayElement < RuboCop::Cop::Cop
+class RuboCop::Cop::Layout::MultilineArrayBraceLayout < RuboCop::Cop::Cop
   def autocorrect(node); end
-  def base_description(left_parenthesis); end
-  def brace_alignment_style; end
-  def check(array_node, left_parenthesis); end
-  def check_right_bracket(right_bracket, left_bracket, left_parenthesis); end
-  def message(base_description); end
   def on_array(node); end
-  def on_csend(node); end
-  def on_send(node); end
-  include RuboCop::Cop::Alignment
-  include RuboCop::Cop::ConfigurableEnforcedStyle
-  include RuboCop::Cop::MultilineElementIndentation
+  include RuboCop::Cop::MultilineLiteralBraceLayout
 end
-class RuboCop::Cop::Layout::IndentFirstHashElement < RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def base_description(left_parenthesis); end
-  def brace_alignment_style; end
-  def check(hash_node, left_parenthesis); end
-  def check_based_on_longest_key(hash_node, left_brace, left_parenthesis); end
-  def check_right_brace(right_brace, left_brace, left_parenthesis); end
-  def message(base_description); end
-  def on_csend(node); end
-  def on_hash(node); end
-  def on_send(node); end
-  def separator_style?(first_pair); end
-  include RuboCop::Cop::Alignment
-  include RuboCop::Cop::ConfigurableEnforcedStyle
-  include RuboCop::Cop::MultilineElementIndentation
-end
-class RuboCop::Cop::Layout::IndentFirstParameter < RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def base_description(_); end
-  def brace_alignment_style; end
-  def check(def_node); end
-  def message(base_description); end
-  def on_def(node); end
-  def on_defs(node); end
-  include RuboCop::Cop::Alignment
-  include RuboCop::Cop::ConfigurableEnforcedStyle
-  include RuboCop::Cop::MultilineElementIndentation
-end
-class RuboCop::Cop::Layout::IndentHeredoc < RuboCop::Cop::Cop
-  def adjust_minus(corrector, node); end
-  def adjust_squiggly(corrector, node); end
-  def autocorrect(node); end
-  def base_indent_level(node); end
-  def check_style!; end
-  def correct_by_library(node); end
-  def correct_by_squiggly(node); end
-  def heredoc_body(node); end
-  def heredoc_end(node); end
-  def heredoc_indent_type(node); end
-  def indent_level(str); end
-  def indentation_width; end
-  def indented_body(node); end
-  def indented_end(node); end
-  def library_message(indentation_width, method); end
-  def line_too_long?(node); end
-  def longest_line(lines); end
-  def max_line_length; end
-  def message(node); end
-  def on_heredoc(node); end
-  def ruby23_message(indentation_width, current_indent_type); end
-  def ruby23_type_message(indentation_width, current_indent_type); end
-  def ruby23_width_message(indentation_width); end
-  def unlimited_heredoc_length?; end
-  include RuboCop::Cop::ConfigurableEnforcedStyle
-  include RuboCop::Cop::Heredoc
-end
-class RuboCop::Cop::Layout::InitialIndentation < RuboCop::Cop::Cop
-  def autocorrect(range); end
-  def first_token; end
-  def investigate(_processed_source); end
-  def space_before(token); end
-  include RuboCop::Cop::RangeHelp
-end
-class RuboCop::Cop::Layout::LeadingBlankLines < RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def investigate(processed_source); end
-end
-class RuboCop::Cop::Layout::LeadingCommentSpace < RuboCop::Cop::Cop
-  def allow_doxygen_comment?; end
-  def allowed_on_first_line?(comment); end
-  def autocorrect(comment); end
-  def doxygen_comment_style?(comment); end
-  def investigate(processed_source); end
-  def rackup_config_file?; end
-  def rackup_options?(comment); end
-  def shebang?(comment); end
-  include RuboCop::Cop::RangeHelp
-end
-class RuboCop::Cop::Layout::MultilineArrayBraceLayout < RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def on_array(node); end
-  include RuboCop::Cop::MultilineLiteralBraceLayout
-end
-class RuboCop::Cop::Layout::MultilineArrayLineBreaks < RuboCop::Cop::Cop
+class RuboCop::Cop::Layout::MultilineArrayLineBreaks < RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_array(node); end
   include RuboCop::Cop::MultilineElementLineBreaks
@@ -2991,7 +3175,8 @@ class RuboCop::Cop::Layout::MultilineBlockLayout < RuboCop::Cop::Cop
   def autocorrect(node); end
   def autocorrect_arguments(corrector, node); end
   def autocorrect_body(corrector, node, block_body); end
-  def block_arg_string(args); end
+  def block_arg_string(node, args); end
+  def include_trailing_comma?(args); end
   def line_break_necessary_in_args?(node); end
   def on_block(node); end
   include RuboCop::Cop::RangeHelp
@@ -2999,7 +3184,6 @@ end
 class RuboCop::Cop::Layout::MultilineHashBraceLayout < RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_hash(node); end
-  def self.autocorrect_incompatible_with; end
   include RuboCop::Cop::MultilineLiteralBraceLayout
 end
 class RuboCop::Cop::Layout::MultilineHashKeyLineBreaks < RuboCop::Cop::Cop
@@ -3065,6 +3249,16 @@ class RuboCop::Cop::Layout::MultilineOperationIndentation < RuboCop::Cop::Cop
   include RuboCop::Cop::ConfigurableEnforcedStyle
   include RuboCop::Cop::MultilineExpressionIndentation
 end
+class RuboCop::Cop::Layout::ParameterAlignment < RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def base_column(node, args); end
+  def fixed_indentation?; end
+  def message(_node); end
+  def on_def(node); end
+  def on_defs(node); end
+  def target_method_lineno(node); end
+  include RuboCop::Cop::Alignment
+end
 class RuboCop::Cop::Layout::RescueEnsureAlignment < RuboCop::Cop::Cop
   def access_modifier?(node); end
   def access_modifier_node(node); end
@@ -3147,6 +3341,7 @@ end
 class RuboCop::Cop::Layout::SpaceAroundKeyword < RuboCop::Cop::Cop
   def accept_left_parenthesis?(range); end
   def accept_left_square_bracket?(range); end
+  def accept_namespace_operator?(range); end
   def accepted_opening_delimiter?(range, char); end
   def autocorrect(range); end
   def check(node, locations, begin_keyword = nil); end
@@ -3154,6 +3349,7 @@ class RuboCop::Cop::Layout::SpaceAroundKeyword < RuboCop::Cop::Cop
   def check_end(node, range, begin_keyword); end
   def check_keyword(node, range); end
   def do?(node); end
+  def namespace_operator?(range, pos); end
   def offense(range, msg); end
   def on_and(node); end
   def on_block(node); end
@@ -3214,13 +3410,18 @@ class RuboCop::Cop::Layout::SpaceAroundOperators < RuboCop::Cop::Cop
   def operator_with_regular_syntax?(send_node); end
   def regular_operator?(send_node); end
   def self.autocorrect_incompatible_with; end
+  def should_not_have_surrounding_space?(operator); end
+  def space_around_exponent_operator?; end
   include RuboCop::Cop::PrecedingFollowingAlignment
   include RuboCop::Cop::RangeHelp
+  include RuboCop::Cop::RationalLiteral
 end
 class RuboCop::Cop::Layout::SpaceBeforeBlockBraces < RuboCop::Cop::Cop
   def autocorrect(range); end
+  def block_delimiters_style; end
   def check_empty(left_brace, space_plus_brace, used_style); end
   def check_non_empty(left_brace, space_plus_brace, used_style); end
+  def conflict_with_block_delimiters?(node); end
   def empty_braces?(loc); end
   def on_block(node); end
   def self.autocorrect_incompatible_with; end
@@ -3242,6 +3443,7 @@ end
 class RuboCop::Cop::Layout::SpaceBeforeFirstArg < RuboCop::Cop::Cop
   def autocorrect(range); end
   def expect_params_after_method_name?(node); end
+  def no_space_between_method_name_and_first_argument?(node); end
   def on_csend(node); end
   def on_send(node); end
   def regular_method_call_with_arguments?(node); end
@@ -3258,6 +3460,7 @@ class RuboCop::Cop::Layout::SpaceInLambdaLiteral < RuboCop::Cop::Cop
   def autocorrect(lambda_node); end
   def on_send(node); end
   def range_of_offense(node); end
+  def space_after_arrow(lambda_node); end
   def space_after_arrow?(lambda_node); end
   include RuboCop::Cop::ConfigurableEnforcedStyle
   include RuboCop::Cop::RangeHelp
@@ -3273,6 +3476,7 @@ end
 class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets < RuboCop::Cop::Cop
   def array_brackets(node); end
   def autocorrect(node); end
+  def compact(corrector, bracket, side); end
   def compact_corrections(corrector, node, left, right); end
   def compact_offense(node, token, side: nil); end
   def compact_offenses(node, left, right, start_ok, end_ok); end
@@ -3338,6 +3542,7 @@ class RuboCop::Cop::Layout::SpaceInsideParens < RuboCop::Cop::Cop
   def each_missing_space(tokens); end
   def investigate(processed_source); end
   def parens?(token1, token2); end
+  def same_line?(token1, token2); end
   include RuboCop::Cop::ConfigurableEnforcedStyle
   include RuboCop::Cop::RangeHelp
   include RuboCop::Cop::SurroundingSpace
@@ -3387,7 +3592,7 @@ class RuboCop::Cop::Layout::Tab < RuboCop::Cop::Cop
   include RuboCop::Cop::Alignment
   include RuboCop::Cop::RangeHelp
 end
-class RuboCop::Cop::Layout::TrailingBlankLines < RuboCop::Cop::Cop
+class RuboCop::Cop::Layout::TrailingEmptyLines < RuboCop::Cop::Cop
   def autocorrect(range); end
   def ends_in_end?(processed_source); end
   def investigate(processed_source); end
@@ -3481,6 +3686,10 @@ class RuboCop::Cop::Lint::DuplicateCaseCondition < RuboCop::Cop::Cop
   def on_case(case_node); end
   def repeated_condition?(previous, condition); end
 end
+class RuboCop::Cop::Lint::DuplicateHashKey < RuboCop::Cop::Cop
+  def on_hash(node); end
+  include RuboCop::Cop::Duplication
+end
 class RuboCop::Cop::Lint::DuplicateMethods < RuboCop::Cop::Cop
   def alias_method?(node = nil); end
   def attr?(node = nil); end
@@ -3503,10 +3712,6 @@ class RuboCop::Cop::Lint::DuplicateMethods < RuboCop::Cop::Cop
   def source_location(node); end
   def sym_name(node = nil); end
 end
-class RuboCop::Cop::Lint::DuplicatedKey < RuboCop::Cop::Cop
-  def on_hash(node); end
-  include RuboCop::Cop::Duplication
-end
 class RuboCop::Cop::Lint::EachWithObjectArgument < RuboCop::Cop::Cop
   def each_with_object?(node = nil); end
   def on_csend(node); end
@@ -3577,10 +3782,6 @@ class RuboCop::Cop::Lint::FormatParameterMismatch < RuboCop::Cop::Cop
   def splat_args?(node); end
   def sprintf?(node); end
 end
-class RuboCop::Cop::Lint::HandleExceptions < RuboCop::Cop::Cop
-  def comment_lines?(node); end
-  def on_resbody(node); end
-end
 class RuboCop::Cop::Lint::HeredocMethodCallPosition < RuboCop::Cop::Cop
   def all_on_same_line?(nodes); end
   def autocorrect(node); end
@@ -3674,7 +3875,7 @@ class RuboCop::Cop::Lint::MissingCopEnableDirective < RuboCop::Cop::Cop
   def message(max_range:, cop:); end
   include RuboCop::Cop::RangeHelp
 end
-class RuboCop::Cop::Lint::MultipleCompare < RuboCop::Cop::Cop
+class RuboCop::Cop::Lint::MultipleComparison < RuboCop::Cop::Cop
   def autocorrect(node); end
   def multiple_compare?(node = nil); end
   def on_send(node); end
@@ -3699,6 +3900,15 @@ class RuboCop::Cop::Lint::NextWithoutAccumulator < RuboCop::Cop::Cop
   def on_body_of_reduce(node = nil); end
   def parent_block_node(node); end
 end
+class RuboCop::Cop::Lint::NonDeterministicRequireOrder < RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def loop_variable(node = nil); end
+  def on_block(node); end
+  def unsorted_dir_block?(node = nil); end
+  def unsorted_dir_each?(node = nil); end
+  def unsorted_dir_loop?(node); end
+  def var_is_required?(node0, param1); end
+end
 class RuboCop::Cop::Lint::NonLocalExitFromIterator < RuboCop::Cop::Cop
   def chained_send?(node = nil); end
   def define_method?(node = nil); end
@@ -3748,6 +3958,70 @@ class RuboCop::Cop::Lint::RandOne < RuboCop::Cop::Cop
   def on_send(node); end
   def rand_one?(node = nil); end
 end
+class RuboCop::Cop::Lint::RedundantCopDisableDirective < RuboCop::Cop::Cop
+  def add_offense_for_entire_comment(comment, cops); end
+  def add_offense_for_some_cops(comment, cops); end
+  def add_offenses(redundant_cops); end
+  def all_cop_names; end
+  def all_disabled?(comment); end
+  def autocorrect(args); end
+  def check(offenses, cop_disabled_line_ranges, comments); end
+  def collect_variable_like_names(scope); end
+  def comment_range_with_surrounding_space(range); end
+  def cop_range(comment, cop); end
+  def describe(cop); end
+  def directive_count(comment); end
+  def directive_range_in_list(range, ranges); end
+  def each_already_disabled(line_ranges, disabled_ranges, comments); end
+  def each_line_range(line_ranges, disabled_ranges, offenses, comments, cop); end
+  def each_redundant_disable(cop_disabled_line_ranges, offenses, comments, &block); end
+  def ends_its_line?(range); end
+  def find_redundant(comment, offenses, cop, line_range, next_line_range); end
+  def ignore_offense?(disabled_ranges, line_range); end
+  def matching_range(haystack, needle); end
+  def trailing_range?(ranges, range); end
+  include RuboCop::Cop::RangeHelp
+  include RuboCop::NameSimilarity
+end
+class RuboCop::Cop::Lint::RedundantCopEnableDirective < RuboCop::Cop::Cop
+  def all_or_name(name); end
+  def autocorrect(comment_and_name); end
+  def comment_start(comment); end
+  def cop_name_indention(comment, name); end
+  def investigate(processed_source); end
+  def range_of_offense(comment, name); end
+  def range_to_remove(begin_pos, end_pos, comma_pos, comment); end
+  def range_with_comma(comment, name); end
+  include RuboCop::Cop::RangeHelp
+  include RuboCop::Cop::SurroundingSpace
+end
+class RuboCop::Cop::Lint::RedundantRequireStatement < RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def on_send(node); end
+  def unnecessary_require_statement?(node = nil); end
+  include RuboCop::Cop::RangeHelp
+end
+class RuboCop::Cop::Lint::RedundantSplatExpansion < RuboCop::Cop::Cop
+  def array_new?(node = nil); end
+  def array_new_inside_array_literal?(array_new_node); end
+  def array_splat?(node); end
+  def autocorrect(node); end
+  def literal_expansion(node = nil); end
+  def method_argument?(node); end
+  def on_splat(node); end
+  def part_of_an_array?(node); end
+  def redundant_brackets?(node); end
+  def redundant_splat_expansion(node); end
+  def remove_brackets(array); end
+  def replacement_range_and_content(node); end
+end
+class RuboCop::Cop::Lint::RedundantStringCoercion < RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def message(node); end
+  def on_interpolation(begin_node); end
+  def to_s_without_args?(node = nil); end
+  include RuboCop::Cop::Interpolation
+end
 class RuboCop::Cop::Lint::RedundantWithIndex < RuboCop::Cop::Cop
   def autocorrect(node); end
   def message(node); end
@@ -3858,12 +4132,9 @@ class RuboCop::Cop::Lint::ShadowingOuterLocalVariable < RuboCop::Cop::Cop
   def before_declaring_variable(variable, variable_table); end
   def join_force?(force_class); end
 end
-class RuboCop::Cop::Lint::StringConversionInInterpolation < RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def message(node); end
-  def on_interpolation(begin_node); end
-  def to_s_without_args?(node = nil); end
-  include RuboCop::Cop::Interpolation
+class RuboCop::Cop::Lint::SuppressedException < RuboCop::Cop::Cop
+  def comment_lines?(node); end
+  def on_resbody(node); end
 end
 class RuboCop::Cop::Lint::Syntax < RuboCop::Cop::Cop
   def add_offense_from_diagnostic(diagnostic, ruby_version); end
@@ -3902,63 +4173,6 @@ class RuboCop::Cop::Lint::UnifiedInteger < RuboCop::Cop::Cop
   def fixnum_or_bignum_const(node = nil); end
   def on_const(node); end
 end
-class RuboCop::Cop::Lint::UnneededCopDisableDirective < RuboCop::Cop::Cop
-  def add_offense_for_entire_comment(comment, cops); end
-  def add_offense_for_some_cops(comment, cops); end
-  def add_offenses(unneeded_cops); end
-  def all_cop_names; end
-  def all_disabled?(comment); end
-  def autocorrect(args); end
-  def check(offenses, cop_disabled_line_ranges, comments); end
-  def collect_variable_like_names(scope); end
-  def comment_range_with_surrounding_space(range); end
-  def cop_range(comment, cop); end
-  def describe(cop); end
-  def directive_count(comment); end
-  def directive_range_in_list(range, ranges); end
-  def each_already_disabled(line_ranges, disabled_ranges, comments); end
-  def each_line_range(line_ranges, disabled_ranges, offenses, comments, cop); end
-  def each_unneeded_disable(cop_disabled_line_ranges, offenses, comments, &block); end
-  def ends_its_line?(range); end
-  def find_unneeded(comment, offenses, cop, line_range, next_line_range); end
-  def ignore_offense?(disabled_ranges, line_range); end
-  def matching_range(haystack, needle); end
-  def trailing_range?(ranges, range); end
-  include RuboCop::Cop::RangeHelp
-  include RuboCop::NameSimilarity
-end
-class RuboCop::Cop::Lint::UnneededCopEnableDirective < RuboCop::Cop::Cop
-  def all_or_name(name); end
-  def autocorrect(comment_and_name); end
-  def comment_start(comment); end
-  def cop_name_indention(comment, name); end
-  def investigate(processed_source); end
-  def range_of_offense(comment, name); end
-  def range_to_remove(begin_pos, end_pos, comma_pos, comment); end
-  def range_with_comma(comment, name); end
-  include RuboCop::Cop::RangeHelp
-  include RuboCop::Cop::SurroundingSpace
-end
-class RuboCop::Cop::Lint::UnneededRequireStatement < RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def on_send(node); end
-  def unnecessary_require_statement?(node = nil); end
-  include RuboCop::Cop::RangeHelp
-end
-class RuboCop::Cop::Lint::UnneededSplatExpansion < RuboCop::Cop::Cop
-  def array_new?(node = nil); end
-  def array_new_inside_array_literal?(array_new_node); end
-  def array_splat?(node); end
-  def autocorrect(node); end
-  def literal_expansion(node = nil); end
-  def method_argument?(node); end
-  def on_splat(node); end
-  def part_of_an_array?(node); end
-  def remove_brackets(array); end
-  def replacement_range_and_content(node); end
-  def unneeded_brackets?(node); end
-  def unneeded_splat_expansion(node); end
-end
 class RuboCop::Cop::Lint::UnreachableCode < RuboCop::Cop::Cop
   def check_case(node); end
   def check_if(node); end
@@ -4085,10 +4299,13 @@ end
 module RuboCop::Cop::Metrics::Utils
 end
 class RuboCop::Cop::Metrics::Utils::AbcSizeCalculator
+  def branch?(node); end
   def calculate; end
+  def condition?(node); end
+  def else_branch?(node); end
   def evaluate_branch_nodes(node); end
+  def evaluate_condition_node(node); end
   def initialize(node); end
-  def node_has_else_branch?(node); end
   def self.calculate(node); end
 end
 class RuboCop::Cop::Metrics::AbcSize < RuboCop::Cop::Cop
@@ -4117,49 +4334,6 @@ class RuboCop::Cop::Metrics::ClassLength < RuboCop::Cop::Cop
   def on_class(node); end
   include RuboCop::Cop::ClassishLength
 end
-class RuboCop::Cop::Metrics::LineLength < RuboCop::Cop::Cop
-  def allow_heredoc?; end
-  def allow_uri?; end
-  def allowed_heredoc; end
-  def allowed_uri_position?(line, uri_range); end
-  def autocorrect(range); end
-  def breakable_nodes_by_line_index; end
-  def breakable_range(line, line_index); end
-  def breakable_semicolon_range(line, line_index); end
-  def check_directive_line(line, line_index); end
-  def check_for_breakable_node(node); end
-  def check_line(line, line_index); end
-  def check_uri_line(line, line_index); end
-  def directive_on_source_line?(line_index); end
-  def excess_range(uri_range, line, line_index); end
-  def extract_heredocs(ast); end
-  def find_excessive_uri_range(line); end
-  def heredocs; end
-  def highlight_start(line); end
-  def ignore_cop_directives?; end
-  def ignored_line?(line, line_index); end
-  def indentation_difference(line); end
-  def investigate_post_walk(processed_source); end
-  def line_in_heredoc?(line_number); end
-  def line_in_permitted_heredoc?(line_number); end
-  def line_length(line); end
-  def line_length_without_directive(line); end
-  def match_uris(string); end
-  def max; end
-  def on_array(node); end
-  def on_hash(node); end
-  def on_potential_breakable_node(node); end
-  def on_send(node); end
-  def register_offense(loc, line, line_index); end
-  def shebang?(line, line_index); end
-  def tab_indentation_width; end
-  def uri_regexp; end
-  def valid_uri?(uri_ish_string); end
-  include RuboCop::Cop::CheckLineBreakable
-  include RuboCop::Cop::ConfigurableMax
-  include RuboCop::Cop::IgnoredPattern
-  include RuboCop::Cop::RangeHelp
-end
 class RuboCop::Cop::Metrics::MethodLength < RuboCop::Cop::Cop
   def cop_label; end
   def on_block(node); end
@@ -4202,6 +4376,10 @@ class RuboCop::Cop::Naming::AsciiIdentifiers < RuboCop::Cop::Cop
   def investigate(processed_source); end
   include RuboCop::Cop::RangeHelp
 end
+class RuboCop::Cop::Naming::BlockParameterName < RuboCop::Cop::Cop
+  def on_block(node); end
+  include RuboCop::Cop::UncommunicativeName
+end
 class RuboCop::Cop::Naming::ClassAndModuleCamelCase < RuboCop::Cop::Cop
   def on_class(node); end
   def on_module(node); end
@@ -4217,6 +4395,7 @@ class RuboCop::Cop::Naming::ConstantName < RuboCop::Cop::Cop
 end
 class RuboCop::Cop::Naming::FileName < RuboCop::Cop::Cop
   def allowed_acronyms; end
+  def bad_filename_allowed?; end
   def expect_matching_definition?; end
   def filename_good?(basename); end
   def find_class_or_module(node, namespace); end
@@ -4226,6 +4405,7 @@ class RuboCop::Cop::Naming::FileName < RuboCop::Cop::Cop
   def match?(expected); end
   def match_acronym?(expected, name); end
   def match_namespace(node, namespace, expected); end
+  def matching_definition?(file_path); end
   def no_definition_message(basename, file_path); end
   def other_message(basename); end
   def partial_matcher!(expected); end
@@ -4243,7 +4423,7 @@ class RuboCop::Cop::Naming::HeredocDelimiterCase < RuboCop::Cop::Cop
   include RuboCop::Cop::Heredoc
 end
 class RuboCop::Cop::Naming::HeredocDelimiterNaming < RuboCop::Cop::Cop
-  def blacklisted_delimiters; end
+  def forbidden_delimiters; end
   def meaningful_delimiters?(node); end
   def on_heredoc(node); end
   include RuboCop::Cop::Heredoc
@@ -4267,6 +4447,11 @@ class RuboCop::Cop::Naming::MethodName < RuboCop::Cop::Cop
   include RuboCop::Cop::ConfigurableNaming
   include RuboCop::Cop::IgnoredPattern
 end
+class RuboCop::Cop::Naming::MethodParameterName < RuboCop::Cop::Cop
+  def on_def(node); end
+  def on_defs(node); end
+  include RuboCop::Cop::UncommunicativeName
+end
 class RuboCop::Cop::Naming::BinaryOperatorParameterName < RuboCop::Cop::Cop
   def on_def(node); end
   def op_method?(name); end
@@ -4274,16 +4459,16 @@ class RuboCop::Cop::Naming::BinaryOperatorParameterName < RuboCop::Cop::Cop
 end
 class RuboCop::Cop::Naming::PredicateName < RuboCop::Cop::Cop
   def allowed_method_name?(method_name, prefix); end
+  def allowed_methods; end
   def dynamic_method_define(node = nil); end
   def expected_name(method_name, prefix); end
+  def forbidden_prefixes; end
   def message(method_name, new_name); end
   def method_definition_macros(macro_name); end
   def on_def(node); end
   def on_defs(node); end
   def on_send(node); end
   def predicate_prefixes; end
-  def predicate_whitelist; end
-  def prefix_blacklist; end
 end
 class RuboCop::Cop::Naming::RescuedExceptionsVariableName < RuboCop::Cop::Cop
   def autocorrect(node); end
@@ -4293,15 +4478,6 @@ class RuboCop::Cop::Naming::RescuedExceptionsVariableName < RuboCop::Cop::Cop
   def preferred_name(variable_name); end
   def variable_name(node); end
 end
-class RuboCop::Cop::Naming::UncommunicativeBlockParamName < RuboCop::Cop::Cop
-  def on_block(node); end
-  include RuboCop::Cop::UncommunicativeName
-end
-class RuboCop::Cop::Naming::UncommunicativeMethodParamName < RuboCop::Cop::Cop
-  def on_def(node); end
-  def on_defs(node); end
-  include RuboCop::Cop::UncommunicativeName
-end
 class RuboCop::Cop::Naming::VariableName < RuboCop::Cop::Cop
   def message(style); end
   def on_arg(node); end
@@ -4387,6 +4563,7 @@ class RuboCop::Cop::Style::AsciiComments < RuboCop::Cop::Cop
 end
 class RuboCop::Cop::Style::Attr < RuboCop::Cop::Cop
   def autocorrect(node); end
+  def class_eval?(node = nil); end
   def message(node); end
   def on_send(node); end
   def replacement_method(node); end
@@ -4421,6 +4598,9 @@ class RuboCop::Cop::Style::BlockDelimiters < RuboCop::Cop::Cop
   def autocorrect(node); end
   def braces_for_chaining_message(node); end
   def braces_for_chaining_style?(node); end
+  def braces_required_message(node); end
+  def braces_required_method?(method_name); end
+  def braces_required_methods; end
   def braces_style?(node); end
   def conditional?(node); end
   def correction_would_break_code?(node); end
@@ -4441,34 +4621,13 @@ class RuboCop::Cop::Style::BlockDelimiters < RuboCop::Cop::Cop
   def return_value_used?(node); end
   def semantic_block_style?(node); end
   def semantic_message(node); end
+  def special_method?(method_name); end
+  def special_method_proper_block_style?(node); end
   def whitespace_after?(range, length = nil); end
   def whitespace_before?(range); end
   include RuboCop::Cop::ConfigurableEnforcedStyle
   include RuboCop::Cop::IgnoredMethods
 end
-class RuboCop::Cop::Style::BracesAroundHashParameters < RuboCop::Cop::Cop
-  def add_arg_offense(arg, type); end
-  def add_braces(corrector, node); end
-  def autocorrect(send_node); end
-  def braces_needed_for_semantics?(arg); end
-  def check(arg, args); end
-  def check_braces(arg); end
-  def check_context_dependent(arg, args); end
-  def check_no_braces(arg); end
-  def extra_left_space?(hash_node); end
-  def extra_right_space?(hash_node); end
-  def extra_space(hash_node); end
-  def left_brace_and_space(loc_begin, space); end
-  def left_whole_line_range(loc_begin); end
-  def on_csend(node); end
-  def on_send(node); end
-  def remove_braces_with_range(corrector, left_range, right_range); end
-  def remove_braces_with_whitespace(corrector, node, space); end
-  def right_brace_and_space(loc_end, space); end
-  def right_whole_line_range(loc_end); end
-  include RuboCop::Cop::ConfigurableEnforcedStyle
-  include RuboCop::Cop::RangeHelp
-end
 class RuboCop::Cop::Style::CaseEquality < RuboCop::Cop::Cop
   def case_equality?(node = nil); end
   def on_send(node); end
@@ -4559,7 +4718,7 @@ class RuboCop::Cop::Style::CommandLiteral < RuboCop::Cop::Cop
   include RuboCop::Cop::ConfigurableEnforcedStyle
 end
 class RuboCop::Cop::Style::CommentAnnotation < RuboCop::Cop::Cop
-  def annotation_range(comment, margin, length); end
+  def annotation_range(comment, margin, first_word, colon, space); end
   def autocorrect(comment); end
   def concat_length(*args); end
   def correct_annotation?(first_word, colon, space, note); end
@@ -4676,6 +4835,7 @@ class RuboCop::Cop::Style::Copyright < RuboCop::Cop::Cop
   def notice; end
   def notice_found?(processed_source); end
   def shebang_token?(processed_source, token_index); end
+  def verify_autocorrect_notice!; end
   include RuboCop::Cop::RangeHelp
 end
 class RuboCop::Cop::Style::DateTime < RuboCop::Cop::Cop
@@ -4903,15 +5063,19 @@ class RuboCop::Cop::Style::FormatStringToken < RuboCop::Cop::Cop
 end
 class RuboCop::Cop::Style::FrozenStringLiteralComment < RuboCop::Cop::Cop
   def autocorrect(node); end
-  def check_for_comment(processed_source); end
-  def check_for_no_comment(processed_source); end
+  def disabled_offense(processed_source); end
+  def enable_comment(corrector); end
+  def ensure_comment(processed_source); end
+  def ensure_enabled_comment(processed_source); end
+  def ensure_no_comment(processed_source); end
   def following_comment; end
   def frozen_string_literal_comment(processed_source); end
   def insert_comment(corrector); end
   def investigate(processed_source); end
   def last_special_comment(processed_source); end
   def line_range(line); end
-  def offense(processed_source); end
+  def missing_offense(processed_source); end
+  def missing_true_offense(processed_source); end
   def preceding_comment; end
   def remove_comment(corrector, node); end
   def unnecessary_comment_offense(processed_source); end
@@ -4939,6 +5103,19 @@ class RuboCop::Cop::Style::GuardClause < RuboCop::Cop::Cop
   include RuboCop::Cop::MinBodyLength
   include RuboCop::Cop::StatementModifier
 end
+class RuboCop::Cop::Style::HashEachMethods < RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def check_argument(variable); end
+  def correct_args(node, corrector); end
+  def correct_implicit(node, corrector, method_name); end
+  def correct_key_value_each(node, corrector); end
+  def kv_each(node = nil); end
+  def kv_range(outer_node); end
+  def on_block(node); end
+  def register_kv_offense(node); end
+  def used?(arg); end
+  include RuboCop::Cop::Lint::UnusedArgument
+end
 class RuboCop::Cop::Style::HashSyntax < RuboCop::Cop::Cop
   def acceptable_19_syntax_symbol?(sym_name); end
   def alternative_style; end
@@ -4959,6 +5136,24 @@ class RuboCop::Cop::Style::HashSyntax < RuboCop::Cop::Cop
   include RuboCop::Cop::ConfigurableEnforcedStyle
   include RuboCop::Cop::RangeHelp
 end
+class RuboCop::Cop::Style::HashTransformKeys < RuboCop::Cop::Cop
+  def extract_captures(match); end
+  def new_method_name; end
+  def on_bad_each_with_object(node = nil); end
+  def on_bad_hash_brackets_map(node = nil); end
+  def on_bad_map_to_h(node = nil); end
+  extend RuboCop::Cop::TargetRubyVersion
+  include RuboCop::Cop::HashTransformMethod
+end
+class RuboCop::Cop::Style::HashTransformValues < RuboCop::Cop::Cop
+  def extract_captures(match); end
+  def new_method_name; end
+  def on_bad_each_with_object(node = nil); end
+  def on_bad_hash_brackets_map(node = nil); end
+  def on_bad_map_to_h(node = nil); end
+  extend RuboCop::Cop::TargetRubyVersion
+  include RuboCop::Cop::HashTransformMethod
+end
 class RuboCop::Cop::Style::IdenticalConditionalBranches < RuboCop::Cop::Cop
   def check_branches(branches); end
   def check_expressions(expressions); end
@@ -4978,13 +5173,20 @@ class RuboCop::Cop::Style::IfUnlessModifier < RuboCop::Cop::Cop
   def autocorrect(node); end
   def eligible_node?(node); end
   def first_line_comment(node); end
+  def ignored_patterns; end
+  def line_length_enabled_at_line?(line); end
   def named_capture_in_condition?(node); end
   def non_eligible_if?(node); end
   def on_if(node); end
   def parenthesize?(node); end
   def to_modifier_form(node); end
   def to_normal_form(node); end
+  def too_long_line_based_on_allow_uri?(line); end
+  def too_long_line_based_on_config?(range, line); end
+  def too_long_line_based_on_ignore_cop_directives?(range, line); end
   def too_long_single_line?(node); end
+  include RuboCop::Cop::IgnoredPattern
+  include RuboCop::Cop::LineLengthHelp
   include RuboCop::Cop::StatementModifier
 end
 class RuboCop::Cop::Style::IfUnlessModifierOfIfUnless < RuboCop::Cop::Cop
@@ -5021,6 +5223,7 @@ class RuboCop::Cop::Style::InverseMethods < RuboCop::Cop::Cop
   def autocorrect(node); end
   def camel_case_constant?(node); end
   def correct_inverse_block(node); end
+  def correct_inverse_method(node); end
   def correct_inverse_selector(block, corrector); end
   def dot_range(loc); end
   def end_parentheses(node, method_call); end
@@ -5041,13 +5244,13 @@ class RuboCop::Cop::Style::InlineComment < RuboCop::Cop::Cop
   def investigate(processed_source); end
 end
 class RuboCop::Cop::Style::IpAddresses < RuboCop::Cop::Cop
+  def allowed_addresses; end
   def correct_style_detected; end
   def could_be_ip?(str); end
   def offense?(node); end
   def opposite_style_detected; end
   def starts_with_hex_or_colon?(str); end
   def too_long?(str); end
-  def whitelist; end
   include RuboCop::Cop::StringHelp
 end
 class RuboCop::Cop::Style::Lambda < RuboCop::Cop::Cop
@@ -5080,6 +5283,7 @@ class RuboCop::Cop::Style::LineEndConcatenation < RuboCop::Cop::Cop
   def eligible_operator?(operator); end
   def eligible_predecessor?(predecessor); end
   def eligible_successor?(successor); end
+  def eligible_token_set?(predecessor, operator, successor); end
   def investigate(processed_source); end
   def self.autocorrect_incompatible_with; end
   def standard_string_literal?(token); end
@@ -5096,30 +5300,30 @@ class RuboCop::Cop::Style::MethodCallWithoutArgsParentheses < RuboCop::Cop::Cop
   include RuboCop::Cop::IgnoredMethods
 end
 class RuboCop::Cop::Style::MethodCallWithArgsParentheses < RuboCop::Cop::Cop
-  def add_offense_for_omit_parentheses(node); end
-  def add_offense_for_require_parentheses(node); end
+  def args_begin(node); end
+  def args_end(node); end
+  def args_parenthesized?(node); end
+  def autocorrect(_node); end
+  def initialize(*arg0); end
+  include RuboCop::Cop::ConfigurableEnforcedStyle
+  include RuboCop::Cop::IgnoredMethods
+  include RuboCop::Cop::IgnoredPattern
+end
+module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses
   def allowed_camel_case_method_call?(node); end
   def allowed_chained_call_with_parentheses?(node); end
   def allowed_multiline_call_with_parentheses?(node); end
   def ambigious_literal?(node); end
-  def args_begin(node); end
-  def args_end(node); end
-  def args_parenthesized?(node); end
   def assigned_before?(node, target); end
   def autocorrect(node); end
-  def autocorrect_for_omit_parentheses(node); end
-  def autocorrect_for_require_parentheses(node); end
   def call_as_argument_or_chain?(node); end
   def call_in_literals?(node); end
   def call_in_logical_operators?(node); end
   def call_in_optional_arguments?(node); end
   def call_with_ambiguous_arguments?(node); end
   def call_with_braced_block?(node); end
-  def eligible_for_parentheses_omission?(node); end
   def hash_literal?(node); end
   def hash_literal_in_arguments?(node); end
-  def ignored_macro?(node); end
-  def included_macros_list; end
   def legitimate_call_with_parentheses?(node); end
   def logical_operator?(node); end
   def message(_node = nil); end
@@ -5133,9 +5337,17 @@ class RuboCop::Cop::Style::MethodCallWithArgsParentheses < RuboCop::Cop::Cop
   def super_call_without_arguments?(node); end
   def ternary_if?(node); end
   def unary_literal?(node); end
-  include RuboCop::Cop::ConfigurableEnforcedStyle
-  include RuboCop::Cop::IgnoredMethods
-  include RuboCop::Cop::IgnoredPattern
+end
+module RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses
+  def autocorrect(node); end
+  def eligible_for_parentheses_omission?(node); end
+  def ignored_macro?(node); end
+  def included_macros_list; end
+  def message(_node = nil); end
+  def on_csend(node); end
+  def on_send(node); end
+  def on_super(node); end
+  def on_yield(node); end
 end
 class RuboCop::Cop::Style::MethodCalledOnDoEndBlock < RuboCop::Cop::Cop
   def on_block(node); end
@@ -5146,6 +5358,8 @@ end
 class RuboCop::Cop::Style::MethodDefParentheses < RuboCop::Cop::Cop
   def arguments_without_parentheses?(node); end
   def autocorrect(node); end
+  def correct_arguments(arg_node, corrector); end
+  def correct_definition(def_node, corrector); end
   def missing_parentheses(node); end
   def on_def(node); end
   def on_defs(node); end
@@ -5266,6 +5480,7 @@ class RuboCop::Cop::Style::MultilineTernaryOperator < RuboCop::Cop::Cop
   def on_if(node); end
 end
 class RuboCop::Cop::Style::MultilineWhenThen < RuboCop::Cop::Cop
+  def accept_node_type?(node); end
   def autocorrect(node); end
   def on_when(node); end
   include RuboCop::Cop::RangeHelp
@@ -5329,7 +5544,7 @@ class RuboCop::Cop::Style::NestedModifier < RuboCop::Cop::Cop
   def check(node); end
   def left_hand_operand(node, operator); end
   def modifier?(node); end
-  def new_expression(outer_node, inner_node); end
+  def new_expression(inner_node); end
   def on_if(node); end
   def on_until(node); end
   def on_while(node); end
@@ -5339,12 +5554,12 @@ class RuboCop::Cop::Style::NestedModifier < RuboCop::Cop::Cop
   include RuboCop::Cop::RangeHelp
 end
 class RuboCop::Cop::Style::NestedParenthesizedCalls < RuboCop::Cop::Cop
+  def allowed?(send_node); end
+  def allowed_methods; end
   def allowed_omission?(send_node); end
   def autocorrect(nested); end
   def on_csend(node); end
   def on_send(node); end
-  def whitelisted?(send_node); end
-  def whitelisted_methods; end
   include RuboCop::Cop::RangeHelp
 end
 class RuboCop::Cop::Style::NestedTernaryOperator < RuboCop::Cop::Cop
@@ -5484,11 +5699,11 @@ class RuboCop::Cop::Style::OrAssignment < RuboCop::Cop::Cop
   def unless_assignment?(node = nil); end
 end
 class RuboCop::Cop::Style::OptionHash < RuboCop::Cop::Cop
+  def allowlist; end
   def on_args(node); end
   def option_hash(node = nil); end
   def super_used?(node); end
   def suspicious_name?(arg_name); end
-  def whitelist; end
 end
 class RuboCop::Cop::Style::OptionalArguments < RuboCop::Cop::Cop
   def argument_positions(arguments); end
@@ -5560,6 +5775,7 @@ class RuboCop::Cop::Style::ParenthesesAroundCondition < RuboCop::Cop::Cop
 end
 class RuboCop::Cop::Style::PercentLiteralDelimiters < RuboCop::Cop::Cop
   def autocorrect(node); end
+  def contains_delimiter?(node, delimiters); end
   def contains_preferred_delimiter?(node, type); end
   def include_same_character_as_used_for_delimiter?(node, type); end
   def matchpairs(begin_delimiter); end
@@ -5638,6 +5854,24 @@ class RuboCop::Cop::Style::RedundantBegin < RuboCop::Cop::Cop
   def on_def(node); end
   def on_defs(node); end
 end
+class RuboCop::Cop::Style::RedundantCapitalW < RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def on_array(node); end
+  def on_percent_literal(node); end
+  def requires_interpolation?(node); end
+  include RuboCop::Cop::PercentLiteral
+end
+class RuboCop::Cop::Style::RedundantCondition < RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def else_source(else_branch); end
+  def make_ternary_form(node); end
+  def message(node); end
+  def offense?(node); end
+  def on_if(node); end
+  def range_of_offense(node); end
+  def use_if_branch?(else_branch); end
+  include RuboCop::Cop::RangeHelp
+end
 class RuboCop::Cop::Style::RedundantConditional < RuboCop::Cop::Cop
   def autocorrect(node); end
   def configured_indentation_width; end
@@ -5665,6 +5899,21 @@ class RuboCop::Cop::Style::RedundantFreeze < RuboCop::Cop::Cop
   def strip_parenthesis(node); end
   include RuboCop::Cop::FrozenStringLiteral
 end
+class RuboCop::Cop::Style::RedundantInterpolation < RuboCop::Cop::Cop
+  def autocorrect(node); end
+  def autocorrect_other(embedded_node, node); end
+  def autocorrect_single_variable_interpolation(embedded_node, node); end
+  def autocorrect_variable_interpolation(embedded_node, node); end
+  def embedded_in_percent_array?(node); end
+  def implicit_concatenation?(node); end
+  def interpolation?(node); end
+  def on_dstr(node); end
+  def self.autocorrect_incompatible_with; end
+  def single_interpolation?(node); end
+  def single_variable_interpolation?(node); end
+  def variable_interpolation?(node); end
+  include RuboCop::Cop::PercentLiteral
+end
 class RuboCop::Cop::Style::RedundantParentheses < RuboCop::Cop::Cop
   def allowed_ancestor?(node); end
   def allowed_array_or_hash_element?(node); end
@@ -5702,11 +5951,23 @@ class RuboCop::Cop::Style::RedundantParentheses < RuboCop::Cop::Cop
   def suspect_unary?(node); end
   include RuboCop::Cop::Parentheses
 end
+class RuboCop::Cop::Style::RedundantPercentQ < RuboCop::Cop::Cop
+  def acceptable_capital_q?(node); end
+  def acceptable_q?(node); end
+  def allowed_percent_q?(node); end
+  def autocorrect(node); end
+  def check(node); end
+  def interpolated_quotes?(node); end
+  def message(node); end
+  def on_dstr(node); end
+  def on_str(node); end
+  def start_with_percent_q_variant?(string); end
+  def string_literal?(node); end
+end
 class RuboCop::Cop::Style::RedundantReturn < RuboCop::Cop::Cop
   def add_braces(corrector, node); end
   def add_brackets(corrector, node); end
   def allow_multiple_return_values?; end
-  def arguments?(args); end
   def autocorrect(node); end
   def check_begin_node(node); end
   def check_branch(node); end
@@ -5715,6 +5976,9 @@ class RuboCop::Cop::Style::RedundantReturn < RuboCop::Cop::Cop
   def check_if_node(node); end
   def check_rescue_node(node); end
   def check_return_node(node); end
+  def correct_with_arguments(return_node, corrector); end
+  def correct_without_arguments(return_node, corrector); end
+  def hash_without_braces?(node); end
   def message(node); end
   def on_def(node); end
   def on_defs(node); end
@@ -5743,6 +6007,19 @@ class RuboCop::Cop::Style::RedundantSelf < RuboCop::Cop::Cop
   def regular_method_call?(node); end
   def self.autocorrect_incompatible_with; end
 end
+class RuboCop::Cop::Style::RedundantSort < RuboCop::Cop::Cop
+  def accessor_start(node); end
+  def arg_node(node); end
+  def arg_value(node); end
+  def autocorrect(node); end
+  def base(accessor, arg); end
+  def message(node, sorter, accessor); end
+  def on_send(node); end
+  def redundant_sort?(node = nil); end
+  def suffix(sorter); end
+  def suggestion(sorter, accessor, arg); end
+  include RuboCop::Cop::RangeHelp
+end
 class RuboCop::Cop::Style::RedundantSortBy < RuboCop::Cop::Cop
   def autocorrect(node); end
   def on_block(node); end
@@ -5817,6 +6094,7 @@ class RuboCop::Cop::Style::SafeNavigation < RuboCop::Cop::Cop
   def extract_parts_from_if(node); end
   def find_matching_receiver_invocation(method_chain, checked_variable); end
   def handle_comments(corrector, node, method_call); end
+  def method_call(node); end
   def method_called?(send_node); end
   def modifier_if_safe_navigation_candidate(node = nil); end
   def negated?(send_node); end
@@ -6064,8 +6342,6 @@ class RuboCop::Cop::Style::TrailingBodyOnModule < RuboCop::Cop::Cop
 end
 class RuboCop::Cop::Style::TrailingCommaInArguments < RuboCop::Cop::Cop
   def autocorrect(range); end
-  def avoid_autocorrect?(args); end
-  def braces_will_be_removed?(args); end
   def on_csend(node); end
   def on_send(node); end
   def self.autocorrect_incompatible_with; end
@@ -6114,6 +6390,7 @@ class RuboCop::Cop::Style::TrivialAccessors < RuboCop::Cop::Cop
   def allow_dsl_writers?; end
   def allow_predicates?; end
   def allowed_method?(node); end
+  def allowed_methods; end
   def allowed_reader?(node); end
   def allowed_writer?(method_name); end
   def autocorrect(node); end
@@ -6133,7 +6410,6 @@ class RuboCop::Cop::Style::TrivialAccessors < RuboCop::Cop::Cop
   def trivial_accessor_kind(node); end
   def trivial_reader?(node); end
   def trivial_writer?(node); end
-  def whitelist; end
 end
 class RuboCop::Cop::Style::UnlessElse < RuboCop::Cop::Cop
   def autocorrect(node); end
@@ -6142,65 +6418,6 @@ class RuboCop::Cop::Style::UnlessElse < RuboCop::Cop::Cop
   def range_between_else_and_end(node); end
   include RuboCop::Cop::RangeHelp
 end
-class RuboCop::Cop::Style::UnneededCapitalW < RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def on_array(node); end
-  def on_percent_literal(node); end
-  def requires_interpolation?(node); end
-  include RuboCop::Cop::PercentLiteral
-end
-class RuboCop::Cop::Style::UnneededCondition < RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def else_source(else_branch); end
-  def make_ternary_form(node); end
-  def message(node); end
-  def offense?(node); end
-  def on_if(node); end
-  def range_of_offense(node); end
-  def use_if_branch?(else_branch); end
-  include RuboCop::Cop::RangeHelp
-end
-class RuboCop::Cop::Style::UnneededInterpolation < RuboCop::Cop::Cop
-  def autocorrect(node); end
-  def autocorrect_other(embedded_node, node); end
-  def autocorrect_single_variable_interpolation(embedded_node, node); end
-  def autocorrect_variable_interpolation(embedded_node, node); end
-  def embedded_in_percent_array?(node); end
-  def implicit_concatenation?(node); end
-  def interpolation?(node); end
-  def on_dstr(node); end
-  def self.autocorrect_incompatible_with; end
-  def single_interpolation?(node); end
-  def single_variable_interpolation?(node); end
-  def variable_interpolation?(node); end
-  include RuboCop::Cop::PercentLiteral
-end
-class RuboCop::Cop::Style::UnneededPercentQ < RuboCop::Cop::Cop
-  def acceptable_capital_q?(node); end
-  def acceptable_q?(node); end
-  def allowed_percent_q?(node); end
-  def autocorrect(node); end
-  def check(node); end
-  def interpolated_quotes?(node); end
-  def message(node); end
-  def on_dstr(node); end
-  def on_str(node); end
-  def start_with_percent_q_variant?(string); end
-  def string_literal?(node); end
-end
-class RuboCop::Cop::Style::UnneededSort < RuboCop::Cop::Cop
-  def accessor_start(node); end
-  def arg_node(node); end
-  def arg_value(node); end
-  def autocorrect(node); end
-  def base(accessor, arg); end
-  def message(node, sorter, accessor); end
-  def on_send(node); end
-  def suffix(sorter); end
-  def suggestion(sorter, accessor, arg); end
-  def unneeded_sort?(node = nil); end
-  include RuboCop::Cop::RangeHelp
-end
 class RuboCop::Cop::Style::UnpackFirst < RuboCop::Cop::Cop
   def autocorrect(node); end
   def first_element_range(node, unpack_call); end
@@ -6252,11 +6469,14 @@ class RuboCop::Cop::Style::YodaCondition < RuboCop::Cop::Cop
   def corrected_code(node); end
   def enforce_yoda?; end
   def equality_only?; end
+  def file_constant_equal_program_name?(node = nil); end
   def message(node); end
   def non_equality_operator?(node); end
   def noncommutative_operator?(node); end
   def on_send(node); end
+  def program_name?(name); end
   def reverse_comparison(operator); end
+  def source_file_path_constant?(node); end
   def valid_yoda?(node); end
   def yoda_compatible_condition?(node); end
   include RuboCop::Cop::ConfigurableEnforcedStyle
@@ -6312,6 +6532,7 @@ class RuboCop::Cop::Team
   def cops; end
   def debug?; end
   def errors; end
+  def external_dependency_checksum; end
   def forces; end
   def forces_for(cops); end
   def handle_error(error, location, cop); end
@@ -6495,6 +6716,12 @@ class RuboCop::Formatter::JSONFormatter < RuboCop::Formatter::BaseFormatter
   def started(target_files); end
   include RuboCop::PathUtil
 end
+class RuboCop::Formatter::JUnitFormatter < RuboCop::Formatter::BaseFormatter
+  def add_failure_to(testcase, offenses, cop_name); end
+  def file_finished(file, offenses); end
+  def finished(_inspected_files); end
+  def initialize(output, options = nil); end
+end
 class RuboCop::Formatter::OffenseCountFormatter < RuboCop::Formatter::BaseFormatter
   def file_finished(_file, offenses); end
   def finished(_inspected_files); end
@@ -6589,6 +6816,7 @@ class RuboCop::Config
   def for_cop(cop); end
   def for_department(department_name); end
   def initialize(hash = nil, loaded_path = nil); end
+  def internal?; end
   def key?(*args, &block); end
   def keys(*args, &block); end
   def loaded_path; end
@@ -6625,7 +6853,7 @@ class RuboCop::ConfigLoaderResolver
   def merge_with_default(config, config_file, unset_nil:); end
   def remote_file?(uri); end
   def resolve_inheritance(path, hash, file, debug); end
-  def resolve_inheritance_from_gems(hash, gems); end
+  def resolve_inheritance_from_gems(hash); end
   def resolve_requires(path, hash); end
   def should_union?(base_hash, key, inherit_mode); end
   def transform(config); end
@@ -6640,7 +6868,6 @@ class RuboCop::ConfigLoader
   def self.auto_gen_config; end
   def self.auto_gen_config=(arg0); end
   def self.auto_gen_config?; end
-  def self.check_cop_config_value(hash, parent = nil); end
   def self.check_duplication(yaml_code, absolute_path); end
   def self.clear_options; end
   def self.configuration_file_for(target_dir); end
@@ -6666,6 +6893,7 @@ class RuboCop::ConfigLoader
   def self.options_config=(arg0); end
   def self.read_file(absolute_path); end
   def self.resolver; end
+  def self.warn_on_pending_cops(config); end
   def self.write_config_file(file_name, file_string, rubocop_yml_contents); end
   def self.yaml_safe_load(yaml_code, filename); end
 end
@@ -6686,27 +6914,24 @@ class RuboCop::ConfigStore
   def options_config=(options_config); end
 end
 class RuboCop::ConfigValidator
-  def base_dir_for_path_parameters(*args, &block); end
-  def bundler_lock_file_path(*args, &block); end
+  def alert_about_unrecognized_cops(invalid_cop_names); end
+  def check_cop_config_value(hash, parent = nil); end
   def check_target_ruby; end
-  def find_file_upwards(*args, &block); end
+  def each_invalid_parameter(cop_name); end
   def for_all_cops(*args, &block); end
   def initialize(config); end
-  def read_ruby_version_from_bundler_lock_file; end
+  def msg_not_boolean(parent, key, value); end
+  def reject_conflicting_safe_settings; end
   def reject_mutually_exclusive_defaults; end
-  def ruby_version_file; end
   def smart_loaded_path(*args, &block); end
-  def target_ruby_source; end
+  def target_ruby; end
   def target_ruby_version; end
-  def target_ruby_version_from_bundler_lock_file; end
-  def target_ruby_version_from_version_file; end
   def validate; end
   def validate_enforced_styles(valid_cop_names); end
   def validate_parameter_names(valid_cop_names); end
   def validate_section_presence(name); end
   def validate_support_and_has_list(name, formats, valid); end
   def validate_syntax_cop; end
-  def warn_about_unrecognized_cops(invalid_cop_names); end
   extend Forwardable
 end
 class RuboCop::TargetFinder
@@ -6720,6 +6945,7 @@ class RuboCop::TargetFinder
   def force_exclusion?; end
   def included_file?(file); end
   def initialize(config_store, options = nil); end
+  def order; end
   def process_explicit_path(path); end
   def ruby_executable?(file); end
   def ruby_extension?(file); end
@@ -6773,6 +6999,7 @@ class RuboCop::CommentConfig
   def cop_disabled_line_ranges; end
   def cop_enabled_at_line?(cop, line_number); end
   def cop_line_ranges(analysis); end
+  def directive_on_comment_line?(comment); end
   def directive_parts(comment); end
   def each_directive; end
   def each_mentioned_cop; end
@@ -6864,8 +7091,9 @@ class RuboCop::ProcessedSource
 end
 class RuboCop::ResultCache
   def any_symlink?(path); end
+  def context_checksum(team, options); end
   def file_checksum(file, config_store); end
-  def initialize(file, options, config_store, cache_root = nil); end
+  def initialize(file, team, options, config_store, cache_root = nil); end
   def load; end
   def relevant_options_digest(options); end
   def rubocop_checksum; end
@@ -6881,20 +7109,23 @@ class RuboCop::ResultCache
   def self.source_checksum; end
   def self.source_checksum=(arg0); end
   def symlink_protection_triggered?(path); end
+  def team_checksum(team); end
   def valid?; end
 end
 class RuboCop::Runner
   def aborting=(arg0); end
   def aborting?; end
-  def add_unneeded_disables(file, offenses, source); end
-  def autocorrect_unneeded_disables(file, source, cop, offenses); end
+  def add_redundant_disables(file, offenses, source); end
+  def autocorrect_redundant_disables(file, source, cop, offenses); end
+  def cached_result(file, team); end
   def cached_run?; end
   def check_for_infinite_loop(processed_source, offenses); end
-  def check_for_unneeded_disables?(source); end
+  def check_for_redundant_disables?(source); end
   def considered_failure?(offense); end
   def do_inspection_loop(file, processed_source); end
   def each_inspected_file(files); end
   def errors; end
+  def file_finished(file, offenses); end
   def file_offense_cache(file); end
   def file_offenses(file); end
   def file_started(file); end
@@ -6911,8 +7142,10 @@ class RuboCop::Runner
   def minimum_severity_to_fail; end
   def mobilized_cop_classes(config); end
   def process_file(file); end
+  def redundant_cop_disable_directive(file); end
   def run(paths); end
   def save_in_cache(cache, offenses); end
+  def standby_team(config); end
   def style_guide_cops_only?(config); end
   def warm_cache(target_files); end
   def warnings; end
@@ -6924,35 +7157,73 @@ end
 class RuboCop::CLI
   def act_on_options; end
   def apply_default_formatter; end
-  def config_lines(cop); end
   def config_store; end
-  def cops_of_department(cops, department); end
-  def display_error_summary(errors); end
-  def display_warning_summary(warnings); end
-  def execute_runner(paths); end
-  def execute_runners(paths); end
+  def execute_runners; end
   def handle_exiting_options; end
-  def init_dotfile; end
   def initialize; end
+  def options; end
+  def run(args = nil); end
+  def run_command(name); end
+  def validate_options_vs_config; end
+end
+class RuboCop::CLI::Finished < RuntimeError
+end
+module RuboCop::CLI::Command
+  def self.class_for(name); end
+  def self.run(env, name); end
+end
+class RuboCop::CLI::Environment
+  def config_store; end
+  def initialize(options, config_store, paths); end
+  def options; end
+  def paths; end
+  def run(name); end
+end
+class RuboCop::CLI::Command::Base
+  def env; end
+  def initialize(env); end
+  def self.by_command_name(name); end
+  def self.command_name; end
+  def self.command_name=(arg0); end
+  def self.inherited(subclass); end
+end
+class RuboCop::CLI::Command::AutoGenerateConfig < RuboCop::CLI::Command::Base
+  def add_formatter; end
+  def execute_runner; end
   def line_length_cop(config); end
   def line_length_enabled?(config); end
   def max_line_length(config); end
+  def maybe_run_line_length_cop; end
+  def reset_config_and_auto_gen_file; end
+  def run; end
+  def run_all_cops(line_length_contents); end
+  def run_line_length_cop; end
+  def same_max_line_length?(config1, config2); end
+  def skip_line_length_cop(reason); end
+end
+class RuboCop::CLI::Command::ExecuteRunner < RuboCop::CLI::Command::Base
+  def display_error_summary(errors); end
+  def display_warning_summary(warnings); end
+  def execute_runner(paths); end
   def maybe_print_corrected_source; end
-  def maybe_run_line_length_cop(paths); end
-  def options; end
+  def run; end
+  include RuboCop::Formatter::TextUtil
+end
+class RuboCop::CLI::Command::InitDotfile < RuboCop::CLI::Command::Base
+  def run; end
+end
+class RuboCop::CLI::Command::ShowCops < RuboCop::CLI::Command::Base
+  def config_lines(cop); end
+  def cops_of_department(cops, department); end
+  def initialize(env); end
   def print_available_cops; end
   def print_cop_details(cops); end
   def print_cops_of_department(registry, department, show_all); end
-  def reset_config_and_auto_gen_file; end
-  def run(args = nil); end
-  def run_all_cops_auto_gen_config(line_length_contents, paths); end
-  def run_line_length_cop_auto_gen_config(paths); end
-  def same_max_line_length?(config1, config2); end
+  def run; end
   def selected_cops_of_department(cops, department); end
-  def validate_options_vs_config; end
-  include RuboCop::Formatter::TextUtil
 end
-class RuboCop::CLI::Finished < RuntimeError
+class RuboCop::CLI::Command::Version < RuboCop::CLI::Command::Base
+  def run; end
 end
 class RuboCop::IncorrectCopNameError < StandardError
 end
@@ -6983,12 +7254,13 @@ class RuboCop::OptionsValidator
   def except_syntax?; end
   def incompatible_options; end
   def initialize(options); end
-  def only_includes_unneeded_disable?; end
+  def only_includes_redundant_disable?; end
   def self.format_message_from(name, cop_names); end
   def self.validate_cop_list(names); end
   def validate_auto_correct; end
   def validate_auto_gen_config; end
   def validate_compatibility; end
+  def validate_cop_options; end
   def validate_exclude_limit_option; end
   def validate_parallel; end
   def validate_parallel_with_combo_option; end
@@ -7008,6 +7280,38 @@ class RuboCop::RemoteConfig
   def request(uri = nil, limit = nil, &block); end
   def uri; end
 end
+class RuboCop::TargetRuby
+  def initialize(config); end
+  def rubocop_version_with_support; end
+  def self.supported_versions; end
+  def source; end
+  def supported?; end
+  def version; end
+end
+class RuboCop::TargetRuby::Source
+  def initialize(config); end
+  def name; end
+  def to_s; end
+  def version; end
+end
+class RuboCop::TargetRuby::RuboCopConfig < RuboCop::TargetRuby::Source
+  def find_version; end
+  def name; end
+end
+class RuboCop::TargetRuby::RubyVersionFile < RuboCop::TargetRuby::Source
+  def find_version; end
+  def name; end
+  def ruby_version_file; end
+end
+class RuboCop::TargetRuby::BundlerLockFile < RuboCop::TargetRuby::Source
+  def bundler_lock_file_path; end
+  def find_version; end
+  def name; end
+end
+class RuboCop::TargetRuby::Default < RuboCop::TargetRuby::Source
+  def find_version; end
+  def name; end
+end
 module RuboCop::YAMLDuplicationChecker
   def self.check(yaml_string, filename, &on_duplicated); end
   def self.traverse(tree, &on_duplicated); end