# typed: true

# DO NOT EDIT MANUALLY
# This is an autogenerated file for types exported from the `rubocop-rspec` gem.
# Please instead update this file by running `bin/tapioca gem rubocop-rspec`.


module RuboCop; end

class RuboCop::AST::Node < ::Parser::AST::Node
  include ::RuboCop::RSpec::Node
end

module RuboCop::Cop; end
module RuboCop::Cop::RSpec; end

class RuboCop::Cop::RSpec::AlignLeftLetBrace < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def on_new_investigation; end

  private

  def token_aligner; end

  class << self
    def autocorrect_incompatible_with; end
  end
end

RuboCop::Cop::RSpec::AlignLeftLetBrace::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::AlignRightLetBrace < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def on_new_investigation; end

  private

  def token_aligner; end

  class << self
    def autocorrect_incompatible_with; end
  end
end

RuboCop::Cop::RSpec::AlignRightLetBrace::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::AnyInstance < ::RuboCop::Cop::RSpec::Base
  def on_send(node); end
end

RuboCop::Cop::RSpec::AnyInstance::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::AnyInstance::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::AroundBlock < ::RuboCop::Cop::RSpec::Base
  def find_arg_usage(param0); end
  def hook_block(param0 = T.unsafe(nil)); end
  def hook_itblock(param0 = T.unsafe(nil)); end
  def hook_numblock(param0 = T.unsafe(nil)); end
  def on_block(node); end
  def on_itblock(node); end
  def on_numblock(node); end

  private

  def add_no_arg_offense(node); end
  def check_for_itblock(block); end
  def check_for_numblock(block); end
  def check_for_unused_proxy(block, proxy); end
end

RuboCop::Cop::RSpec::AroundBlock::MSG_NO_ARG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::AroundBlock::MSG_UNUSED_ARG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::Base < ::RuboCop::Cop::Base
  include ::RuboCop::RSpec::Language

  def on_new_investigation; end

  class << self
    def inherited(subclass); end
  end
end

class RuboCop::Cop::RSpec::Be < ::RuboCop::Cop::RSpec::Base
  def be_without_args(param0 = T.unsafe(nil)); end
  def on_send(node); end
end

RuboCop::Cop::RSpec::Be::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::Be::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::BeEmpty < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def expect_array_matcher?(param0 = T.unsafe(nil)); end
  def on_send(node); end
end

RuboCop::Cop::RSpec::BeEmpty::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::BeEmpty::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::BeEq < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def eq_type_with_identity?(param0 = T.unsafe(nil)); end
  def on_send(node); end
end

RuboCop::Cop::RSpec::BeEq::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::BeEq::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::BeEql < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def eql_type_with_identity(param0 = T.unsafe(nil)); end
  def on_send(node); end
end

RuboCop::Cop::RSpec::BeEql::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::BeEql::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::BeNil < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::ConfigurableEnforcedStyle
  extend ::RuboCop::Cop::AutoCorrector

  def be_nil_matcher?(param0 = T.unsafe(nil)); end
  def nil_value_expectation?(param0 = T.unsafe(nil)); end
  def on_send(node); end

  private

  def check_be_nil_style(node); end
  def check_be_style(node); end
end

RuboCop::Cop::RSpec::BeNil::BE_MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::BeNil::BE_NIL_MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::BeNil::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::BeforeAfterAll < ::RuboCop::Cop::RSpec::Base
  def before_or_after_all(param0 = T.unsafe(nil)); end
  def on_send(node); end
end

RuboCop::Cop::RSpec::BeforeAfterAll::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::BeforeAfterAll::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set)

class RuboCop::Cop::RSpec::ChangeByZero < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RangeHelp
  extend ::RuboCop::Cop::AutoCorrector

  def change_nodes(param0); end
  def expect_change_with_arguments(param0 = T.unsafe(nil)); end
  def expect_change_with_block(param0 = T.unsafe(nil)); end
  def on_send(node); end

  private

  def autocorrect(corrector, node, change_node); end
  def autocorrect_compound(corrector, node); end
  def compound_expectations?(node); end
  def insert_operator(corrector, node, change_node); end
  def message(change_node); end
  def message_compound(change_node); end
  def negated_matcher; end
  def preferred_method; end
  def register_offense(node, change_node); end
  def remove_by_zero(corrector, node, change_node); end
  def replace_node(node, change_node); end
end

RuboCop::Cop::RSpec::ChangeByZero::CHANGE_METHODS = T.let(T.unsafe(nil), Set)
RuboCop::Cop::RSpec::ChangeByZero::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::ChangeByZero::MSG_COMPOUND = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::ChangeByZero::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set)

class RuboCop::Cop::RSpec::ClassCheck < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::ConfigurableEnforcedStyle
  extend ::RuboCop::Cop::AutoCorrector

  def on_send(node); end

  private

  def autocorrect(corrector, node); end
  def format_message(node); end
  def offending?(node); end
  def preferred_method_name; end
  def preferred_method_name?(method_name); end
  def preferred_method_names; end
end

RuboCop::Cop::RSpec::ClassCheck::METHOD_NAMES_FOR_BE_A = T.let(T.unsafe(nil), Set)
RuboCop::Cop::RSpec::ClassCheck::METHOD_NAMES_FOR_KIND_OF = T.let(T.unsafe(nil), Set)
RuboCop::Cop::RSpec::ClassCheck::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::ClassCheck::PREFERRED_METHOD_NAME_BY_STYLE = T.let(T.unsafe(nil), Hash)
RuboCop::Cop::RSpec::ClassCheck::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

module RuboCop::Cop::RSpec::CommentsHelp
  include ::RuboCop::Cop::RSpec::FinalEndLocation

  def begin_pos_with_comment(node); end
  def buffer; end
  def end_line_position(node); end
  def source_range_with_comment(node); end
  def start_line_position(node); end
end

class RuboCop::Cop::RSpec::ContainExactly < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def on_send(node); end
end

RuboCop::Cop::RSpec::ContainExactly::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::ContainExactly::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::ContextMethod < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def context_method(param0 = T.unsafe(nil)); end
  def on_block(node); end

  private

  def method_name?(description); end
end

RuboCop::Cop::RSpec::ContextMethod::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::ContextWording < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::AllowedPattern

  def context_wording(param0 = T.unsafe(nil)); end
  def on_block(node); end

  private

  def allowed_patterns; end
  def description(context); end
  def expect_patterns; end
  def message; end
  def prefix_regexes; end
  def prefixes; end
end

RuboCop::Cop::RSpec::ContextWording::MSG_ALWAYS = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::ContextWording::MSG_MATCH = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::DescribeClass < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::TopLevelGroup

  def example_group_with_ignored_metadata?(param0 = T.unsafe(nil)); end
  def not_a_const_described(param0 = T.unsafe(nil)); end
  def on_top_level_group(node); end
  def sym_pair(param0 = T.unsafe(nil)); end

  private

  def ignored_metadata; end
  def ignored_metadata?(node); end
  def string_constant?(described); end
end

RuboCop::Cop::RSpec::DescribeClass::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::DescribeMethod < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::TopLevelGroup

  def method_name?(param0 = T.unsafe(nil)); end
  def on_top_level_group(node); end
  def second_string_literal_argument(param0 = T.unsafe(nil)); end

  private

  def method_name_prefix?(description); end
end

RuboCop::Cop::RSpec::DescribeMethod::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::DescribeSymbol < ::RuboCop::Cop::RSpec::Base
  def describe_symbol?(param0 = T.unsafe(nil)); end
  def on_send(node); end
end

RuboCop::Cop::RSpec::DescribeSymbol::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::DescribeSymbol::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::DescribedClass < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::ConfigurableEnforcedStyle
  include ::RuboCop::Cop::RSpec::Namespace
  extend ::RuboCop::Cop::AutoCorrector

  def common_instance_exec_closure?(param0 = T.unsafe(nil)); end
  def contains_described_class?(param0); end
  def described_constant(param0 = T.unsafe(nil)); end
  def on_block(node); end
  def rspec_block?(param0 = T.unsafe(nil)); end
  def scope_changing_syntax?(param0 = T.unsafe(nil)); end

  private

  def allowed?(node); end
  def autocorrect(corrector, match); end
  def collapse_namespace(namespace, const); end
  def const_name(node); end
  def find_usage(node, &block); end
  def full_const_name(node); end
  def message(offense); end
  def offensive?(node); end
  def offensive_described_class?(node); end
  def only_static_constants?; end
  def scope_change?(node); end
  def skippable_block?(node); end
end

RuboCop::Cop::RSpec::DescribedClass::DESCRIBED_CLASS = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::DescribedClass::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::DescribedClassModuleWrapping < ::RuboCop::Cop::RSpec::Base
  def include_rspec_blocks?(param0); end
  def on_module(node); end
end

RuboCop::Cop::RSpec::DescribedClassModuleWrapping::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::Dialect < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::MethodPreference
  extend ::RuboCop::Cop::AutoCorrector

  def on_send(node); end
  def rspec_method?(param0 = T.unsafe(nil)); end
end

RuboCop::Cop::RSpec::Dialect::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::DiscardedMatcher < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::InsideExample

  def on_block(node); end
  def on_send(node); end

  private

  def all_matcher_methods; end
  def check_discarded_matcher(send_node, node); end
  def custom_matcher_methods; end
  def example_with_matcher_expectation?(node); end
  def expectation_with_matcher?(node); end
  def find_outermost_chain(node); end
  def matcher_call?(node); end
  def void_value?(node); end
end

RuboCop::Cop::RSpec::DiscardedMatcher::MATCHER_METHODS = T.let(T.unsafe(nil), Set)
RuboCop::Cop::RSpec::DiscardedMatcher::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::DuplicatedMetadata < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::Metadata
  include ::RuboCop::Cop::RangeHelp
  extend ::RuboCop::Cop::AutoCorrector

  def on_metadata(symbols, _hash); end

  private

  def autocorrect(corrector, node); end
  def duplicated?(node); end
  def on_metadata_symbol(node); end
end

RuboCop::Cop::RSpec::DuplicatedMetadata::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::EmptyExampleGroup < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::InsideExample
  include ::RuboCop::Cop::RangeHelp
  extend ::RuboCop::Cop::AutoCorrector

  def example_group_body(param0 = T.unsafe(nil)); end
  def example_or_group_or_include?(param0 = T.unsafe(nil)); end
  def examples?(param0 = T.unsafe(nil)); end
  def examples_directly_or_in_block?(param0 = T.unsafe(nil)); end
  def examples_inside_block?(param0 = T.unsafe(nil)); end
  def on_block(node); end

  private

  def conditionals_with_examples?(body); end
  def examples_in_branches?(condition_node); end
  def offensive?(body); end
  def removed_range(node); end
end

RuboCop::Cop::RSpec::EmptyExampleGroup::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::EmptyHook < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RangeHelp
  extend ::RuboCop::Cop::AutoCorrector

  def empty_hook?(param0 = T.unsafe(nil)); end
  def on_block(node); end
end

RuboCop::Cop::RSpec::EmptyHook::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::EmptyLineAfterExample < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::FinalEndLocation
  include ::RuboCop::Cop::RangeHelp
  include ::RuboCop::Cop::RSpec::EmptyLineSeparation
  extend ::RuboCop::Cop::AutoCorrector

  def on_block(node); end

  private

  def allow_consecutive_one_liners?; end
  def allowed_one_liner?(node); end
  def consecutive_one_liner?(node); end
  def next_one_line_example?(node); end
end

RuboCop::Cop::RSpec::EmptyLineAfterExample::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::FinalEndLocation
  include ::RuboCop::Cop::RangeHelp
  include ::RuboCop::Cop::RSpec::EmptyLineSeparation
  extend ::RuboCop::Cop::AutoCorrector

  def on_block(node); end
end

RuboCop::Cop::RSpec::EmptyLineAfterExampleGroup::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::EmptyLineAfterFinalLet < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::FinalEndLocation
  include ::RuboCop::Cop::RangeHelp
  include ::RuboCop::Cop::RSpec::EmptyLineSeparation
  extend ::RuboCop::Cop::AutoCorrector

  def example_group_or_include?(param0 = T.unsafe(nil)); end
  def on_block(node); end
end

RuboCop::Cop::RSpec::EmptyLineAfterFinalLet::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::EmptyLineAfterHook < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::ConfigurableEnforcedStyle
  include ::RuboCop::Cop::RSpec::FinalEndLocation
  include ::RuboCop::Cop::RangeHelp
  include ::RuboCop::Cop::RSpec::EmptyLineSeparation
  extend ::RuboCop::Cop::AutoCorrector

  def on_block(node); end
  def on_itblock(node); end
  def on_numblock(node); end

  private

  def chained_single_line_hooks?(node); end
end

RuboCop::Cop::RSpec::EmptyLineAfterHook::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::EmptyLineAfterSubject < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::FinalEndLocation
  include ::RuboCop::Cop::RangeHelp
  include ::RuboCop::Cop::RSpec::EmptyLineSeparation
  include ::RuboCop::Cop::RSpec::InsideExampleGroup
  extend ::RuboCop::Cop::AutoCorrector

  def on_block(node); end
end

RuboCop::Cop::RSpec::EmptyLineAfterSubject::MSG = T.let(T.unsafe(nil), String)

module RuboCop::Cop::RSpec::EmptyLineSeparation
  include ::RuboCop::Cop::RSpec::FinalEndLocation
  include ::RuboCop::Cop::RangeHelp

  def last_child?(node); end
  def missing_separating_line(node); end
  def missing_separating_line_offense(node); end
  def offending_loc(last_line); end
end

class RuboCop::Cop::RSpec::EmptyMetadata < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::Metadata
  include ::RuboCop::Cop::RangeHelp
  extend ::RuboCop::Cop::AutoCorrector

  def on_metadata(_symbols, hash); end

  private

  def remove_empty_metadata(corrector, node); end
end

RuboCop::Cop::RSpec::EmptyMetadata::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::EmptyOutput < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def matching_empty_output(param0 = T.unsafe(nil)); end
  def on_send(send_node); end
end

RuboCop::Cop::RSpec::EmptyOutput::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::EmptyOutput::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::Eq < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RangeHelp
  extend ::RuboCop::Cop::AutoCorrector

  def be_equals(param0 = T.unsafe(nil)); end
  def on_send(node); end

  private

  def offense_range(matcher); end
end

RuboCop::Cop::RSpec::Eq::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::Eq::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::ExampleLength < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::CodeLength

  def on_block(node); end

  private

  def cop_label; end
end

RuboCop::Cop::RSpec::ExampleLength::LABEL = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::ExampleWithoutDescription < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::ConfigurableEnforcedStyle

  def example_description(param0 = T.unsafe(nil)); end
  def on_block(node); end

  private

  def check_example_without_description(node); end
  def disallow_empty_description?(node); end
end

RuboCop::Cop::RSpec::ExampleWithoutDescription::MSG_ADD_DESCRIPTION = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::ExampleWithoutDescription::MSG_DEFAULT_ARGUMENT = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::ExampleWording < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def it_description(param0 = T.unsafe(nil)); end
  def on_block(node); end

  private

  def add_wording_offense(node, message); end
  def custom_transform; end
  def docstring(node); end
  def ignored_words; end
  def insufficient_docstring?(description_node); end
  def insufficient_examples; end
  def preprocess(message); end
  def replacement_text(node); end
  def text(node); end
end

RuboCop::Cop::RSpec::ExampleWording::IT_PREFIX = T.let(T.unsafe(nil), Regexp)
RuboCop::Cop::RSpec::ExampleWording::MSG_INSUFFICIENT_DESCRIPTION = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::ExampleWording::MSG_IT = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::ExampleWording::MSG_SHOULD = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::ExampleWording::MSG_WILL = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::ExampleWording::SHOULD_PREFIX = T.let(T.unsafe(nil), Regexp)
RuboCop::Cop::RSpec::ExampleWording::WILL_PREFIX = T.let(T.unsafe(nil), Regexp)

class RuboCop::Cop::RSpec::ExcessiveDocstringSpacing < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def example_description(param0 = T.unsafe(nil)); end
  def on_send(node); end

  private

  def add_whitespace_offense(node, text); end
  def docstring(node); end
  def excessive_whitespace?(text); end
  def strip_excessive_whitespace(text); end
  def text(node); end
end

RuboCop::Cop::RSpec::ExcessiveDocstringSpacing::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::ExpectActual < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def expect_literal(param0 = T.unsafe(nil)); end
  def expect_literal_no_arg(param0 = T.unsafe(nil)); end
  def on_send(node); end

  private

  def complex_literal?(node); end
  def literal?(node); end
  def register_offense(actual, send_node, matcher, expected); end
  def simple_literal?(node); end
end

RuboCop::Cop::RSpec::ExpectActual::COMPLEX_LITERALS = T.let(T.unsafe(nil), Array)
RuboCop::Cop::RSpec::ExpectActual::CORRECTABLE_MATCHERS = T.let(T.unsafe(nil), Array)
RuboCop::Cop::RSpec::ExpectActual::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::ExpectActual::MSG_NO_ARG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::ExpectActual::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)
RuboCop::Cop::RSpec::ExpectActual::SIMPLE_LITERALS = T.let(T.unsafe(nil), Array)
RuboCop::Cop::RSpec::ExpectActual::SKIPPED_MATCHERS = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::ExpectChange < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::ConfigurableEnforcedStyle
  extend ::RuboCop::Cop::AutoCorrector

  def expect_matcher_with_arguments(param0 = T.unsafe(nil)); end
  def expect_matcher_with_block(param0 = T.unsafe(nil)); end
  def on_block(node); end
  def on_send(node); end

  private

  def matcher_method?(method_name); end
  def matcher_method_names; end
  def negated_matcher; end
end

RuboCop::Cop::RSpec::ExpectChange::MSG_BLOCK = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::ExpectChange::MSG_CALL = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::ExpectInHook < ::RuboCop::Cop::RSpec::Base
  def expectation(param0); end
  def on_block(node); end
  def on_itblock(node); end
  def on_numblock(node); end

  private

  def message(expect, hook); end
end

RuboCop::Cop::RSpec::ExpectInHook::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::ExpectInLet < ::RuboCop::Cop::RSpec::Base
  def expectation(param0); end
  def on_block(node); end

  private

  def message(expect); end
end

RuboCop::Cop::RSpec::ExpectInLet::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::ExpectOutput < ::RuboCop::Cop::RSpec::Base
  def on_gvasgn(node); end

  private

  def inside_example_scope?(node); end
end

RuboCop::Cop::RSpec::ExpectOutput::MSG = T.let(T.unsafe(nil), String)

module RuboCop::Cop::RSpec::ExplicitHelper
  include ::RuboCop::RSpec::Language
  extend ::RuboCop::AST::NodePattern::Macros

  def predicate_matcher?(param0 = T.unsafe(nil)); end
  def predicate_matcher_block?(param0 = T.unsafe(nil)); end

  private

  def allowed_explicit_matchers; end
  def check_explicit(node); end
  def corrector_explicit(corrector, to_node, actual, matcher, block_child); end
  def heredoc_argument?(matcher); end
  def message_explicit(matcher); end
  def move_predicate(corrector, actual, matcher, block_child); end
  def predicate_matcher_name?(name); end
  def replaceable_matcher?(matcher); end
  def replacement_matcher(node); end
  def to_predicate_method(matcher); end
  def uncorrectable_matcher?(node, matcher); end
end

RuboCop::Cop::RSpec::ExplicitHelper::BUILT_IN_MATCHERS = T.let(T.unsafe(nil), Array)
RuboCop::Cop::RSpec::ExplicitHelper::MSG_EXPLICIT = T.let(T.unsafe(nil), String)

module RuboCop::Cop::RSpec::FileHelp
  def expanded_file_path; end
end

module RuboCop::Cop::RSpec::FinalEndLocation
  def final_end_location(start_node); end
end

class RuboCop::Cop::RSpec::Focus < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RangeHelp
  extend ::RuboCop::Cop::AutoCorrector

  def focusable_selector?(param0 = T.unsafe(nil)); end
  def focused_block?(param0 = T.unsafe(nil)); end
  def metadata(param0 = T.unsafe(nil)); end
  def on_send(node); end

  private

  def correct_send(corrector, focus); end
  def on_focused_block(node); end
  def on_metadata(node); end
  def with_surrounding(focus); end
end

RuboCop::Cop::RSpec::Focus::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::HookArgument < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::ConfigurableEnforcedStyle
  extend ::RuboCop::Cop::AutoCorrector

  def on_block(node); end
  def on_itblock(node); end
  def on_numblock(node); end
  def scoped_hook(param0 = T.unsafe(nil)); end
  def unscoped_hook(param0 = T.unsafe(nil)); end

  private

  def autocorrect(corrector, _node, method_send); end
  def check_implicit(method_send); end
  def explicit_message(scope); end
  def hook(node, &block); end
  def implicit_style?; end
end

RuboCop::Cop::RSpec::HookArgument::EXPLICIT_MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::HookArgument::IMPLICIT_MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::HooksBeforeExamples < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def example_or_group?(param0 = T.unsafe(nil)); end
  def on_block(node); end
  def on_itblock(node); end
  def on_numblock(node); end

  private

  def autocorrect(corrector, node, first_example); end
  def check_hooks(node); end
  def find_first_example(node); end
  def multiline_block?(block); end
end

RuboCop::Cop::RSpec::HooksBeforeExamples::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::IdenticalEqualityAssertion < ::RuboCop::Cop::RSpec::Base
  def equality_check?(param0 = T.unsafe(nil)); end
  def on_send(node); end
end

RuboCop::Cop::RSpec::IdenticalEqualityAssertion::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::IdenticalEqualityAssertion::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::ImplicitBlockExpectation < ::RuboCop::Cop::RSpec::Base
  def implicit_expect(param0 = T.unsafe(nil)); end
  def lambda?(param0 = T.unsafe(nil)); end
  def lambda_subject?(param0 = T.unsafe(nil)); end
  def on_send(node); end

  private

  def find_subject(block_node); end
  def multi_statement_example_group?(node); end
  def nearest_subject(node); end
end

RuboCop::Cop::RSpec::ImplicitBlockExpectation::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::ImplicitBlockExpectation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::ImplicitExpect < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::ConfigurableEnforcedStyle
  extend ::RuboCop::Cop::AutoCorrector

  def implicit_expect(param0 = T.unsafe(nil)); end
  def on_send(node); end

  private

  def offending_expect(node); end
  def offense_message(offending_source); end
  def range_for_is_expected(source_map); end
  def replacement_source(offending_source); end
end

RuboCop::Cop::RSpec::ImplicitExpect::ENFORCED_REPLACEMENTS = T.let(T.unsafe(nil), Hash)
RuboCop::Cop::RSpec::ImplicitExpect::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::ImplicitExpect::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::ImplicitSubject < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::ConfigurableEnforcedStyle
  extend ::RuboCop::Cop::AutoCorrector

  def explicit_unnamed_subject?(param0 = T.unsafe(nil)); end
  def implicit_subject?(param0 = T.unsafe(nil)); end
  def on_send(node); end

  private

  def autocorrect(corrector, node); end
  def example_of(node); end
  def implicit_subject_in_non_its?(node); end
  def implicit_subject_in_non_its_and_non_single_line?(node); end
  def implicit_subject_in_non_its_and_non_single_statement?(node); end
  def invalid?(node); end
  def its?(node); end
  def message(_node); end
  def single_line?(node); end
  def single_statement?(node); end
end

RuboCop::Cop::RSpec::ImplicitSubject::MSG_REQUIRE_EXPLICIT = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::ImplicitSubject::MSG_REQUIRE_IMPLICIT = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::ImplicitSubject::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::IncludeExamples < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def on_send(node); end
end

RuboCop::Cop::RSpec::IncludeExamples::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::IncludeExamples::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::IndexedLet < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::AllowedIdentifiers
  include ::RuboCop::Cop::AllowedPattern

  def let_name(param0 = T.unsafe(nil)); end
  def on_block(node); end

  private

  def allowed_identifiers; end
  def cop_config_patterns_values; end
  def filter_indexed_lets(candidates); end
  def indexed_let?(node); end
  def let_name_stripped_index(node); end
end

RuboCop::Cop::RSpec::IndexedLet::INDEX_REGEX = T.let(T.unsafe(nil), Regexp)
RuboCop::Cop::RSpec::IndexedLet::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::IndexedLet::SUFFIX_INDEX_REGEX = T.let(T.unsafe(nil), Regexp)

module RuboCop::Cop::RSpec::InflectedHelper
  include ::RuboCop::RSpec::Language
  extend ::RuboCop::AST::NodePattern::Macros

  def be_bool?(param0 = T.unsafe(nil)); end
  def be_boolthy?(param0 = T.unsafe(nil)); end
  def predicate_in_actual?(param0 = T.unsafe(nil)); end

  private

  def boolean_matcher?(node); end
  def cannot_replace_predicate?(send_node); end
  def check_inflected(node); end
  def message_inflected(predicate); end
  def predicate?(sym); end
  def remove_predicate(corrector, predicate); end
  def rewrite_matcher(corrector, predicate, matcher); end
  def to_predicate_matcher(name); end
  def true?(to_symbol, matcher); end
end

RuboCop::Cop::RSpec::InflectedHelper::MSG_INFLECTED = T.let(T.unsafe(nil), String)

module RuboCop::Cop::RSpec::InsideExample
  private

  def inside_example?(node); end
end

module RuboCop::Cop::RSpec::InsideExampleGroup
  private

  def example_group_root?(node); end
  def example_group_root_with_siblings?(node); end
  def inside_example_group?(node); end
end

class RuboCop::Cop::RSpec::InstanceSpy < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def have_received_usage(param0); end
  def null_double(param0); end
  def on_block(node); end

  private

  def autocorrect(corrector, node); end
end

RuboCop::Cop::RSpec::InstanceSpy::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::InstanceVariable < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::TopLevelGroup

  def custom_matcher?(param0 = T.unsafe(nil)); end
  def dynamic_class?(param0 = T.unsafe(nil)); end
  def ivar_assigned?(param0, param1); end
  def ivar_usage(param0); end
  def on_top_level_group(node); end

  private

  def assignment_only?; end
  def valid_usage?(node); end
end

RuboCop::Cop::RSpec::InstanceVariable::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::IsExpectedSpecify < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def offense?(param0 = T.unsafe(nil)); end
  def on_send(node); end
end

RuboCop::Cop::RSpec::IsExpectedSpecify::IS_EXPECTED_METHODS = T.let(T.unsafe(nil), Set)
RuboCop::Cop::RSpec::IsExpectedSpecify::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::IsExpectedSpecify::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::ItBehavesLike < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::ConfigurableEnforcedStyle
  extend ::RuboCop::Cop::AutoCorrector

  def example_inclusion_offense(param0 = T.unsafe(nil), param1); end
  def on_send(node); end

  private

  def message(_node); end
end

RuboCop::Cop::RSpec::ItBehavesLike::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::ItBehavesLike::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::IteratedExpectation < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def each?(param0 = T.unsafe(nil)); end
  def each_itblock?(param0 = T.unsafe(nil)); end
  def each_numblock?(param0 = T.unsafe(nil)); end
  def expectation?(param0 = T.unsafe(nil), param1); end
  def on_block(node); end
  def on_itblock(node); end
  def on_numblock(node); end

  private

  def check_offense(node, argument); end
  def only_expectations?(body, arg); end
  def single_expectation?(body, arg); end
  def single_expectation_replacement(node); end
  def uses_argument_in_matcher?(node, argument); end
end

RuboCop::Cop::RSpec::IteratedExpectation::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::LeadingSubject < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::InsideExampleGroup
  extend ::RuboCop::Cop::AutoCorrector

  def on_block(node); end

  private

  def autocorrect(corrector, node, sibling); end
  def check_previous_nodes(node); end
  def offending?(node); end
  def offending_node(node); end
  def parent(node); end
end

RuboCop::Cop::RSpec::LeadingSubject::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::LeakyConstantDeclaration < ::RuboCop::Cop::RSpec::Base
  def on_casgn(node); end
  def on_class(node); end
  def on_module(node); end

  private

  def explicit_namespace?(namespace); end
  def inside_describe_block?(node); end
end

RuboCop::Cop::RSpec::LeakyConstantDeclaration::MSG_CLASS = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::LeakyConstantDeclaration::MSG_CONST = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::LeakyConstantDeclaration::MSG_MODULE = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::LeakyLocalVariable < ::RuboCop::Cop::RSpec::Base
  def after_leaving_scope(scope, _variable_table); end
  def example_method?(param0 = T.unsafe(nil)); end
  def includes_method?(param0 = T.unsafe(nil)); end

  private

  def allowed_includes_arguments?(node, argument); end
  def allowed_reference?(node); end
  def check_references(variable); end
  def example_scope?(node); end
  def in_example_arguments?(ancestor, node); end
  def inside_describe_block?(node); end
  def part_of_example_scope?(node); end

  class << self
    def joining_forces; end
  end
end

RuboCop::Cop::RSpec::LeakyLocalVariable::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::LetBeforeExamples < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def example_or_group?(param0 = T.unsafe(nil)); end
  def include_examples?(param0 = T.unsafe(nil)); end
  def on_block(node); end

  private

  def autocorrect(corrector, node, first_example); end
  def check_let_declarations(node); end
  def example_group_with_include_examples?(body); end
  def find_first_example(node); end
  def multiline_block?(block); end

  class << self
    def autocorrect_incompatible_with; end
  end
end

RuboCop::Cop::RSpec::LetBeforeExamples::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::LetSetup < ::RuboCop::Cop::RSpec::Base
  def example_or_shared_group_or_including?(param0 = T.unsafe(nil)); end
  def let_bang(param0 = T.unsafe(nil)); end
  def method_called?(param0, param1); end
  def on_block(node); end

  private

  def child_let_bang(node, &block); end
  def outer_let_bang?(ancestor_node, method_name); end
  def overrides_outer_let_bang?(node, method_name); end
  def unused_let_bang(node); end
end

RuboCop::Cop::RSpec::LetSetup::MSG = T.let(T.unsafe(nil), String)

module RuboCop::Cop::RSpec::LocationHelp
  private

  def arguments_with_whitespace(node); end
  def block_with_whitespace(node); end

  class << self
    def arguments_with_whitespace(node); end
    def block_with_whitespace(node); end
  end
end

class RuboCop::Cop::RSpec::MatchArray < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def match_array_with_empty_array?(param0 = T.unsafe(nil)); end
  def on_send(node); end

  private

  def check_populated_array(node); end
end

RuboCop::Cop::RSpec::MatchArray::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::MatchArray::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::MatchWithSimpleRegex < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def match_with_regexp?(param0 = T.unsafe(nil)); end
  def on_send(node); end

  private

  def regexp_to_string(node); end
  def simple_expression?(expr); end
  def simple_regexp?(node); end
  def to_string_literal(string); end
end

RuboCop::Cop::RSpec::MatchWithSimpleRegex::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::MatchWithSimpleRegex::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::MessageChain < ::RuboCop::Cop::RSpec::Base
  def on_send(node); end
end

RuboCop::Cop::RSpec::MessageChain::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::MessageChain::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::MessageExpectation < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::ConfigurableEnforcedStyle

  def message_expectation(param0 = T.unsafe(nil)); end
  def on_send(node); end
  def receive_message?(param0); end

  private

  def preferred_style?(expectation); end
end

RuboCop::Cop::RSpec::MessageExpectation::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::MessageExpectation::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::MessageSpies < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::ConfigurableEnforcedStyle

  def message_expectation(param0 = T.unsafe(nil)); end
  def on_send(node); end
  def receive_message(param0); end

  private

  def error_message(receiver); end
  def preferred_style?(expectation); end
  def receive_message_matcher(node); end
end

RuboCop::Cop::RSpec::MessageSpies::MSG_HAVE_RECEIVED = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::MessageSpies::MSG_RECEIVE = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::MessageSpies::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

module RuboCop::Cop::RSpec::Metadata
  include ::RuboCop::RSpec::Language
  extend ::RuboCop::AST::NodePattern::Macros

  def metadata_in_block(param0, param1); end
  def on_block(node); end
  def on_itblock(node); end
  def on_metadata(_symbols, _hash); end
  def on_numblock(node); end
  def rspec_configure(param0 = T.unsafe(nil)); end
  def rspec_metadata(param0 = T.unsafe(nil)); end

  private

  def on_metadata_arguments(metadata_arguments); end
end

class RuboCop::Cop::RSpec::MetadataStyle < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::ConfigurableEnforcedStyle
  include ::RuboCop::Cop::RSpec::Metadata
  include ::RuboCop::Cop::RangeHelp
  extend ::RuboCop::Cop::AutoCorrector

  def extract_metadata_hash(param0 = T.unsafe(nil)); end
  def match_ambiguous_trailing_metadata?(param0 = T.unsafe(nil)); end
  def match_boolean_metadata_pair?(param0 = T.unsafe(nil)); end
  def on_metadata(symbols, hash); end

  private

  def autocorrect_pair(corrector, node); end
  def autocorrect_symbol(corrector, node); end
  def bad_metadata_pair?(node); end
  def bad_metadata_symbol?(_node); end
  def format_symbol_to_pair_source(node); end
  def insert_pair(corrector, node); end
  def insert_pair_as_last_argument(corrector, node); end
  def insert_pair_to_empty_hash_metadata(corrector, node, hash_node); end
  def insert_pair_to_non_empty_hash_metadata(corrector, node, hash_node); end
  def insert_symbol(corrector, node); end
  def message_for_style; end
  def on_metadata_pair(node); end
  def on_metadata_symbol(node); end
  def remove_pair(corrector, node); end
  def remove_pair_following(corrector, node); end
  def remove_pair_preceding(corrector, node); end
  def remove_symbol(corrector, node); end
end

class RuboCop::Cop::RSpec::MissingExampleGroupArgument < ::RuboCop::Cop::RSpec::Base
  def on_block(node); end
end

RuboCop::Cop::RSpec::MissingExampleGroupArgument::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::MissingExpectationTargetMethod < ::RuboCop::Cop::RSpec::Base
  def expect?(param0 = T.unsafe(nil)); end
  def expect_block?(param0 = T.unsafe(nil)); end
  def expectation_without_runner?(param0 = T.unsafe(nil)); end
  def on_send(node); end
end

RuboCop::Cop::RSpec::MissingExpectationTargetMethod::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::MissingExpectationTargetMethod::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::MultipleDescribes < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::TopLevelGroup

  def on_top_level_group(node); end
end

RuboCop::Cop::RSpec::MultipleDescribes::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::MultipleExpectations < ::RuboCop::Cop::RSpec::Base
  def aggregate_failures?(param0 = T.unsafe(nil), param1); end
  def aggregate_failures_block?(param0 = T.unsafe(nil)); end
  def expect?(param0 = T.unsafe(nil)); end
  def max=(value); end
  def on_block(node); end

  private

  def example_with_aggregate_failures?(example_node); end
  def find_aggregate_failures(example_node); end
  def find_expectation(node, &block); end
  def flag_example(node, expectation_count:); end
  def max_expectations; end
end

RuboCop::Cop::RSpec::MultipleExpectations::ANYTHING = T.let(T.unsafe(nil), Proc)
RuboCop::Cop::RSpec::MultipleExpectations::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::MultipleExpectations::TRUE_NODE = T.let(T.unsafe(nil), Proc)

class RuboCop::Cop::RSpec::MultipleMemoizedHelpers < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::Variable

  def max=(value); end
  def on_block(node); end
  def on_new_investigation; end

  private

  def all_helpers(node); end
  def allow_subject?; end
  def example_group_memoized_helpers; end
  def helpers(node); end
  def max; end
  def variable_nodes(node); end
end

RuboCop::Cop::RSpec::MultipleMemoizedHelpers::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::MultipleSubjects < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RangeHelp
  extend ::RuboCop::Cop::AutoCorrector

  def on_block(node); end

  private

  def autocorrect(corrector, subject); end
  def named_subject?(node); end
  def remove_autocorrect(corrector, node); end
  def rename_autocorrect(corrector, node); end
end

RuboCop::Cop::RSpec::MultipleSubjects::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::NamedSubject < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::ConfigurableEnforcedStyle

  def example_or_hook_block?(param0 = T.unsafe(nil)); end
  def on_block(node); end
  def shared_example?(param0 = T.unsafe(nil)); end
  def subject_usage(param0); end

  private

  def allow_explicit_subject?(node); end
  def always?; end
  def check_explicit_subject(node); end
  def find_subject(block_node); end
  def ignored_shared_example?(node); end
  def named_only?(node); end
  def nearest_subject(node); end
  def subject_definition_is_named?(node); end
end

RuboCop::Cop::RSpec::NamedSubject::MSG = T.let(T.unsafe(nil), String)

module RuboCop::Cop::RSpec::Namespace
  private

  def namespace(node); end
end

class RuboCop::Cop::RSpec::NestedGroups < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::TopLevelGroup

  def max=(value); end
  def on_top_level_group(node); end

  private

  def allowed_groups; end
  def count_up_nesting?(node, example_group); end
  def find_nested_example_groups(node, nesting: T.unsafe(nil), &block); end
  def max_nesting; end
  def max_nesting_config; end
  def message(nesting); end
end

RuboCop::Cop::RSpec::NestedGroups::DEPRECATED_MAX_KEY = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::NestedGroups::DEPRECATION_WARNING = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::NestedGroups::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::NoExpectationExample < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::AllowedPattern
  include ::RuboCop::Cop::RSpec::SkipOrPending

  def includes_expectation?(param0); end
  def includes_skip_example?(param0); end
  def on_block(node); end
  def on_itblock(node); end
  def on_numblock(node); end
  def regular_or_focused_example?(param0 = T.unsafe(nil)); end
end

RuboCop::Cop::RSpec::NoExpectationExample::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::NotToNot < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::ConfigurableEnforcedStyle
  extend ::RuboCop::Cop::AutoCorrector

  def not_to_not_offense(param0 = T.unsafe(nil), param1); end
  def on_send(node); end

  private

  def message(_node); end
end

RuboCop::Cop::RSpec::NotToNot::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::NotToNot::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::Output < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def io_output?(param0 = T.unsafe(nil)); end
  def on_send(node); end
  def output?(param0 = T.unsafe(nil)); end

  private

  def match_gvar?(sym); end
end

RuboCop::Cop::RSpec::Output::IO_METHODS = T.let(T.unsafe(nil), Set)
RuboCop::Cop::RSpec::Output::KERNEL_METHODS = T.let(T.unsafe(nil), Set)
RuboCop::Cop::RSpec::Output::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::Output::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::OverwritingSetup < ::RuboCop::Cop::RSpec::Base
  def first_argument_name(param0 = T.unsafe(nil)); end
  def on_block(node); end
  def setup?(param0 = T.unsafe(nil)); end

  private

  def common_setup?(node); end
  def find_duplicates(node); end
end

RuboCop::Cop::RSpec::OverwritingSetup::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::Pending < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::SkipOrPending

  def on_send(node); end
  def pending_block?(param0 = T.unsafe(nil)); end
  def skippable?(param0 = T.unsafe(nil)); end
  def skippable_example?(param0 = T.unsafe(nil)); end

  private

  def skipped?(node); end
  def skipped_regular_example_without_body?(node); end
end

RuboCop::Cop::RSpec::Pending::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::PendingWithoutReason < ::RuboCop::Cop::RSpec::Base
  def metadata_without_reason?(param0 = T.unsafe(nil)); end
  def on_send(node); end
  def skipped_by_example_group_method?(param0 = T.unsafe(nil)); end
  def skipped_by_example_method?(param0 = T.unsafe(nil)); end
  def skipped_by_example_method_with_block?(param0 = T.unsafe(nil)); end
  def skipped_in_example?(param0 = T.unsafe(nil)); end

  private

  def block_node_example_group?(node); end
  def on_pending_by_metadata(node); end
  def on_skipped_by_example_group_method(node); end
  def on_skipped_by_example_method(node); end
  def on_skipped_by_in_example_method(node); end
  def parent_node(node); end
end

RuboCop::Cop::RSpec::PendingWithoutReason::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::PredicateMatcher < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::ConfigurableEnforcedStyle
  include ::RuboCop::Cop::RSpec::InflectedHelper
  include ::RuboCop::Cop::RSpec::ExplicitHelper
  extend ::RuboCop::Cop::AutoCorrector

  def on_block(node); end
  def on_send(node); end
end

RuboCop::Cop::RSpec::PredicateMatcher::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::ReceiveCounts < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def on_send(node); end
  def receive_counts(param0 = T.unsafe(nil)); end
  def stub?(param0); end

  private

  def autocorrect(corrector, node, range); end
  def matcher_for(method, count); end
  def message_for(node, source); end
  def range(node, offending_node); end
end

RuboCop::Cop::RSpec::ReceiveCounts::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::ReceiveCounts::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::ReceiveMessages < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RangeHelp
  extend ::RuboCop::Cop::AutoCorrector

  def allow_argument(param0 = T.unsafe(nil)); end
  def allow_receive_message?(param0 = T.unsafe(nil)); end
  def on_begin(node); end
  def receive_and_return_argument(param0 = T.unsafe(nil)); end
  def receive_arg(param0); end
  def receive_node(param0); end

  private

  def add_repeated_lines_and_arguments(items); end
  def arguments(items); end
  def heredoc_or_splat?(node); end
  def item_range_by_whole_lines(item); end
  def message(repeated_lines); end
  def normalize_receive_arg(receive_arg); end
  def normalize_return_arg(return_arg); end
  def register_offense(item, repeated_lines, args); end
  def repeated_receive_message(node); end
  def replace_to_receive_messages(corrector, item, args); end
  def requires_quotes?(value); end
  def uniq_items(items); end
end

RuboCop::Cop::RSpec::ReceiveMessages::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::ReceiveNever < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def expect_to_receive?(param0 = T.unsafe(nil)); end
  def method_on_stub?(param0); end
  def on_send(node); end

  private

  def autocorrect(corrector, node); end
  def used_with_expect?(node); end
end

RuboCop::Cop::RSpec::ReceiveNever::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::ReceiveNever::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::RedundantAround < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def match_redundant_around_hook_block?(param0 = T.unsafe(nil)); end
  def match_redundant_around_hook_send?(param0 = T.unsafe(nil)); end
  def on_block(node); end
  def on_itblock(node); end
  def on_numblock(node); end
  def on_send(node); end

  private

  def autocorrect(corrector, node); end
end

RuboCop::Cop::RSpec::RedundantAround::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::RedundantAround::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::RedundantPredicateMatcher < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def on_send(node); end

  private

  def message(bad_method, good_method); end
  def replaceable_arguments?(node); end
  def replaced_method_name(method_name); end
end

RuboCop::Cop::RSpec::RedundantPredicateMatcher::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::RedundantPredicateMatcher::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::RemoveConst < ::RuboCop::Cop::RSpec::Base
  def on_send(node); end
  def remove_const(param0 = T.unsafe(nil)); end
end

RuboCop::Cop::RSpec::RemoveConst::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::RemoveConst::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::RepeatedDescription < ::RuboCop::Cop::RSpec::Base
  def on_block(node); end

  private

  def example_signature(example); end
  def its_signature(example); end
  def repeated_descriptions(node); end
  def repeated_its(node); end
end

RuboCop::Cop::RSpec::RepeatedDescription::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::RepeatedExample < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::RepeatedItems

  def on_block(node); end

  private

  def add_offenses_for_repeated_group(repeated_examples); end
  def build_example_signature(example); end
  def extract_other_lines(examples_group, current_example); end
  def find_repeated_examples(node); end
  def message(other_lines); end
end

RuboCop::Cop::RSpec::RepeatedExample::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::RepeatedExampleGroupBody < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::SkipOrPending
  include ::RuboCop::Cop::RSpec::RepeatedItems

  def body(param0 = T.unsafe(nil)); end
  def const_arg(param0 = T.unsafe(nil)); end
  def metadata(param0 = T.unsafe(nil)); end
  def on_begin(node); end
  def several_example_groups?(param0 = T.unsafe(nil)); end

  private

  def message(group, repeats); end
  def repeated_group_bodies(node); end
  def signature_keys(group); end
end

RuboCop::Cop::RSpec::RepeatedExampleGroupBody::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::RepeatedExampleGroupDescription < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::SkipOrPending
  include ::RuboCop::Cop::RSpec::RepeatedItems

  def doc_string_and_metadata(param0 = T.unsafe(nil)); end
  def empty_description?(param0 = T.unsafe(nil)); end
  def on_begin(node); end
  def several_example_groups?(param0 = T.unsafe(nil)); end

  private

  def message(group, repeats); end
  def repeated_group_descriptions(node); end
end

RuboCop::Cop::RSpec::RepeatedExampleGroupDescription::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::RepeatedIncludeExample < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::RepeatedItems

  def include_examples?(param0 = T.unsafe(nil)); end
  def on_begin(node); end
  def several_include_examples?(param0 = T.unsafe(nil)); end
  def shared_examples_name(param0 = T.unsafe(nil)); end

  private

  def literal_include_examples?(node); end
  def message(item, repeats); end
  def repeated_include_examples(node); end
  def signature_keys(item); end
end

RuboCop::Cop::RSpec::RepeatedIncludeExample::MSG = T.let(T.unsafe(nil), String)

module RuboCop::Cop::RSpec::RepeatedItems
  def add_repeated_lines(items); end
  def find_repeated_groups(items, key_proc:); end
end

class RuboCop::Cop::RSpec::RepeatedSubjectCall < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::TopLevelGroup

  def on_top_level_group(node); end
  def subject?(param0 = T.unsafe(nil)); end
  def subject_calls(param0, param1); end

  private

  def detect_offense(subject_node); end
  def detect_offenses_in_block(node, subject_names = T.unsafe(nil)); end
  def detect_offenses_in_example(node, subject_names); end
  def detect_subjects_in_scope(node); end
  def expect_block(node); end
end

RuboCop::Cop::RSpec::RepeatedSubjectCall::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::ReturnFromStub < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::ConfigurableEnforcedStyle
  extend ::RuboCop::Cop::AutoCorrector

  def and_return_value(param0); end
  def contains_stub?(param0); end
  def on_block(node); end
  def on_send(node); end
  def stub_with_block?(param0 = T.unsafe(nil)); end

  private

  def check_and_return_call(node); end
  def check_block_body(block); end
  def dynamic?(node); end
end

class RuboCop::Cop::RSpec::ReturnFromStub::AndReturnCallCorrector
  def initialize(node); end

  def call(corrector); end

  private

  def arg; end
  def hash_without_braces?; end
  def heredoc?; end
  def node; end
  def range; end
  def receiver; end
  def replacement; end
end

class RuboCop::Cop::RSpec::ReturnFromStub::BlockBodyCorrector
  def initialize(block); end

  def call(corrector); end

  private

  def block; end
  def body; end
  def heredoc?; end
  def node; end
end

RuboCop::Cop::RSpec::ReturnFromStub::BlockBodyCorrector::NULL_BLOCK_BODY = T.let(T.unsafe(nil), T.untyped)
RuboCop::Cop::RSpec::ReturnFromStub::MSG_AND_RETURN = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::ReturnFromStub::MSG_BLOCK = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::ReturnFromStub::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::ScatteredLet < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def on_block(node); end

  private

  def check_let_declarations(body); end
end

RuboCop::Cop::RSpec::ScatteredLet::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::ScatteredSetup < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::FinalEndLocation
  include ::RuboCop::Cop::RangeHelp
  include ::RuboCop::Cop::RSpec::RepeatedItems
  extend ::RuboCop::Cop::AutoCorrector

  def on_block(node); end

  private

  def autocorrect(corrector, first_occurrence, occurrence); end
  def lines_msg(numbers); end
  def message(occurrences, occurrence); end
  def repeated_hooks(node); end
end

RuboCop::Cop::RSpec::ScatteredSetup::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::SharedContext < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def context?(param0); end
  def examples?(param0); end
  def on_block(node); end
  def shared_context(param0 = T.unsafe(nil)); end
  def shared_example(param0 = T.unsafe(nil)); end

  private

  def can_correct?(node); end
  def examples_with_only_context(node); end
  def message; end
  def offending_node(node); end
  def strict?; end
end

RuboCop::Cop::RSpec::SharedContext::MSG_CONTEXT = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::SharedContext::MSG_EXAMPLES = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::SharedContext::MSG_EXAMPLES_STRICT = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::SharedExamples < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::ConfigurableEnforcedStyle
  extend ::RuboCop::Cop::AutoCorrector

  def on_send(node); end
  def shared_examples(param0 = T.unsafe(nil)); end

  private

  def new_checker(ast_node); end
  def offense?(ast_node); end
end

class RuboCop::Cop::RSpec::SharedExamples::StringChecker
  def initialize(node); end

  def message; end
  def node; end
  def preferred_style; end
end

RuboCop::Cop::RSpec::SharedExamples::StringChecker::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::SharedExamples::SymbolChecker
  def initialize(node); end

  def message; end
  def node; end
  def preferred_style; end
end

RuboCop::Cop::RSpec::SharedExamples::SymbolChecker::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::SingleArgumentMessageChain < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def message_chain(param0 = T.unsafe(nil)); end
  def on_send(node); end
  def single_key_hash?(param0 = T.unsafe(nil)); end

  private

  def autocorrect(corrector, node, method, arg); end
  def autocorrect_array_arg(corrector, arg); end
  def autocorrect_hash_arg(corrector, arg); end
  def key_to_arg(node); end
  def replacement(method); end
  def single_element_array?(node); end
  def valid_usage?(node); end
end

RuboCop::Cop::RSpec::SingleArgumentMessageChain::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::SingleArgumentMessageChain::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::SkipBlockInsideExample < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::InsideExample

  def on_block(node); end
  def on_itblock(node); end
  def on_numblock(node); end
end

RuboCop::Cop::RSpec::SkipBlockInsideExample::MSG = T.let(T.unsafe(nil), String)

module RuboCop::Cop::RSpec::SkipOrPending
  extend ::RuboCop::AST::NodePattern::Macros

  def skip_or_pending_inside_block?(param0 = T.unsafe(nil)); end
  def skipped_in_metadata?(param0 = T.unsafe(nil)); end
end

class RuboCop::Cop::RSpec::SortMetadata < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::Metadata
  include ::RuboCop::Cop::RangeHelp
  extend ::RuboCop::Cop::AutoCorrector

  def match_ambiguous_trailing_metadata?(param0 = T.unsafe(nil)); end
  def on_metadata(args, hash); end

  private

  def crime_scene(symbols, pairs); end
  def last_arg_could_be_a_hash?(args); end
  def replacement(symbols, pairs); end
  def sort_pairs(pairs); end
  def sort_symbols(symbols); end
  def sorted?(symbols, pairs); end
  def trailing_symbols(args); end
end

RuboCop::Cop::RSpec::SortMetadata::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::SpecFilePathFormat < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::TopLevelGroup
  include ::RuboCop::Cop::RSpec::Namespace
  include ::RuboCop::Cop::RSpec::FileHelp

  def example_group_arguments(param0 = T.unsafe(nil)); end
  def metadata_key_value(param0); end
  def on_top_level_example_group(node); end

  private

  def camel_to_snake_case(string); end
  def correct_path_pattern(class_name, arguments); end
  def custom_transform; end
  def ensure_correct_file_path(send_node, class_name, arguments); end
  def expected_path(constant); end
  def filename_ends_with?(pattern); end
  def ignore_metadata; end
  def ignore_metadata?(arguments); end
  def ignore_method_name?(method_name); end
  def ignore_methods?; end
  def inflector; end
  def method_name_pattern(method_name); end
end

module RuboCop::Cop::RSpec::SpecFilePathFormat::ActiveSupportInflector
  class << self
    def call(string); end
    def prepare_availability(config); end
  end
end

module RuboCop::Cop::RSpec::SpecFilePathFormat::DefaultInflector
  class << self
    def call(string); end
  end
end

RuboCop::Cop::RSpec::SpecFilePathFormat::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::SpecFilePathFormat::PATH_NAME_BOUNDARY = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::SpecFilePathSuffix < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::TopLevelGroup
  include ::RuboCop::Cop::RSpec::FileHelp

  def on_top_level_example_group(node); end

  private

  def correct_path?; end
end

RuboCop::Cop::RSpec::SpecFilePathSuffix::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::StubbedMock < ::RuboCop::Cop::RSpec::Base
  def configured_response?(param0 = T.unsafe(nil)); end
  def expectation(param0 = T.unsafe(nil)); end
  def matcher_with_blockpass(param0 = T.unsafe(nil)); end
  def matcher_with_configured_response(param0 = T.unsafe(nil)); end
  def matcher_with_hash(param0 = T.unsafe(nil)); end
  def matcher_with_return_block(param0 = T.unsafe(nil)); end
  def message_expectation?(param0 = T.unsafe(nil)); end
  def on_send(node); end

  private

  def msg(method_name); end
  def on_expectation(expectation, method_name, matcher); end
  def replacement(method_name); end
end

RuboCop::Cop::RSpec::StubbedMock::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::StubbedMock::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::SubjectDeclaration < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def offensive_subject_declaration?(param0 = T.unsafe(nil)); end
  def on_send(node); end

  private

  def first_argument_range(node); end
  def message_for(offense); end
end

RuboCop::Cop::RSpec::SubjectDeclaration::MSG_LET = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::SubjectDeclaration::MSG_REDUNDANT = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::SubjectStub < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::TopLevelGroup

  def let?(param0 = T.unsafe(nil)); end
  def message_expectation?(param0 = T.unsafe(nil), param1); end
  def message_expectation_matcher?(param0); end
  def on_top_level_group(node); end
  def subject?(param0 = T.unsafe(nil)); end

  private

  def find_all_explicit(node); end
  def find_subject_expectations(node, subject_names = T.unsafe(nil), &block); end
end

RuboCop::Cop::RSpec::SubjectStub::MSG = T.let(T.unsafe(nil), String)

module RuboCop::Cop::RSpec::TopLevelGroup
  extend ::RuboCop::AST::NodePattern::Macros

  def on_new_investigation; end
  def top_level_groups; end

  private

  def on_top_level_example_group(_node); end
  def on_top_level_group(_node); end
  def root_node; end
  def top_level_group?(node); end
  def top_level_nodes(node); end
end

RuboCop::Cop::RSpec::TopLevelGroup::DEPRECATED_MODULE_METHOD_WARNING = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::UndescriptiveLiteralsDescription < ::RuboCop::Cop::RSpec::Base
  def example_groups_or_example?(param0 = T.unsafe(nil)); end
  def on_block(node); end

  private

  def offense?(node); end
end

RuboCop::Cop::RSpec::UndescriptiveLiteralsDescription::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::UnspecifiedException < ::RuboCop::Cop::RSpec::Base
  def expect_to?(param0 = T.unsafe(nil)); end
  def on_send(node); end

  private

  def empty_exception_matcher?(node); end
  def find_expect_to(node); end
end

RuboCop::Cop::RSpec::UnspecifiedException::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::UnspecifiedException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

module RuboCop::Cop::RSpec::Variable
  extend ::RuboCop::AST::NodePattern::Macros

  def variable_definition?(param0 = T.unsafe(nil)); end
end

RuboCop::Cop::RSpec::Variable::Helpers = RuboCop::RSpec::Language::Helpers
RuboCop::Cop::RSpec::Variable::Subjects = RuboCop::RSpec::Language::Subjects

class RuboCop::Cop::RSpec::VariableDefinition < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::ConfigurableEnforcedStyle
  include ::RuboCop::Cop::RSpec::Variable
  include ::RuboCop::Cop::RSpec::InsideExampleGroup
  extend ::RuboCop::Cop::AutoCorrector

  def on_send(node); end

  private

  def correct_variable(variable); end
  def style_offense?(variable); end
end

RuboCop::Cop::RSpec::VariableDefinition::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::VariableName < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::ConfigurableEnforcedStyle
  include ::RuboCop::Cop::ConfigurableFormatting
  include ::RuboCop::Cop::ConfigurableNaming
  include ::RuboCop::Cop::AllowedPattern
  include ::RuboCop::Cop::RSpec::Variable
  include ::RuboCop::Cop::RSpec::InsideExampleGroup

  def on_send(node); end

  private

  def message(style); end
end

RuboCop::Cop::RSpec::VariableName::MSG = T.let(T.unsafe(nil), String)

class RuboCop::Cop::RSpec::VerifiedDoubleReference < ::RuboCop::Cop::RSpec::Base
  extend ::RuboCop::Cop::AutoCorrector

  def autocorrect(corrector, node); end
  def on_send(node); end
  def verified_double(param0 = T.unsafe(nil)); end
end

RuboCop::Cop::RSpec::VerifiedDoubleReference::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::VerifiedDoubleReference::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set)

class RuboCop::Cop::RSpec::VerifiedDoubles < ::RuboCop::Cop::RSpec::Base
  def on_send(node); end
  def unverified_double(param0 = T.unsafe(nil)); end

  private

  def hash?(arg); end
  def symbol?(name); end
end

RuboCop::Cop::RSpec::VerifiedDoubles::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::VerifiedDoubles::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::VoidExpect < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RSpec::InsideExample

  def expect?(param0 = T.unsafe(nil)); end
  def expect_block?(param0 = T.unsafe(nil)); end
  def on_block(node); end
  def on_send(node); end

  private

  def check_expect(node); end
  def void?(expect); end
end

RuboCop::Cop::RSpec::VoidExpect::MSG = T.let(T.unsafe(nil), String)
RuboCop::Cop::RSpec::VoidExpect::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array)

class RuboCop::Cop::RSpec::Yield < ::RuboCop::Cop::RSpec::Base
  include ::RuboCop::Cop::RangeHelp
  extend ::RuboCop::Cop::AutoCorrector

  def block_arg(param0 = T.unsafe(nil)); end
  def block_call?(param0 = T.unsafe(nil), param1); end
  def method_on_stub?(param0); end
  def on_block(node); end

  private

  def autocorrect(corrector, node, range); end
  def block_range(node); end
  def calling_block?(node, block); end
  def convert_block_to_yield(node); end
  def generate_replacement(node); end
end

RuboCop::Cop::RSpec::Yield::MSG = T.let(T.unsafe(nil), String)
module RuboCop::RSpec; end

class RuboCop::RSpec::AlignLetBrace
  include ::RuboCop::RSpec::Language
  include ::RuboCop::PathUtil
  include ::RuboCop::Cop::Util

  def initialize(root, token); end

  def indent_for(node); end
  def offending_tokens; end

  private

  def adjacent_let_chunks; end
  def let_group_for(let); end
  def let_token(node); end
  def root; end
  def single_line_lets; end
  def target_column_for(let); end
  def token; end
end

class RuboCop::RSpec::Concept
  include ::RuboCop::RSpec::Language
  extend ::RuboCop::AST::NodePattern::Macros

  def initialize(node); end

  def ==(other); end
  def eql?(other); end
  def hash; end
  def to_node; end

  protected

  def node; end
end

module RuboCop::RSpec::Corrector; end

class RuboCop::RSpec::Corrector::MoveNode
  include ::RuboCop::Cop::RangeHelp
  include ::RuboCop::Cop::RSpec::FinalEndLocation
  include ::RuboCop::Cop::RSpec::CommentsHelp

  def initialize(node, corrector, processed_source); end

  def corrector; end
  def move_after(other); end
  def move_before(other); end
  def original; end
  def processed_source; end

  private

  def node_range(node); end
  def node_range_with_surrounding_space(node); end
  def source(node); end
end

class RuboCop::RSpec::Example < ::RuboCop::RSpec::Concept
  def definition; end
  def doc_string; end
  def extract_doc_string(param0 = T.unsafe(nil)); end
  def extract_implementation(param0 = T.unsafe(nil)); end
  def extract_metadata(param0 = T.unsafe(nil)); end
  def implementation; end
  def metadata; end
end

class RuboCop::RSpec::ExampleGroup < ::RuboCop::RSpec::Concept
  def examples; end
  def hooks; end
  def lets; end
  def scope_change?(param0 = T.unsafe(nil)); end
  def subjects; end

  private

  def find_all(node, predicate); end
  def find_all_in_scope(node, predicate); end
end

class RuboCop::RSpec::Hook < ::RuboCop::RSpec::Concept
  def example?; end
  def extract_metadata(param0 = T.unsafe(nil)); end
  def inside_class_method?; end
  def knowable_scope?; end
  def metadata; end
  def name; end
  def scope; end

  private

  def inside_class_self?(node); end
  def scope_argument; end
  def scope_name; end
  def transform_metadata(meta); end
  def transform_true(node); end
  def valid_scope?(node); end
end

module RuboCop::RSpec::Language
  extend ::RuboCop::AST::NodePattern::Macros

  def example?(param0 = T.unsafe(nil)); end
  def example_group?(param0 = T.unsafe(nil)); end
  def example_group_with_body?(param0 = T.unsafe(nil)); end
  def explicit_rspec?(param0 = T.unsafe(nil)); end
  def hook?(param0 = T.unsafe(nil)); end
  def include?(param0 = T.unsafe(nil)); end
  def let?(param0 = T.unsafe(nil)); end
  def rspec?(param0 = T.unsafe(nil)); end
  def shared_group?(param0 = T.unsafe(nil)); end
  def spec_group?(param0 = T.unsafe(nil)); end
  def subject?(param0 = T.unsafe(nil)); end

  class << self
    def config; end
    def config=(_arg0); end
  end
end

module RuboCop::RSpec::Language::ALL
  class << self
    def all(element); end
  end
end

module RuboCop::RSpec::Language::ErrorMatchers
  class << self
    def all(element); end
  end
end

module RuboCop::RSpec::Language::ExampleGroups
  class << self
    def all(element); end
    def focused(element); end
    def regular(element); end
    def skipped(element); end
  end
end

module RuboCop::RSpec::Language::Examples
  class << self
    def all(element); end
    def focused(element); end
    def pending(element); end
    def regular(element); end
    def skipped(element); end
  end
end

module RuboCop::RSpec::Language::Expectations
  class << self
    def all(element); end
  end
end

module RuboCop::RSpec::Language::Helpers
  class << self
    def all(element); end
  end
end

module RuboCop::RSpec::Language::HookScopes
  class << self
    def all(element); end
  end
end

RuboCop::RSpec::Language::HookScopes::ALL = T.let(T.unsafe(nil), Array)

module RuboCop::RSpec::Language::Hooks
  class << self
    def all(element); end
  end
end

module RuboCop::RSpec::Language::Includes
  class << self
    def all(element); end
    def context(element); end
    def examples(element); end
  end
end

module RuboCop::RSpec::Language::Runners
  class << self
    def all(element = T.unsafe(nil)); end
  end
end

RuboCop::RSpec::Language::Runners::ALL = T.let(T.unsafe(nil), Array)

module RuboCop::RSpec::Language::SharedGroups
  class << self
    def all(element); end
    def context(element); end
    def examples(element); end
  end
end

module RuboCop::RSpec::Language::Subjects
  class << self
    def all(element); end
  end
end

module RuboCop::RSpec::Node
  def recursive_literal_or_const?; end
end

class RuboCop::RSpec::Plugin < ::LintRoller::Plugin
  def about; end
  def rules(_context); end
  def supported?(context); end
end

module RuboCop::RSpec::Version; end
RuboCop::RSpec::Version::STRING = T.let(T.unsafe(nil), String)

class RuboCop::RSpec::Wording
  def initialize(text, ignore:, replace:); end

  def rewrite; end

  private

  def append_suffix(word, suffix); end
  def ignored_word?(word); end
  def ignores; end
  def remove_should_and_pluralize; end
  def replace_prefix(pattern, replacement); end
  def replacements; end
  def substitute(word); end
  def text; end
  def uppercase?(word); end
end

RuboCop::RSpec::Wording::ES_SUFFIX_PATTERN = T.let(T.unsafe(nil), Regexp)
RuboCop::RSpec::Wording::IES_SUFFIX_PATTERN = T.let(T.unsafe(nil), Regexp)
RuboCop::RSpec::Wording::SHOULDNT_BE_PREFIX = T.let(T.unsafe(nil), Regexp)
RuboCop::RSpec::Wording::SHOULDNT_PREFIX = T.let(T.unsafe(nil), Regexp)
RuboCop::RSpec::Wording::WILL_NOT_PREFIX = T.let(T.unsafe(nil), Regexp)
RuboCop::RSpec::Wording::WONT_PREFIX = T.let(T.unsafe(nil), Regexp)
