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

# typed: true

module RSpec
  extend ::RSpec::Support::Warnings
  extend ::RSpec::Core::Warnings

  class << self
    def clear_examples; end
    def configuration; end
    def configuration=(_arg0); end
    def configure; end
    def const_missing(name); end
    def context(*args, &example_group_block); end
    def current_example; end
    def current_example=(example); end
    def describe(*args, &example_group_block); end
    def example_group(*args, &example_group_block); end
    def fcontext(*args, &example_group_block); end
    def fdescribe(*args, &example_group_block); end
    def reset; end
    def shared_context(name, *args, &block); end
    def shared_examples(name, *args, &block); end
    def shared_examples_for(name, *args, &block); end
    def world; end
    def world=(_arg0); end
    def xcontext(*args, &example_group_block); end
    def xdescribe(*args, &example_group_block); end
  end
end

module RSpec::Expectations
  class << self
    def configuration; end
    def differ; end
    def fail_with(message, expected = T.unsafe(nil), actual = T.unsafe(nil)); end
  end
end

class RSpec::Expectations::BlockExpectationTarget < ::RSpec::Expectations::ExpectationTarget
  def not_to(matcher, message = T.unsafe(nil), &block); end
  def to(matcher, message = T.unsafe(nil), &block); end
  def to_not(matcher, message = T.unsafe(nil), &block); end

  private

  def enforce_block_expectation(matcher); end
  def supports_block_expectations?(matcher); end
end

class RSpec::Expectations::BlockSnippetExtractor
  def initialize(proc, method_name); end

  def body_content_lines; end
  def method_name; end
  def proc; end

  private

  def beginning_line_number; end
  def block_token_extractor; end
  def file_path; end
  def raw_body_lines; end
  def raw_body_snippet; end
  def source; end
  def source_location; end

  class << self
    def try_extracting_single_line_body_of(proc, method_name); end
  end
end

class RSpec::Expectations::BlockSnippetExtractor::AmbiguousTargetError < ::RSpec::Expectations::BlockSnippetExtractor::Error; end

class RSpec::Expectations::BlockSnippetExtractor::BlockLocator < ::Struct
  def beginning_line_number; end
  def beginning_line_number=(_); end
  def body_content_locations; end
  def method_call_location; end
  def method_name; end
  def method_name=(_); end
  def source; end
  def source=(_); end

  private

  def block_body_node; end
  def block_wrapper_node; end
  def candidate_block_wrapper_nodes; end
  def candidate_method_ident_nodes; end
  def method_ident_node; end
  def method_ident_node?(node); end

  class << self
    def [](*_arg0); end
    def inspect; end
    def members; end
    def new(*_arg0); end
  end
end

class RSpec::Expectations::BlockSnippetExtractor::BlockTokenExtractor < ::Struct
  def initialize(*_arg0); end

  def beginning_line_number; end
  def beginning_line_number=(_); end
  def body_tokens; end
  def method_name; end
  def method_name=(_); end
  def source; end
  def source=(_); end
  def state; end

  private

  def after_beginning_of_args_state(token); end
  def after_beginning_of_body_state(token); end
  def after_method_call_state(token); end
  def after_opener_state(token); end
  def block_locator; end
  def correct_block?(body_tokens); end
  def finalize_pending_tokens!; end
  def finish!; end
  def finish_or_find_next_block_if_incorrect!; end
  def handle_closer_token(token); end
  def handle_opener_token(token); end
  def initial_state(token); end
  def invoke_state_handler(token); end
  def opener_token?(token); end
  def opener_token_stack; end
  def parse!; end
  def pending_tokens; end
  def pipe_token?(token); end

  class << self
    def [](*_arg0); end
    def inspect; end
    def members; end
    def new(*_arg0); end
  end
end

class RSpec::Expectations::BlockSnippetExtractor::Error < ::StandardError; end
class RSpec::Expectations::BlockSnippetExtractor::TargetNotFoundError < ::RSpec::Expectations::BlockSnippetExtractor::Error; end

class RSpec::Expectations::Configuration
  def initialize; end

  def add_should_and_should_not_to(*modules); end
  def backtrace_formatter; end
  def backtrace_formatter=(_arg0); end
  def color?; end
  def false_positives_handler; end
  def include_chain_clauses_in_custom_matcher_descriptions=(_arg0); end
  def include_chain_clauses_in_custom_matcher_descriptions?; end
  def max_formatted_output_length=(length); end
  def on_potential_false_positives; end
  def on_potential_false_positives=(behavior); end
  def reset_syntaxes_to_default; end
  def strict_predicate_matchers; end
  def strict_predicate_matchers=(flag); end
  def strict_predicate_matchers?; end
  def syntax; end
  def syntax=(values); end
  def warn_about_potential_false_positives=(boolean); end
  def warn_about_potential_false_positives?; end
end

RSpec::Expectations::Configuration::FALSE_POSITIVE_BEHAVIOURS = T.let(T.unsafe(nil), Hash)

module RSpec::Expectations::Configuration::NullBacktraceFormatter
  class << self
    def format_backtrace(backtrace); end
  end
end

module RSpec::Expectations::ExpectationHelper
  class << self
    def check_message(msg); end
    def handle_failure(matcher, message, failure_message_method); end
    def modern_matcher_from(matcher); end
    def with_matcher(handler, matcher, message); end
  end
end

class RSpec::Expectations::ExpectationNotMetError < ::Exception; end

class RSpec::Expectations::ExpectationTarget
  include ::RSpec::Expectations::ExpectationTarget::InstanceMethods

  def initialize(value); end

  def target; end

  class << self
    def for(value, block); end
  end
end

module RSpec::Expectations::ExpectationTarget::InstanceMethods
  def not_to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
  def to(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end
  def to_not(matcher = T.unsafe(nil), message = T.unsafe(nil), &block); end

  private

  def prevent_operator_matchers(verb); end
end

module RSpec::Expectations::ExpectationTarget::UndefinedValue; end

class RSpec::Expectations::FailureAggregator
  def initialize(block_label, metadata); end

  def aggregate; end
  def block_label; end
  def call(failure, options); end
  def failures; end
  def metadata; end
  def other_errors; end

  private

  def assign_backtrace(failure); end
  def notify_aggregated_failures; end
end

RSpec::Expectations::LegacyMacherAdapter = RSpec::Expectations::LegacyMatcherAdapter

class RSpec::Expectations::LegacyMatcherAdapter < ::RSpec::Matchers::MatcherDelegator
  def initialize(matcher); end

  class << self
    def wrap(matcher); end
  end
end

class RSpec::Expectations::LegacyMatcherAdapter::RSpec1 < ::RSpec::Expectations::LegacyMatcherAdapter
  def failure_message; end
  def failure_message_when_negated; end

  class << self
    def interface_matches?(matcher); end
  end
end

class RSpec::Expectations::LegacyMatcherAdapter::RSpec2 < ::RSpec::Expectations::LegacyMatcherAdapter
  def failure_message; end
  def failure_message_when_negated; end

  class << self
    def interface_matches?(matcher); end
  end
end

class RSpec::Expectations::MultipleExpectationsNotMetError < ::RSpec::Expectations::ExpectationNotMetError
  def initialize(failure_aggregator); end

  def aggregation_block_label; end
  def aggregation_metadata; end
  def all_exceptions; end
  def exception_count_description; end
  def failures; end
  def message; end
  def other_errors; end
  def summary; end

  private

  def backtrace_line(line); end
  def block_description; end
  def enumerated(exceptions, index_offset); end
  def enumerated_errors; end
  def enumerated_failures; end
  def exclusion_patterns; end
  def format_backtrace(backtrace); end
  def indentation; end
  def indented(failure_message, index); end
  def index_label(index); end
  def longest_index_label_width; end
  def pluralize(noun, count); end
  def width_of_label(index); end
end

class RSpec::Expectations::NegativeExpectationHandler
  class << self
    def does_not_match?(matcher, actual, &block); end
    def handle_matcher(actual, initial_matcher, custom_message = T.unsafe(nil), &block); end
    def opposite_should_method; end
    def should_method; end
    def verb; end
  end
end

class RSpec::Expectations::PositiveExpectationHandler
  class << self
    def handle_matcher(actual, initial_matcher, custom_message = T.unsafe(nil), &block); end
    def opposite_should_method; end
    def should_method; end
    def verb; end
  end
end

module RSpec::Expectations::Syntax
  private

  def default_should_host; end
  def disable_expect(syntax_host = T.unsafe(nil)); end
  def disable_should(syntax_host = T.unsafe(nil)); end
  def enable_expect(syntax_host = T.unsafe(nil)); end
  def enable_should(syntax_host = T.unsafe(nil)); end
  def expect_enabled?(syntax_host = T.unsafe(nil)); end
  def should_enabled?(syntax_host = T.unsafe(nil)); end
  def warn_about_should!; end
  def warn_about_should_unless_configured(method_name); end

  class << self
    def default_should_host; end
    def disable_expect(syntax_host = T.unsafe(nil)); end
    def disable_should(syntax_host = T.unsafe(nil)); end
    def enable_expect(syntax_host = T.unsafe(nil)); end
    def enable_should(syntax_host = T.unsafe(nil)); end
    def expect_enabled?(syntax_host = T.unsafe(nil)); end
    def should_enabled?(syntax_host = T.unsafe(nil)); end
    def warn_about_should!; end
    def warn_about_should_unless_configured(method_name); end
  end
end

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

module RSpec::Matchers
  extend ::RSpec::Matchers::DSL

  def a_block_changing(*args, &block); end
  def a_block_outputting(*args, &block); end
  def a_block_raising(*args, &block); end
  def a_block_throwing(*args, &block); end
  def a_block_yielding_control(*args, &block); end
  def a_block_yielding_successive_args(*args, &block); end
  def a_block_yielding_with_args(*args, &block); end
  def a_block_yielding_with_no_args(*args, &block); end
  def a_collection_containing_exactly(*args, &block); end
  def a_collection_ending_with(*args, &block); end
  def a_collection_including(*args, &block); end
  def a_collection_starting_with(*args, &block); end
  def a_falsey_value(*args, &block); end
  def a_falsy_value(*args, &block); end
  def a_hash_including(*args, &block); end
  def a_kind_of(*args, &block); end
  def a_nil_value(*args, &block); end
  def a_range_covering(*args, &block); end
  def a_string_ending_with(*args, &block); end
  def a_string_including(*args, &block); end
  def a_string_matching(*args, &block); end
  def a_string_starting_with(*args, &block); end
  def a_truthy_value(*args, &block); end
  def a_value(*args, &block); end
  def a_value_between(*args, &block); end
  def a_value_within(*args, &block); end
  def aggregate_failures(label = T.unsafe(nil), metadata = T.unsafe(nil), &block); end
  def all(expected); end
  def an_instance_of(*args, &block); end
  def an_object_eq_to(*args, &block); end
  def an_object_eql_to(*args, &block); end
  def an_object_equal_to(*args, &block); end
  def an_object_existing(*args, &block); end
  def an_object_having_attributes(*args, &block); end
  def an_object_matching(*args, &block); end
  def an_object_responding_to(*args, &block); end
  def an_object_satisfying(*args, &block); end
  def be(*args); end
  def be_a(klass); end
  def be_a_kind_of(expected); end
  def be_an(klass); end
  def be_an_instance_of(expected); end
  def be_between(min, max); end
  def be_falsey; end
  def be_falsy(*args, &block); end
  def be_instance_of(expected); end
  def be_kind_of(expected); end
  def be_nil; end
  def be_truthy; end
  def be_within(delta); end
  def change(receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end
  def changing(*args, &block); end
  def contain_exactly(*items); end
  def containing_exactly(*args, &block); end
  def cover(*values); end
  def covering(*args, &block); end
  def end_with(*expected); end
  def ending_with(*args, &block); end
  def eq(expected); end
  def eq_to(*args, &block); end
  def eql(expected); end
  def eql_to(*args, &block); end
  def equal(expected); end
  def equal_to(*args, &block); end
  def exist(*args); end
  def existing(*args, &block); end
  def expect(value = T.unsafe(nil), &block); end
  def have_attributes(expected); end
  def having_attributes(*args, &block); end
  def include(*expected); end
  def including(*args, &block); end
  def match(expected); end
  def match_array(items); end
  def match_regex(*args, &block); end
  def matching(*args, &block); end
  def output(expected = T.unsafe(nil)); end
  def raise_error(error = T.unsafe(nil), message = T.unsafe(nil), &block); end
  def raise_exception(error = T.unsafe(nil), message = T.unsafe(nil), &block); end
  def raising(*args, &block); end
  def respond_to(*names); end
  def responding_to(*args, &block); end
  def satisfy(description = T.unsafe(nil), &block); end
  def satisfying(*args, &block); end
  def start_with(*expected); end
  def starting_with(*args, &block); end
  def throw_symbol(expected_symbol = T.unsafe(nil), expected_arg = T.unsafe(nil)); end
  def throwing(*args, &block); end
  def within(*args, &block); end
  def yield_control; end
  def yield_successive_args(*args); end
  def yield_with_args(*args); end
  def yield_with_no_args; end
  def yielding_control(*args, &block); end
  def yielding_successive_args(*args, &block); end
  def yielding_with_args(*args, &block); end
  def yielding_with_no_args(*args, &block); end

  private

  def method_missing(method, *args, &block); end
  def respond_to_missing?(method, *_arg1); end

  class << self
    def alias_matcher(*args, &block); end
    def clear_generated_description; end
    def configuration; end
    def generated_description; end
    def is_a_describable_matcher?(obj); end
    def is_a_matcher?(obj); end
    def last_description; end
    def last_expectation_handler; end
    def last_expectation_handler=(_arg0); end
    def last_matcher; end
    def last_matcher=(_arg0); end
  end
end

class RSpec::Matchers::AliasedMatcher < ::RSpec::Matchers::MatcherDelegator
  def initialize(base_matcher, description_block); end

  def description; end
  def failure_message; end
  def failure_message_when_negated; end
  def method_missing(*_arg0); end
end

class RSpec::Matchers::AliasedMatcherWithOperatorSupport < ::RSpec::Matchers::AliasedMatcher; end

class RSpec::Matchers::AliasedNegatedMatcher < ::RSpec::Matchers::AliasedMatcher
  def does_not_match?(*args, &block); end
  def failure_message; end
  def failure_message_when_negated; end
  def matches?(*args, &block); end

  private

  def optimal_failure_message(same, inverted); end
end

RSpec::Matchers::AliasedNegatedMatcher::DefaultFailureMessages = RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
RSpec::Matchers::BE_PREDICATE_REGEX = T.let(T.unsafe(nil), Regexp)
module RSpec::Matchers::BuiltIn; end

class RSpec::Matchers::BuiltIn::All < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def initialize(matcher); end

  def description; end
  def does_not_match?(_actual); end
  def failed_objects; end
  def failure_message; end
  def matcher; end

  private

  def add_new_line_if_needed(message); end
  def failure_message_for_item(index, failure_message); end
  def indent_multiline_message(message); end
  def index_failed_objects; end
  def initialize_copy(other); end
  def iterable?; end
  def match(_expected, _actual); end
end

class RSpec::Matchers::BuiltIn::BaseMatcher
  include ::RSpec::Matchers::Composable
  include ::RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
  include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages

  def initialize(expected = T.unsafe(nil)); end

  def actual; end
  def actual_formatted; end
  def description; end
  def diffable?; end
  def expected; end
  def expected_formatted; end
  def expects_call_stack_jump?; end
  def match_unless_raises(*exceptions); end
  def matcher_name; end
  def matcher_name=(_arg0); end
  def matches?(actual); end
  def present_ivars; end
  def rescued_exception; end
  def supports_block_expectations?; end

  private

  def assert_ivars(*expected_ivars); end

  class << self
    def matcher_name; end

    private

    def underscore(camel_cased_word); end
  end
end

module RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
  def failure_message; end
  def failure_message_when_negated; end

  class << self
    def has_default_failure_messages?(matcher); end
  end
end

module RSpec::Matchers::BuiltIn::BaseMatcher::HashFormatting
  private

  def improve_hash_formatting(inspect_string); end

  class << self
    def improve_hash_formatting(inspect_string); end
  end
end

RSpec::Matchers::BuiltIn::BaseMatcher::UNDEFINED = T.let(T.unsafe(nil), Object)

class RSpec::Matchers::BuiltIn::Be < ::RSpec::Matchers::BuiltIn::BaseMatcher
  include ::RSpec::Matchers::BuiltIn::BeHelpers

  def initialize(*args); end

  def <(operand); end
  def <=(operand); end
  def ==(operand); end
  def ===(operand); end
  def =~(operand); end
  def >(operand); end
  def >=(operand); end
  def failure_message; end
  def failure_message_when_negated; end

  private

  def match(_, actual); end
end

class RSpec::Matchers::BuiltIn::BeAKindOf < ::RSpec::Matchers::BuiltIn::BaseMatcher
  private

  def match(expected, actual); end
end

class RSpec::Matchers::BuiltIn::BeAnInstanceOf < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def description; end

  private

  def match(expected, actual); end
end

class RSpec::Matchers::BuiltIn::BeBetween < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def initialize(min, max); end

  def description; end
  def exclusive; end
  def failure_message; end
  def inclusive; end
  def matches?(actual); end

  private

  def comparable?; end
  def compare; end
  def not_comparable_clause; end
end

class RSpec::Matchers::BuiltIn::BeComparedTo < ::RSpec::Matchers::BuiltIn::BaseMatcher
  include ::RSpec::Matchers::BuiltIn::BeHelpers

  def initialize(operand, operator); end

  def description; end
  def does_not_match?(actual); end
  def failure_message; end
  def failure_message_when_negated; end
  def matches?(actual); end

  private

  def perform_match(actual); end
end

class RSpec::Matchers::BuiltIn::BeFalsey < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def failure_message; end
  def failure_message_when_negated; end

  private

  def match(_, actual); end
end

module RSpec::Matchers::BuiltIn::BeHelpers
  private

  def args_to_s; end
  def args_to_sentence; end
  def expected_to_sentence; end
  def inspected_args; end
  def parenthesize(string); end
end

class RSpec::Matchers::BuiltIn::BeNil < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def failure_message; end
  def failure_message_when_negated; end

  private

  def match(_, actual); end
end

class RSpec::Matchers::BuiltIn::BePredicate < ::RSpec::Matchers::BuiltIn::DynamicPredicate
  private

  def failure_to_respond_explanation; end
  def predicate; end
  def predicate_accessible?; end
  def predicate_method_name; end
  def present_tense_predicate; end
end

RSpec::Matchers::BuiltIn::BePredicate::REGEX = T.let(T.unsafe(nil), Regexp)

class RSpec::Matchers::BuiltIn::BeTruthy < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def failure_message; end
  def failure_message_when_negated; end

  private

  def match(_, actual); end
end

class RSpec::Matchers::BuiltIn::BeWithin < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def initialize(delta); end

  def description; end
  def failure_message; end
  def failure_message_when_negated; end
  def matches?(actual); end
  def of(expected); end
  def percent_of(expected); end

  private

  def needs_expected; end
  def not_numeric_clause; end
  def numeric?; end
end

module RSpec::Matchers::BuiltIn::CaptureStderr
  class << self
    def capture(block); end
    def name; end
  end
end

module RSpec::Matchers::BuiltIn::CaptureStdout
  class << self
    def capture(block); end
    def name; end
  end
end

class RSpec::Matchers::BuiltIn::CaptureStreamToTempfile < ::Struct
  def capture(block); end
end

class RSpec::Matchers::BuiltIn::Change < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def initialize(receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end

  def by(expected_delta); end
  def by_at_least(minimum); end
  def by_at_most(maximum); end
  def description; end
  def does_not_match?(event_proc); end
  def failure_message; end
  def failure_message_when_negated; end
  def from(value); end
  def matches?(event_proc); end
  def supports_block_expectations?; end
  def to(value); end

  private

  def change_details; end
  def negative_failure_reason; end
  def perform_change(event_proc); end
  def positive_failure_reason; end
  def raise_block_syntax_error; end
end

class RSpec::Matchers::BuiltIn::ChangeDetails
  def initialize(matcher_name, receiver = T.unsafe(nil), message = T.unsafe(nil), &block); end

  def actual_after; end
  def actual_delta; end
  def changed?; end
  def perform_change(event_proc); end
  def value_representation; end

  private

  def evaluate_value_proc; end
  def extract_value_block_snippet; end
  def message_notation(receiver, message); end
end

class RSpec::Matchers::BuiltIn::ChangeFromValue < ::RSpec::Matchers::BuiltIn::SpecificValuesChange
  def initialize(change_details, expected_before); end

  def does_not_match?(event_proc); end
  def failure_message_when_negated; end
  def to(value); end

  private

  def change_description; end
end

class RSpec::Matchers::BuiltIn::ChangeRelatively < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def initialize(change_details, expected_delta, relativity, &comparer); end

  def description; end
  def does_not_match?(_event_proc); end
  def failure_message; end
  def matches?(event_proc); end
  def supports_block_expectations?; end

  private

  def failure_reason; end
end

class RSpec::Matchers::BuiltIn::ChangeToValue < ::RSpec::Matchers::BuiltIn::SpecificValuesChange
  def initialize(change_details, expected_after); end

  def does_not_match?(_event_proc); end
  def from(value); end

  private

  def change_description; end
end

class RSpec::Matchers::BuiltIn::Compound < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def initialize(matcher_1, matcher_2); end

  def description; end
  def diffable?; end
  def does_not_match?(_actual); end
  def evaluator; end
  def expected; end
  def expects_call_stack_jump?; end
  def matcher_1; end
  def matcher_2; end
  def supports_block_expectations?; end

  protected

  def diffable_matcher_list; end

  private

  def compound_failure_message; end
  def diffable_matcher_list_for(matcher); end
  def indent_multiline_message(message); end
  def initialize_copy(other); end
  def match(_expected, actual); end
  def matcher_1_matches?; end
  def matcher_2_matches?; end
  def matcher_is_diffable?(matcher); end
  def matcher_supports_block_expectations?(matcher); end
end

class RSpec::Matchers::BuiltIn::Compound::And < ::RSpec::Matchers::BuiltIn::Compound
  def failure_message; end

  private

  def conjunction; end
  def match(*_arg0); end
end

class RSpec::Matchers::BuiltIn::Compound::NestedEvaluator
  def initialize(actual, matcher_1, matcher_2); end

  def matcher_matches?(matcher); end

  private

  def inner_matcher_block(outer_args); end
  def order_block_matchers; end

  class << self
    def matcher_expects_call_stack_jump?(matcher); end
  end
end

class RSpec::Matchers::BuiltIn::Compound::Or < ::RSpec::Matchers::BuiltIn::Compound
  def failure_message; end

  private

  def conjunction; end
  def match(*_arg0); end
end

class RSpec::Matchers::BuiltIn::Compound::SequentialEvaluator
  def initialize(actual, *_arg1); end

  def matcher_matches?(matcher); end
end

class RSpec::Matchers::BuiltIn::ContainExactly < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def description; end
  def failure_message; end
  def failure_message_when_negated; end

  private

  def actual_collection_line; end
  def best_solution; end
  def convert_actual_to_an_array; end
  def describe_collection(collection, surface_descriptions = T.unsafe(nil)); end
  def expected_collection_line; end
  def extra_elements_line; end
  def extra_items; end
  def generate_failure_message; end
  def match(_expected, _actual); end
  def match_when_sorted?; end
  def message_line(prefix, collection, surface_descriptions = T.unsafe(nil)); end
  def missing_elements_line; end
  def missing_items; end
  def pairings_maximizer; end
  def safe_sort(array); end
  def to_a_disallowed?(object); end
end

class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer
  def initialize(expected_to_actual_matched_indexes, actual_to_expected_matched_indexes); end

  def actual_to_expected_matched_indexes; end
  def expected_to_actual_matched_indexes; end
  def find_best_solution; end
  def solution; end

  private

  def apply_pairing_to(indeterminates, original_matches, other_list_index); end
  def best_solution_for_pairing(expected_index, actual_index); end
  def categorize_indexes(indexes_to_categorize, other_indexes); end
  def reciprocal_single_match?(matches, index, other_list); end
end

class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::NullSolution
  class << self
    def worse_than?(_other); end
  end
end

class RSpec::Matchers::BuiltIn::ContainExactly::PairingsMaximizer::Solution < ::Struct
  def +(derived_candidate_solution); end
  def candidate?; end
  def ideal?; end
  def indeterminate_actual_indexes; end
  def indeterminate_actual_indexes=(_); end
  def indeterminate_expected_indexes; end
  def indeterminate_expected_indexes=(_); end
  def unmatched_actual_indexes; end
  def unmatched_actual_indexes=(_); end
  def unmatched_expected_indexes; end
  def unmatched_expected_indexes=(_); end
  def unmatched_item_count; end
  def worse_than?(other); end

  class << self
    def [](*_arg0); end
    def inspect; end
    def members; end
    def new(*_arg0); end
  end
end

module RSpec::Matchers::BuiltIn::CountExpectation
  def at_least(number); end
  def at_most(number); end
  def exactly(number); end
  def once; end
  def thrice; end
  def times; end
  def twice; end

  protected

  def count_expectation_type; end
  def expected_count; end

  private

  def count_constraint_to_number(n); end
  def count_expectation_description; end
  def count_failure_reason(action); end
  def cover?(count, number); end
  def expected_count_matches?(actual_count); end
  def has_expected_count?; end
  def human_readable_count(count); end
  def human_readable_expectation_type; end
  def raise_impossible_count_expectation(count); end
  def raise_unsupported_count_expectation; end
  def set_expected_count(relativity, n); end
  def unsupported_count_expectation?(relativity); end
end

class RSpec::Matchers::BuiltIn::Cover < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def initialize(*expected); end

  def does_not_match?(range); end
  def matches?(range); end
end

class RSpec::Matchers::BuiltIn::DynamicPredicate < ::RSpec::Matchers::BuiltIn::BaseMatcher
  include ::RSpec::Matchers::BuiltIn::BeHelpers

  def initialize(method_name, *args, &block); end

  def description; end
  def does_not_match?(actual, &block); end
  def failure_message; end
  def failure_message_when_negated; end
  def matches?(actual, &block); end

  private

  def expectation_of(value); end
  def failure_message_expecting(value); end
  def failure_to_respond_explanation; end
  def method_description; end
  def predicate_accessible?; end
  def predicate_matches?(value = T.unsafe(nil)); end
  def predicate_method_name; end
  def predicate_result; end
  def private_predicate?; end
  def root; end
  def validity_message; end
end

class RSpec::Matchers::BuiltIn::EndWith < ::RSpec::Matchers::BuiltIn::StartOrEndWith
  private

  def element_matches?; end
  def subset_matches?; end
end

class RSpec::Matchers::BuiltIn::Eq < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def description; end
  def diffable?; end
  def failure_message; end
  def failure_message_when_negated; end

  private

  def match(expected, actual); end
end

class RSpec::Matchers::BuiltIn::Eql < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def diffable?; end
  def failure_message; end
  def failure_message_when_negated; end

  private

  def match(expected, actual); end
end

class RSpec::Matchers::BuiltIn::Equal < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def diffable?; end
  def failure_message; end
  def failure_message_when_negated; end

  private

  def actual_inspected; end
  def detailed_failure_message; end
  def expected_is_a_literal_singleton?; end
  def inspect_object(o); end
  def match(expected, actual); end
  def simple_failure_message; end
end

RSpec::Matchers::BuiltIn::Equal::LITERAL_SINGLETONS = T.let(T.unsafe(nil), Array)

class RSpec::Matchers::BuiltIn::Exist < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def initialize(*expected); end

  def does_not_match?(actual); end
  def failure_message; end
  def failure_message_when_negated; end
  def matches?(actual); end
end

class RSpec::Matchers::BuiltIn::Exist::ExistenceTest < ::Struct
  def actual_exists?; end
  def valid_test?; end
  def validity_message; end

  private

  def deprecated(predicate, actual); end
  def existence_values; end
  def predicates; end
  def uniq_truthy_values; end
end

class RSpec::Matchers::BuiltIn::Has < ::RSpec::Matchers::BuiltIn::DynamicPredicate
  private

  def predicate; end
end

RSpec::Matchers::BuiltIn::Has::REGEX = T.let(T.unsafe(nil), Regexp)

class RSpec::Matchers::BuiltIn::HaveAttributes < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def initialize(expected); end

  def actual; end
  def description; end
  def diffable?; end
  def does_not_match?(actual); end
  def failure_message; end
  def failure_message_when_negated; end
  def matches?(actual); end
  def respond_to_failed; end

  private

  def actual_has_attribute?(attribute_key, attribute_value); end
  def cache_all_values; end
  def formatted_values; end
  def perform_match(predicate); end
  def respond_to_attributes?; end
  def respond_to_failure_message_or; end
  def respond_to_matcher; end
end

class RSpec::Matchers::BuiltIn::Include < ::RSpec::Matchers::BuiltIn::BaseMatcher
  include ::RSpec::Matchers::BuiltIn::CountExpectation

  def initialize(*expecteds); end

  def description; end
  def diffable?; end
  def does_not_match?(actual); end
  def expected; end
  def expecteds; end
  def failure_message; end
  def failure_message_when_negated; end
  def matches?(actual); end

  private

  def actual_collection_includes?(expected_item); end
  def actual_hash_has_key?(expected_key); end
  def actual_hash_includes?(expected_key, expected_value); end
  def check_actual?(actual); end
  def check_expected_count?; end
  def comparing_hash_keys?(expected_item); end
  def comparing_hash_to_a_subset?(expected_item); end
  def convert_to_hash?(obj); end
  def count_enumerable(expected_item); end
  def count_inclusions; end
  def diff_would_wrongly_highlight_matched_item?; end
  def excluded_from_actual; end
  def format_failure_message(preposition); end
  def perform_match(&block); end
  def readable_list_of(items); end
end

class RSpec::Matchers::BuiltIn::Match < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def initialize(expected); end

  def description; end
  def diffable?; end
  def with_captures(*captures); end

  private

  def can_safely_call_match?(expected, actual); end
  def match(expected, actual); end
  def match_captures(expected, actual); end
end

class RSpec::Matchers::BuiltIn::NegativeOperatorMatcher < ::RSpec::Matchers::BuiltIn::OperatorMatcher
  def __delegate_operator(actual, operator, expected); end
end

module RSpec::Matchers::BuiltIn::NullCapture
  class << self
    def capture(_block); end
    def name; end
  end
end

class RSpec::Matchers::BuiltIn::OperatorMatcher
  def initialize(actual); end

  def !=(_expected); end
  def !~(_expected); end
  def <(expected); end
  def <=(expected); end
  def ==(expected); end
  def ===(expected); end
  def =~(expected); end
  def >(expected); end
  def >=(expected); end
  def description; end
  def fail_with_message(message); end

  private

  def eval_match(actual, operator, expected); end
  def has_non_generic_implementation_of?(op); end

  class << self
    def get(klass, operator); end
    def register(klass, operator, matcher); end
    def registry; end
    def unregister(klass, operator); end
    def use_custom_matcher_or_delegate(operator); end
  end
end

class RSpec::Matchers::BuiltIn::Output < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def initialize(expected); end

  def description; end
  def diffable?; end
  def does_not_match?(block); end
  def failure_message; end
  def failure_message_when_negated; end
  def matches?(block); end
  def supports_block_expectations?; end
  def to_stderr; end
  def to_stderr_from_any_process; end
  def to_stdout; end
  def to_stdout_from_any_process; end

  private

  def actual_output_description; end
  def captured?; end
  def negative_failure_reason; end
  def positive_failure_reason; end
end

class RSpec::Matchers::BuiltIn::PositiveOperatorMatcher < ::RSpec::Matchers::BuiltIn::OperatorMatcher
  def __delegate_operator(actual, operator, expected); end
end

class RSpec::Matchers::BuiltIn::RaiseError
  include ::RSpec::Matchers::Composable

  def initialize(expected_error_or_message, expected_message, &block); end

  def description; end
  def does_not_match?(given_proc); end
  def expects_call_stack_jump?; end
  def failure_message; end
  def failure_message_when_negated; end
  def matches?(given_proc, negative_expectation = T.unsafe(nil), &block); end
  def supports_block_expectations?; end
  def with_message(expected_message); end

  private

  def block_matches?; end
  def error_and_message_match?; end
  def eval_block; end
  def expectation_matched?; end
  def expected_error; end
  def expecting_specific_exception?; end
  def format_backtrace(backtrace); end
  def given_error; end
  def handle_warning(message); end
  def raise_message_already_set; end
  def ready_to_eval_block?; end
  def verify_message; end
  def warn_about_bare_error!; end
  def warn_about_bare_error?; end
  def warn_about_negative_false_positive!(expression); end
  def warn_about_nil_error!; end
  def warn_about_nil_error?; end
  def warn_for_negative_false_positives!; end
  def warning; end
end

RSpec::Matchers::BuiltIn::RaiseError::UndefinedValue = T.let(T.unsafe(nil), Object)

class RSpec::Matchers::BuiltIn::ReliableMatchData
  def initialize(match_data); end

  def captures; end
  def names; end

  protected

  def match_data; end
end

class RSpec::Matchers::BuiltIn::RespondTo < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def initialize(*names); end

  def and_any_keywords; end
  def and_keywords(*keywords); end
  def and_unlimited_arguments; end
  def argument; end
  def arguments; end
  def description; end
  def does_not_match?(actual); end
  def failure_message; end
  def failure_message_when_negated; end
  def ignoring_method_signature_failure!; end
  def matches?(actual); end
  def with(n); end
  def with_any_keywords; end
  def with_keywords(*keywords); end
  def with_unlimited_arguments; end

  private

  def find_failing_method_names(actual, filter_method); end
  def matches_arity?(actual, name); end
  def pp_names; end
  def with_arity; end
  def with_arity_string; end
  def with_keywords_string; end
end

class RSpec::Matchers::BuiltIn::RespondTo::ArityCheck
  def initialize(expected_arity, expected_keywords, arbitrary_keywords, unlimited_arguments); end

  def matches?(actual, name); end
  def method_signature_for(actual, name); end
  def verifier_for(actual, name); end
end

class RSpec::Matchers::BuiltIn::Satisfy < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def initialize(description = T.unsafe(nil), &block); end

  def description; end
  def failure_message; end
  def failure_message_when_negated; end
  def matches?(actual, &block); end

  private

  def block_representation; end
  def extract_block_snippet; end
end

class RSpec::Matchers::BuiltIn::SpecificValuesChange < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def initialize(change_details, from, to); end

  def description; end
  def failure_message; end
  def matches?(event_proc); end
  def supports_block_expectations?; end

  private

  def after_value_failure; end
  def before_value_failure; end
  def did_change_failure; end
  def did_not_change_failure; end
  def matches_after?; end
  def not_given_a_block_failure; end
  def perform_change(event_proc); end
end

RSpec::Matchers::BuiltIn::SpecificValuesChange::MATCH_ANYTHING = BasicObject
RSpec::Matchers::BuiltIn::StartAndEndWith = RSpec::Matchers::BuiltIn::StartOrEndWith

class RSpec::Matchers::BuiltIn::StartOrEndWith < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def initialize(*expected); end

  def description; end
  def failure_message; end

  private

  def match(_expected, actual); end
  def subsets_comparable?; end
end

class RSpec::Matchers::BuiltIn::StartWith < ::RSpec::Matchers::BuiltIn::StartOrEndWith
  private

  def element_matches?; end
  def subset_matches?; end
end

class RSpec::Matchers::BuiltIn::ThrowSymbol
  include ::RSpec::Matchers::Composable

  def initialize(expected_symbol = T.unsafe(nil), expected_arg = T.unsafe(nil)); end

  def description; end
  def does_not_match?(given_proc); end
  def expects_call_stack_jump?; end
  def failure_message; end
  def failure_message_when_negated; end
  def matches?(given_proc); end
  def supports_block_expectations?; end

  private

  def actual_result; end
  def caught; end
  def expected(symbol_desc = T.unsafe(nil)); end
  def throw_description(symbol, arg); end
end

class RSpec::Matchers::BuiltIn::YieldControl < ::RSpec::Matchers::BuiltIn::BaseMatcher
  include ::RSpec::Matchers::BuiltIn::CountExpectation

  def does_not_match?(block); end
  def failure_message; end
  def failure_message_when_negated; end
  def matches?(block); end
  def supports_block_expectations?; end

  private

  def failure_reason; end
end

class RSpec::Matchers::BuiltIn::YieldProbe
  def initialize(block, &callback); end

  def assert_used!; end
  def assert_valid_expect_block!; end
  def has_block?; end
  def num_yields; end
  def num_yields=(_arg0); end
  def probe; end
  def single_yield_args; end
  def to_proc; end
  def yielded_args; end
  def yielded_args=(_arg0); end
  def yielded_once?(matcher_name); end

  class << self
    def probe(block, &callback); end
  end
end

class RSpec::Matchers::BuiltIn::YieldSuccessiveArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def initialize(*args); end

  def description; end
  def does_not_match?(block); end
  def failure_message; end
  def failure_message_when_negated; end
  def matches?(block); end
  def supports_block_expectations?; end

  private

  def expected_arg_description; end
  def negative_failure_reason; end
  def positive_failure_reason; end
end

class RSpec::Matchers::BuiltIn::YieldWithArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def initialize(*args); end

  def description; end
  def does_not_match?(block); end
  def failure_message; end
  def failure_message_when_negated; end
  def matches?(block); end
  def supports_block_expectations?; end

  private

  def all_args_match?; end
  def args_currently_match?; end
  def expected_arg_description; end
  def negative_failure_reason; end
  def positive_failure_reason; end
end

class RSpec::Matchers::BuiltIn::YieldWithNoArgs < ::RSpec::Matchers::BuiltIn::BaseMatcher
  def does_not_match?(block); end
  def failure_message; end
  def failure_message_when_negated; end
  def matches?(block); end
  def supports_block_expectations?; end

  private

  def negative_failure_reason; end
  def positive_failure_reason; end
end

module RSpec::Matchers::Composable
  def &(matcher); end
  def ===(value); end
  def and(matcher); end
  def or(matcher); end
  def |(matcher); end

  private

  def description_of(object); end
  def should_enumerate?(item); end
  def surface_descriptions_in(item); end
  def unreadable_io?(object); end
  def values_match?(expected, actual); end
  def with_matchers_cloned(object); end

  class << self
    def should_enumerate?(item); end
    def surface_descriptions_in(item); end
    def unreadable_io?(object); end
  end
end

class RSpec::Matchers::Composable::DescribableItem < ::Struct
  def inspect; end
  def item; end
  def item=(_); end
  def pretty_print(pp); end

  class << self
    def [](*_arg0); end
    def inspect; end
    def members; end
    def new(*_arg0); end
  end
end

module RSpec::Matchers::DSL
  def alias_matcher(new_name, old_name, options = T.unsafe(nil), &description_override); end
  def define(name, &declarations); end
  def define_negated_matcher(negated_name, base_name, &description_override); end
  def matcher(name, &declarations); end

  private

  def warn_about_block_args(name, declarations); end
end

module RSpec::Matchers::DSL::DefaultImplementations
  include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages

  def description; end
  def diffable?; end
  def expects_call_stack_jump?; end
  def supports_block_expectations?; end

  private

  def chained_method_clause_sentences; end
end

module RSpec::Matchers::DSL::Macros
  def chain(method_name, *attr_names, &definition); end
  def description(&definition); end
  def diffable; end
  def failure_message(&definition); end
  def failure_message_when_negated(&definition); end
  def match(options = T.unsafe(nil), &match_block); end
  def match_unless_raises(expected_exception = T.unsafe(nil), &match_block); end
  def match_when_negated(options = T.unsafe(nil), &match_block); end
  def supports_block_expectations; end

  private

  def assign_attributes(attr_names); end
  def define_user_override(method_name, user_def, &our_def); end
end

module RSpec::Matchers::DSL::Macros::Deprecated
  def failure_message_for_should(&definition); end
  def failure_message_for_should_not(&definition); end
  def match_for_should(&definition); end
  def match_for_should_not(&definition); end
end

RSpec::Matchers::DSL::Macros::RAISE_NOTIFIER = T.let(T.unsafe(nil), Proc)

class RSpec::Matchers::DSL::Matcher
  include ::RSpec::Matchers::BuiltIn::BaseMatcher::DefaultFailureMessages
  include ::RSpec::Matchers::DSL::DefaultImplementations
  include ::RSpec::Matchers
  include ::RSpec::Matchers::Composable
  extend ::RSpec::Matchers::DSL::Macros
  extend ::RSpec::Matchers::DSL::Macros::Deprecated

  def initialize(name, declarations, matcher_execution_context, *expected, &block_arg); end

  def actual; end
  def block_arg; end
  def expected; end
  def expected_as_array; end
  def inspect; end
  def name; end
  def rescued_exception; end

  private

  def actual_arg_for(block); end
  def method_missing(method, *args, &block); end
  def respond_to_missing?(method, include_private = T.unsafe(nil)); end
end

RSpec::Matchers::DYNAMIC_MATCHER_REGEX = T.let(T.unsafe(nil), Regexp)

module RSpec::Matchers::EnglishPhrasing
  class << self
    def list(obj); end
    def split_words(sym); end
  end
end

class RSpec::Matchers::ExpectedsForMultipleDiffs
  def initialize(expected_list); end

  def message_with_diff(message, differ, actual); end

  private

  def diffs(differ, actual); end

  class << self
    def for_many_matchers(matchers); end
    def from(expected); end

    private

    def diff_label_for(matcher); end
    def truncated(description); end
  end
end

RSpec::Matchers::ExpectedsForMultipleDiffs::DEFAULT_DIFF_LABEL = T.let(T.unsafe(nil), String)
RSpec::Matchers::ExpectedsForMultipleDiffs::DESCRIPTION_MAX_LENGTH = T.let(T.unsafe(nil), Integer)
RSpec::Matchers::HAS_REGEX = T.let(T.unsafe(nil), Regexp)

class RSpec::Matchers::MatcherDelegator
  include ::RSpec::Matchers::Composable

  def initialize(base_matcher); end

  def base_matcher; end
  def method_missing(*args, &block); end

  private

  def initialize_copy(other); end
  def respond_to_missing?(name, include_all = T.unsafe(nil)); end
end

RSpec::SharedContext = RSpec::Core::SharedContext
