sorbet-struct-comparable 1.0.0 → 1.3.0

data/sorbet/rbi/gems/{rspec-mocks.rbi → rspec-mocks@3.10.2.rbi}

@@ -1,601 +1,490 @@
-# This file is autogenerated. Do not edit it by hand. Regenerate it with:
-#   srb rbi gems
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `rspec-mocks` gem.
+# Please instead update this file by running `bin/tapioca gem rspec-mocks`.
 
 # typed: true
-#
-# If you would like to make changes to this file, great! Please create the gem's shim here:
-#
-#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/rspec-mocks/all/rspec-mocks.rbi
-#
-# rspec-mocks-3.9.1
 
-module RSpec
-end
 module RSpec::Mocks
-  def self.allow_message(subject, message, opts = nil, &block); end
-  def self.configuration; end
-  def self.error_generator; end
-  def self.expect_message(subject, message, opts = nil, &block); end
-  def self.setup; end
-  def self.space; end
-  def self.teardown; end
-  def self.verify; end
-  def self.with_temporary_scope; end
+  class << self
+    def allow_message(subject, message, opts = T.unsafe(nil), &block); end
+    def configuration; end
+    def error_generator; end
+    def expect_message(subject, message, opts = T.unsafe(nil), &block); end
+    def setup; end
+    def space; end
+    def teardown; end
+    def verify; end
+    def with_temporary_scope; end
+  end
 end
-class RSpec::Mocks::InstanceMethodStasher
-  def handle_restoration_failures; end
-  def initialize(object, method); end
-  def method_defined_directly_on_klass?; end
-  def method_defined_on_klass?(klass = nil); end
-  def method_is_stashed?; end
-  def method_owned_by_klass?; end
-  def original_method; end
-  def restore; end
-  def stash; end
+
+class RSpec::Mocks::AllowanceTarget < ::RSpec::Mocks::TargetBase
+  def expression; end
+  def not_to(matcher, *_args); end
+  def to(matcher, &block); end
+  def to_not(matcher, *_args); end
 end
-class RSpec::Mocks::MethodDouble
-  def add_default_stub(*args, &implementation); end
-  def add_expectation(error_generator, expectation_ordering, expected_from, opts, &implementation); end
-  def add_simple_expectation(method_name, response, error_generator, backtrace_line); end
-  def add_simple_stub(method_name, response); end
-  def add_stub(error_generator, expectation_ordering, expected_from, opts = nil, &implementation); end
-  def build_expectation(error_generator, expectation_ordering); end
-  def clear; end
-  def configure_method; end
-  def define_proxy_method; end
-  def definition_target; end
-  def expectations; end
-  def initialize(object, method_name, proxy); end
-  def message_expectation_class; end
-  def method_name; end
-  def method_stasher; end
-  def new_rspec_prepended_module; end
-  def object; end
-  def object_singleton_class; end
-  def original_implementation_callable; end
-  def original_method; end
-  def proxy_method_invoked(_obj, *args, &block); end
-  def raise_method_not_stubbed_error; end
-  def remove_method_from_definition_target; end
-  def remove_stub; end
-  def remove_stub_if_present; end
-  def reset; end
-  def restore_original_method; end
-  def restore_original_visibility; end
-  def save_original_implementation_callable!; end
-  def setup_simple_method_double(method_name, response, collection, error_generator = nil, backtrace_line = nil); end
-  def show_frozen_warning; end
-  def stubs; end
-  def usable_rspec_prepended_module; end
-  def verify; end
-  def visibility; end
+
+class RSpec::Mocks::AndReturnImplementation
+  def initialize(values_to_return); end
+
+  def call(*_args_to_ignore, &_block); end
 end
-class RSpec::Mocks::MethodDouble::RSpecPrependedModule < Module
+
+class RSpec::Mocks::AndWrapOriginalImplementation
+  def initialize(method, block); end
+
+  def call(*args, &block); end
+  def initial_action=(_value); end
+  def inner_action; end
+  def inner_action=(_value); end
+  def present?; end
+  def terminal_action=(_value); end
+
+  private
+
+  def cannot_modify_further_error; end
 end
-module RSpec::Mocks::ArgumentMatchers
-  def a_kind_of(klass); end
-  def an_instance_of(klass); end
-  def any_args; end
-  def anything; end
-  def array_including(*args); end
-  def boolean; end
-  def duck_type(*args); end
-  def hash_excluding(*args); end
-  def hash_including(*args); end
-  def hash_not_including(*args); end
-  def instance_of(klass); end
-  def kind_of(klass); end
-  def no_args; end
-  def self.anythingize_lonely_keys(*args); end
+
+class RSpec::Mocks::AndWrapOriginalImplementation::CannotModifyFurtherError < ::StandardError; end
+
+class RSpec::Mocks::AndYieldImplementation
+  def initialize(args_to_yield, eval_context, error_generator); end
+
+  def call(*_args_to_ignore, &block); end
 end
-class RSpec::Mocks::ArgumentMatchers::SingletonMatcher
-  def self.inherited(subklass); end
-  def self.new(*arg0); end
+
+module RSpec::Mocks::AnyInstance
+  class << self
+    def error_generator; end
+  end
 end
-class RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher < RSpec::Mocks::ArgumentMatchers::SingletonMatcher
-  def description; end
+
+class RSpec::Mocks::AnyInstance::Chain
+  include ::RSpec::Mocks::AnyInstance::Chain::Customizations
+
+  def initialize(recorder, *args, &block); end
+
+  def constrained_to_any_of?(*constraints); end
+  def expectation_fulfilled!; end
+  def matches_args?(*args); end
+  def never; end
+  def playback!(instance); end
+  def with(*args, &block); end
+
+  private
+
+  def last_message; end
+  def messages; end
+  def negated?; end
+  def record(rspec_method_name, *args, &block); end
 end
-class RSpec::Mocks::ArgumentMatchers::AnyArgMatcher < RSpec::Mocks::ArgumentMatchers::SingletonMatcher
-  def ===(_other); end
-  def description; end
+
+module RSpec::Mocks::AnyInstance::Chain::Customizations
+  def and_call_original(*args, &block); end
+  def and_raise(*args, &block); end
+  def and_return(*args, &block); end
+  def and_throw(*args, &block); end
+  def and_wrap_original(*args, &block); end
+  def and_yield(*args, &block); end
+  def at_least(*args, &block); end
+  def at_most(*args, &block); end
+  def exactly(*args, &block); end
+  def never(*args, &block); end
+  def once(*args, &block); end
+  def thrice(*args, &block); end
+  def time(*args, &block); end
+  def times(*args, &block); end
+  def twice(*args, &block); end
+  def with(*args, &block); end
+
+  class << self
+    def record(method_name); end
+  end
 end
-class RSpec::Mocks::ArgumentMatchers::NoArgsMatcher < RSpec::Mocks::ArgumentMatchers::SingletonMatcher
-  def description; end
+
+class RSpec::Mocks::AnyInstance::ErrorGenerator < ::RSpec::Mocks::ErrorGenerator
+  def raise_does_not_implement_error(klass, method_name); end
+  def raise_message_already_received_by_other_instance_error(method_name, object_inspect, invoked_instance); end
+  def raise_not_supported_with_prepend_error(method_name, problem_mod); end
+  def raise_second_instance_received_message_error(unfulfilled_expectations); end
 end
-class RSpec::Mocks::ArgumentMatchers::BooleanMatcher < RSpec::Mocks::ArgumentMatchers::SingletonMatcher
-  def ===(value); end
-  def description; end
+
+class RSpec::Mocks::AnyInstance::ExpectChainChain < ::RSpec::Mocks::AnyInstance::StubChain
+  def initialize(*args); end
+
+  def expectation_fulfilled?; end
+  def playback!(instance); end
+
+  private
+
+  def create_message_expectation_on(instance); end
+  def invocation_order; end
 end
-class RSpec::Mocks::ArgumentMatchers::BaseHashMatcher
-  def ===(predicate, actual); end
-  def description(name); end
-  def formatted_expected_hash; end
-  def initialize(expected); end
+
+class RSpec::Mocks::AnyInstance::ExpectationChain < ::RSpec::Mocks::AnyInstance::Chain
+  def initialize(*args, &block); end
+
+  def expectation_fulfilled?; end
+
+  private
+
+  def verify_invocation_order(_rspec_method_name, *_args, &_block); end
 end
-class RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher < RSpec::Mocks::ArgumentMatchers::BaseHashMatcher
-  def ===(actual); end
-  def description; end
+
+class RSpec::Mocks::AnyInstance::FluentInterfaceProxy
+  def initialize(targets); end
+
+  def method_missing(*args, &block); end
+
+  private
+
+  def respond_to_missing?(method_name, include_private = T.unsafe(nil)); end
 end
-class RSpec::Mocks::ArgumentMatchers::HashExcludingMatcher < RSpec::Mocks::ArgumentMatchers::BaseHashMatcher
-  def ===(actual); end
-  def description; end
+
+class RSpec::Mocks::AnyInstance::MessageChains
+  def initialize; end
+
+  def [](method_name); end
+  def add(method_name, chain); end
+  def all_expectations_fulfilled?; end
+  def each_unfulfilled_expectation_matching(method_name, *args); end
+  def has_expectation?(method_name); end
+  def playback!(instance, method_name); end
+  def received_expected_message!(method_name); end
+  def remove_stub_chains_for!(method_name); end
+  def unfulfilled_expectations; end
+
+  private
+
+  def raise_if_second_instance_to_receive_message(instance); end
 end
-class RSpec::Mocks::ArgumentMatchers::ArrayIncludingMatcher
-  def ===(actual); end
-  def description; end
-  def formatted_expected_values; end
-  def initialize(expected); end
+
+class RSpec::Mocks::AnyInstance::PositiveExpectationChain < ::RSpec::Mocks::AnyInstance::ExpectationChain
+  private
+
+  def create_message_expectation_on(instance); end
+  def invocation_order; end
 end
-class RSpec::Mocks::ArgumentMatchers::DuckTypeMatcher
-  def ===(value); end
-  def description; end
-  def initialize(*methods_to_respond_to); end
+
+RSpec::Mocks::AnyInstance::PositiveExpectationChain::ExpectationInvocationOrder = T.let(T.unsafe(nil), Hash)
+
+class RSpec::Mocks::AnyInstance::Proxy
+  def initialize(recorder, target_proxies); end
+
+  def expect_chain(*chain, &block); end
+  def klass; end
+  def should_not_receive(method_name, &block); end
+  def should_receive(method_name, &block); end
+  def stub(method_name_or_method_map, &block); end
+  def stub_chain(*chain, &block); end
+  def unstub(method_name); end
+
+  private
+
+  def perform_proxying(method_name, args, block, &target_proxy_block); end
 end
-class RSpec::Mocks::ArgumentMatchers::InstanceOf
-  def ===(actual); end
-  def description; end
+
+class RSpec::Mocks::AnyInstance::Recorder
   def initialize(klass); end
+
+  def already_observing?(method_name); end
+  def build_alias_method_name(method_name); end
+  def expect_chain(*method_names_and_optional_return_values, &block); end
+  def instance_that_received(method_name); end
+  def klass; end
+  def message_chains; end
+  def notify_received_message(_object, message, args, _blk); end
+  def playback!(instance, method_name); end
+  def should_not_receive(method_name, &block); end
+  def should_receive(method_name, &block); end
+  def stop_all_observation!; end
+  def stub(method_name, &block); end
+  def stub_chain(*method_names_and_optional_return_values, &block); end
+  def stubs; end
+  def unstub(method_name); end
+  def verify; end
+
+  protected
+
+  def stop_observing!(method_name); end
+
+  private
+
+  def allow_no_prepended_module_definition_of(method_name); end
+  def ancestor_is_an_observer?(method_name); end
+  def backup_method!(method_name); end
+  def mark_invoked!(method_name); end
+  def normalize_chain(*args); end
+  def observe!(method_name); end
+  def public_protected_or_private_method_defined?(method_name); end
+  def received_expected_message!(method_name); end
+  def remove_dummy_method!(method_name); end
+  def restore_method!(method_name); end
+  def restore_original_method!(method_name); end
+  def super_class_observers_for(method_name); end
+  def super_class_observing?(method_name); end
 end
-class RSpec::Mocks::ArgumentMatchers::KindOf
-  def ===(actual); end
-  def description; end
-  def initialize(klass); end
+
+class RSpec::Mocks::AnyInstance::StubChain < ::RSpec::Mocks::AnyInstance::Chain
+  def expectation_fulfilled?; end
+
+  private
+
+  def create_message_expectation_on(instance); end
+  def invocation_order; end
+  def verify_invocation_order(rspec_method_name, *_args, &_block); end
 end
-class RSpec::Mocks::ObjectReference
-  def self.anonymous_module?(mod); end
-  def self.for(object_module_or_name, allow_direct_object_refs = nil); end
-  def self.name_of(mod); end
+
+RSpec::Mocks::AnyInstance::StubChain::EmptyInvocationOrder = T.let(T.unsafe(nil), Hash)
+RSpec::Mocks::AnyInstance::StubChain::InvocationOrder = T.let(T.unsafe(nil), Hash)
+
+class RSpec::Mocks::AnyInstance::StubChainChain < ::RSpec::Mocks::AnyInstance::StubChain
+  def initialize(*args); end
+
+  private
+
+  def create_message_expectation_on(instance); end
+  def invocation_order; end
 end
-class RSpec::Mocks::DirectObjectReference
-  def const_to_replace; end
-  def defined?; end
-  def description; end
-  def initialize(object); end
-  def target; end
-  def when_loaded; end
+
+class RSpec::Mocks::AnyInstanceAllowanceTarget < ::RSpec::Mocks::TargetBase
+  def expression; end
+  def not_to(matcher, *_args); end
+  def to(matcher, &block); end
+  def to_not(matcher, *_args); end
 end
-class RSpec::Mocks::NamedObjectReference
-  def const_to_replace; end
-  def defined?; end
+
+class RSpec::Mocks::AnyInstanceExpectationTarget < ::RSpec::Mocks::TargetBase
+  def expression; end
+  def not_to(matcher, &block); end
+  def to(matcher, &block); end
+  def to_not(matcher, &block); end
+end
+
+class RSpec::Mocks::ArgumentListMatcher
+  def initialize(*expected_args); end
+
+  def args_match?(*args); end
+  def expected_args; end
+  def resolve_expected_args_based_on(actual_args); end
+
+  private
+
+  def ensure_expected_args_valid!; end
+  def replace_any_args_with_splat_of_anything(before_count, actual_args_count); end
+end
+
+RSpec::Mocks::ArgumentListMatcher::MATCH_ALL = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentListMatcher)
+
+module RSpec::Mocks::ArgumentMatchers
+  def a_kind_of(klass); end
+  def an_instance_of(klass); end
+  def any_args; end
+  def anything; end
+  def array_including(*args); end
+  def boolean; end
+  def duck_type(*args); end
+  def hash_excluding(*args); end
+  def hash_including(*args); end
+  def hash_not_including(*args); end
+  def instance_of(klass); end
+  def kind_of(klass); end
+  def no_args; end
+
+  class << self
+    def anythingize_lonely_keys(*args); end
+  end
+end
+
+class RSpec::Mocks::ArgumentMatchers::AnyArgMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher
+  def ===(_other); end
   def description; end
-  def initialize(const_name); end
-  def object; end
-  def target; end
-  def when_loaded; end
 end
-module RSpec::Mocks::ExampleMethods
-  def allow(target); end
-  def allow_any_instance_of(klass); end
-  def allow_message_expectations_on_nil; end
-  def class_double(doubled_class, *args); end
-  def class_spy(*args); end
-  def double(*args); end
-  def expect_any_instance_of(klass); end
-  def have_received(method_name, &block); end
-  def hide_const(constant_name); end
-  def instance_double(doubled_class, *args); end
-  def instance_spy(*args); end
-  def object_double(object_or_name, *args); end
-  def object_spy(*args); end
-  def receive(method_name, &block); end
-  def receive_message_chain(*messages, &block); end
-  def receive_messages(message_return_value_hash); end
-  def self.declare_double(type, *args); end
-  def self.declare_verifying_double(type, ref, *args); end
-  def self.extended(object); end
-  def self.included(klass); end
-  def spy(*args); end
-  def stub_const(constant_name, value, options = nil); end
-  def without_partial_double_verification; end
-  include RSpec::Mocks::ArgumentMatchers
+
+RSpec::Mocks::ArgumentMatchers::AnyArgMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::AnyArgMatcher)
+
+class RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher
+  def description; end
 end
-module RSpec::Mocks::ExampleMethods::ExpectHost
-  def expect(target); end
+
+RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::AnyArgsMatcher)
+
+class RSpec::Mocks::ArgumentMatchers::ArrayIncludingMatcher
+  def initialize(expected); end
+
+  def ===(actual); end
+  def description; end
+
+  private
+
+  def formatted_expected_values; end
 end
-class RSpec::Mocks::Proxy
-  def add_message_expectation(method_name, opts = nil, &block); end
-  def add_simple_expectation(method_name, response, location); end
-  def add_simple_stub(method_name, response); end
-  def add_stub(method_name, opts = nil, &implementation); end
-  def as_null_object; end
-  def build_expectation(method_name); end
-  def check_for_unexpected_arguments(expectation); end
-  def ensure_implemented(*_args); end
-  def find_almost_matching_expectation(method_name, *args); end
-  def find_almost_matching_stub(method_name, *args); end
-  def find_best_matching_expectation_for(method_name); end
-  def find_matching_expectation(method_name, *args); end
-  def find_matching_method_stub(method_name, *args); end
-  def has_negative_expectation?(message); end
-  def initialize(object, order_group, options = nil); end
-  def message_received(message, *args, &block); end
-  def messages_arg_list; end
-  def method_double_for(message); end
-  def method_double_if_exists_for_message(message); end
-  def null_object?; end
-  def object; end
-  def original_method_handle_for(_message); end
-  def prepended_modules_of_singleton_class; end
-  def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end
-  def raise_unexpected_message_error(method_name, args); end
-  def received_message?(method_name, *args, &block); end
-  def record_message_received(message, *args, &block); end
-  def remove_stub(method_name); end
-  def remove_stub_if_present(method_name); end
-  def replay_received_message_on(expectation, &block); end
-  def reset; end
-  def self.prepended_modules_of(klass); end
-  def verify; end
-  def visibility_for(_method_name); end
+
+class RSpec::Mocks::ArgumentMatchers::BaseHashMatcher
+  def initialize(expected); end
+
+  def ===(predicate, actual); end
+  def description(name); end
+
+  private
+
+  def formatted_expected_hash; end
 end
-class RSpec::Mocks::Proxy::SpecificMessage < Struct
-  def ==(expectation); end
-  def args; end
-  def args=(_); end
-  def message; end
-  def message=(_); end
-  def object; end
-  def object=(_); end
-  def self.[](*arg0); end
-  def self.inspect; end
-  def self.members; end
-  def self.new(*arg0); end
+
+class RSpec::Mocks::ArgumentMatchers::BooleanMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher
+  def ===(value); end
+  def description; end
 end
-class RSpec::Mocks::TestDoubleProxy < RSpec::Mocks::Proxy
-  def reset; end
+
+RSpec::Mocks::ArgumentMatchers::BooleanMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::BooleanMatcher)
+
+class RSpec::Mocks::ArgumentMatchers::DuckTypeMatcher
+  def initialize(*methods_to_respond_to); end
+
+  def ===(value); end
+  def description; end
 end
-class RSpec::Mocks::PartialDoubleProxy < RSpec::Mocks::Proxy
-  def add_simple_expectation(method_name, response, location); end
-  def add_simple_stub(method_name, response); end
-  def any_instance_class_recorder_observing_method?(klass, method_name); end
-  def message_received(message, *args, &block); end
-  def original_method_handle_for(message); end
-  def reset; end
-  def visibility_for(method_name); end
+
+class RSpec::Mocks::ArgumentMatchers::HashExcludingMatcher < ::RSpec::Mocks::ArgumentMatchers::BaseHashMatcher
+  def ===(actual); end
+  def description; end
 end
-module RSpec::Mocks::PartialClassDoubleProxyMethods
-  def initialize(source_space, *args); end
-  def method_double_from_ancestor_for(message); end
-  def original_method_handle_for(message); end
-  def original_unbound_method_handle_from_ancestor_for(message); end
-  def superclass_proxy; end
+
+class RSpec::Mocks::ArgumentMatchers::HashIncludingMatcher < ::RSpec::Mocks::ArgumentMatchers::BaseHashMatcher
+  def ===(actual); end
+  def description; end
 end
-class RSpec::Mocks::PartialClassDoubleProxy < RSpec::Mocks::PartialDoubleProxy
-  include RSpec::Mocks::PartialClassDoubleProxyMethods
+
+class RSpec::Mocks::ArgumentMatchers::InstanceOf
+  def initialize(klass); end
+
+  def ===(actual); end
+  def description; end
 end
-class RSpec::Mocks::ProxyForNil < RSpec::Mocks::PartialDoubleProxy
-  def add_message_expectation(method_name, opts = nil, &block); end
-  def add_stub(method_name, opts = nil, &implementation); end
-  def disallow_expectations; end
-  def disallow_expectations=(arg0); end
-  def initialize(order_group); end
-  def raise_error(method_name); end
-  def set_expectation_behavior; end
-  def warn(method_name); end
-  def warn_about_expectations; end
-  def warn_about_expectations=(arg0); end
-  def warn_or_raise!(method_name); end
+
+class RSpec::Mocks::ArgumentMatchers::KindOf
+  def initialize(klass); end
+
+  def ===(actual); end
+  def description; end
 end
-module RSpec::Mocks::TestDouble
-  def ==(other); end
-  def __build_mock_proxy(order_group); end
-  def __build_mock_proxy_unless_expired(order_group); end
-  def __disallow_further_usage!; end
-  def __mock_proxy; end
-  def __raise_expired_error; end
-  def as_null_object; end
-  def assign_stubs(stubs); end
-  def freeze; end
-  def initialize(name = nil, stubs = nil); end
-  def initialize_copy(other); end
-  def inspect; end
-  def method_missing(message, *args, &block); end
-  def null_object?; end
-  def respond_to?(message, incl_private = nil); end
-  def to_s; end
+
+class RSpec::Mocks::ArgumentMatchers::NoArgsMatcher < ::RSpec::Mocks::ArgumentMatchers::SingletonMatcher
+  def description; end
 end
-class RSpec::Mocks::Double
-  include RSpec::Mocks::TestDouble
+
+RSpec::Mocks::ArgumentMatchers::NoArgsMatcher::INSTANCE = T.let(T.unsafe(nil), RSpec::Mocks::ArgumentMatchers::NoArgsMatcher)
+
+class RSpec::Mocks::ArgumentMatchers::SingletonMatcher
+  class << self
+    def inherited(subklass); end
+  end
 end
-module RSpec::Mocks::TestDoubleFormatter
-  def self.format(dbl, unwrap = nil); end
-  def self.name_desc(dbl); end
-  def self.type_desc(dbl); end
-  def self.verified_module_desc(dbl); end
+
+class RSpec::Mocks::CallbackInvocationStrategy
+  def call(doubled_module); end
 end
-class RSpec::Mocks::ArgumentListMatcher
-  def args_match?(*args); end
-  def ensure_expected_args_valid!; end
-  def expected_args; end
-  def initialize(*expected_args); end
-  def replace_any_args_with_splat_of_anything(before_count, actual_args_count); end
-  def resolve_expected_args_based_on(actual_args); end
+
+class RSpec::Mocks::CannotSupportArgMutationsError < ::StandardError; end
+
+class RSpec::Mocks::ClassNewMethodReference < ::RSpec::Mocks::ObjectMethodReference
+  def with_signature; end
+
+  class << self
+    def applies_to?(method_name); end
+  end
 end
-class RSpec::Mocks::SimpleMessageExpectation
-  def called_max_times?; end
-  def initialize(message, response, error_generator, backtrace_line = nil); end
-  def invoke(*_); end
-  def matches?(message, *_); end
-  def unadvise(_); end
-  def verify_messages_received; end
+
+class RSpec::Mocks::ClassVerifyingDouble < ::Module
+  include ::RSpec::Mocks::TestDouble
+  include ::RSpec::Mocks::VerifyingDouble
+  include ::RSpec::Mocks::ObjectVerifyingDoubleMethods
 end
-class RSpec::Mocks::MessageExpectation
-  def and_call_original; end
-  def and_raise(*args); end
-  def and_return(first_value, *values); end
-  def and_throw(*args); end
-  def and_wrap_original(&block); end
-  def and_yield(*args, &block); end
-  def at_least(n, &block); end
-  def at_most(n, &block); end
-  def exactly(n, &block); end
-  def inspect; end
-  def never; end
-  def once(&block); end
-  def ordered(&block); end
-  def thrice(&block); end
-  def time(&block); end
-  def times(&block); end
-  def to_s; end
-  def twice(&block); end
-  def with(*args, &block); end
-  include RSpec::Mocks::MessageExpectation::ImplementationDetails
-end
-module RSpec::Mocks::MessageExpectation::ImplementationDetails
-  def actual_received_count_matters?; end
-  def additional_expected_calls; end
-  def advise(*args); end
-  def and_yield_receiver_to_implementation; end
-  def argument_list_matcher=(arg0); end
-  def called_max_times?; end
-  def description_for(verb); end
-  def ensure_expected_ordering_received!; end
-  def error_generator; end
-  def error_generator=(arg0); end
-  def exception_source_id; end
-  def expectation_count_type; end
-  def expected_args; end
-  def expected_from=(arg0); end
-  def expected_messages_received?; end
-  def expected_received_count=(arg0); end
-  def generate_error; end
-  def has_been_invoked?; end
-  def ignoring_args?; end
-  def implementation; end
-  def implementation=(arg0); end
-  def increase_actual_received_count!; end
-  def initial_implementation_action=(action); end
-  def initialize(error_generator, expectation_ordering, expected_from, method_double, type = nil, opts = nil, &implementation_block); end
-  def inner_implementation_action=(action); end
-  def invoke(parent_stub, *args, &block); end
-  def invoke_incrementing_actual_calls_by(increment, allowed_to_fail, parent_stub, *args, &block); end
-  def invoke_without_incrementing_received_count(parent_stub, *args, &block); end
-  def matches?(message, *args); end
-  def matches_at_least_count?; end
-  def matches_at_most_count?; end
-  def matches_exact_count?; end
-  def matches_name_but_not_args(message, *args); end
-  def message; end
-  def negative?; end
-  def negative_expectation_for?(message); end
-  def ordered?; end
-  def orig_object; end
-  def raise_already_invoked_error_if_necessary(calling_customization); end
-  def raise_out_of_order_error; end
-  def raise_unexpected_message_args_error(args_for_multiple_calls); end
-  def safe_invoke(parent_stub, *args, &block); end
-  def set_expected_received_count(relativity, n); end
-  def similar_messages; end
-  def terminal_implementation_action=(action); end
-  def type; end
-  def unadvise(args); end
-  def verify_messages_received; end
-  def warn_about_stub_override; end
-  def wrap_original(method_name, &block); end
-  def yield_receiver_to_implementation_block?; end
-end
-class RSpec::Mocks::AndYieldImplementation
-  def call(*_args_to_ignore, &block); end
-  def initialize(args_to_yield, eval_context, error_generator); end
-end
-class RSpec::Mocks::AndReturnImplementation
-  def call(*_args_to_ignore, &_block); end
-  def initialize(values_to_return); end
-end
-class RSpec::Mocks::Implementation
-  def actions; end
-  def call(*args, &block); end
-  def initial_action; end
-  def initial_action=(arg0); end
-  def inner_action; end
-  def inner_action=(arg0); end
-  def present?; end
-  def terminal_action; end
-  def terminal_action=(arg0); end
-end
-class RSpec::Mocks::AndWrapOriginalImplementation
-  def call(*args, &block); end
-  def cannot_modify_further_error; end
-  def initial_action=(_value); end
-  def initialize(method, block); end
-  def inner_action; end
-  def inner_action=(_value); end
-  def present?; end
-  def terminal_action=(_value); end
-end
-class RSpec::Mocks::AndWrapOriginalImplementation::CannotModifyFurtherError < StandardError
-end
-class RSpec::Mocks::OrderGroup
-  def clear; end
-  def consume; end
-  def empty?; end
-  def expectation_for(message); end
-  def expectations_invoked_in_order?; end
-  def expected_invocations; end
-  def handle_order_constraint(expectation); end
-  def initialize; end
-  def invoked(message); end
-  def invoked_expectations; end
-  def ready_for?(expectation); end
-  def register(expectation); end
-  def remaining_expectations; end
-  def verify_invocation_order(expectation); end
-end
-class RSpec::Mocks::MockExpectationError < Exception
-end
-class RSpec::Mocks::ExpiredTestDoubleError < RSpec::Mocks::MockExpectationError
-end
-class RSpec::Mocks::OutsideOfExampleError < StandardError
-end
-class RSpec::Mocks::MockExpectationAlreadyInvokedError < Exception
-end
-class RSpec::Mocks::CannotSupportArgMutationsError < StandardError
-end
-class RSpec::Mocks::UnsupportedMatcherError < StandardError
-end
-class RSpec::Mocks::NegationUnsupportedError < StandardError
-end
-class RSpec::Mocks::VerifyingDoubleNotDefinedError < StandardError
-end
-class RSpec::Mocks::ErrorGenerator
-  def __raise(message, backtrace_line = nil, source_id = nil); end
-  def arg_list(args); end
-  def count_message(count, expectation_count_type = nil); end
-  def default_error_message(expectation, expected_args, actual_args); end
-  def describe_expectation(verb, message, expected_received_count, _actual_received_count, args); end
-  def diff_message(expected_args, actual_args); end
-  def differ; end
-  def error_message(expectation, args_for_multiple_calls); end
-  def expectation_on_nil_message(method_name); end
-  def expected_part_of_expectation_error(expected_received_count, expectation_count_type, argument_list_matcher); end
-  def format_args(args); end
-  def format_received_args(args_for_multiple_calls); end
-  def group_count(index, args); end
-  def grouped_args(args); end
-  def initialize(target = nil); end
-  def intro(unwrapped = nil); end
-  def list_of_exactly_one_string?(args); end
-  def method_call_args_description(args, generic_prefix = nil, matcher_prefix = nil); end
-  def notify(*args); end
-  def opts; end
-  def opts=(arg0); end
-  def prepend_to_backtrace(exception, line); end
-  def raise_already_invoked_error(message, calling_customization); end
-  def raise_cant_constrain_count_for_negated_have_received_error(count_constraint); end
-  def raise_double_negation_error(wrapped_expression); end
-  def raise_expectation_error(message, expected_received_count, argument_list_matcher, actual_received_count, expectation_count_type, args, backtrace_line = nil, source_id = nil); end
-  def raise_expectation_on_mocked_method(method); end
-  def raise_expectation_on_nil_error(method_name); end
-  def raise_expectation_on_unstubbed_method(method); end
-  def raise_expired_test_double_error; end
-  def raise_have_received_disallowed(type, reason); end
-  def raise_invalid_arguments_error(verifier); end
-  def raise_method_not_stubbed_error(method_name); end
-  def raise_missing_block_error(args_to_yield); end
-  def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end
-  def raise_non_public_error(method_name, visibility); end
-  def raise_only_valid_on_a_partial_double(method); end
-  def raise_out_of_order_error(message); end
-  def raise_similar_message_args_error(expectation, args_for_multiple_calls, backtrace_line = nil); end
-  def raise_unexpected_message_args_error(expectation, args_for_multiple_calls, source_id = nil); end
-  def raise_unexpected_message_error(message, args); end
-  def raise_unimplemented_error(doubled_module, method_name, object); end
-  def raise_verifying_double_not_defined_error(ref); end
-  def raise_wrong_arity_error(args_to_yield, signature); end
-  def received_part_of_expectation_error(actual_received_count, args); end
-  def times(count); end
-  def unexpected_arguments_message(expected_args_string, actual_args_string); end
-  def unpack_string_args(formatted_expected_args, actual_args); end
-end
-class RSpec::Mocks::RootSpace
-  def any_instance_proxy_for(*_args); end
-  def any_instance_recorder_for(*_args); end
-  def any_instance_recorders_from_ancestry_of(_object); end
-  def new_scope; end
-  def proxy_for(*_args); end
-  def raise_lifecycle_message; end
-  def register_constant_mutator(_mutator); end
-  def registered?(_object); end
-  def reset_all; end
-  def superclass_proxy_for(*_args); end
-  def verify_all; end
-end
-class RSpec::Mocks::Space
-  def any_instance_mutex; end
-  def any_instance_proxy_for(klass); end
-  def any_instance_recorder_for(klass, only_return_existing = nil); end
-  def any_instance_recorder_not_found_for(id, klass); end
-  def any_instance_recorders; end
-  def any_instance_recorders_from_ancestry_of(object); end
-  def class_proxy_with_callback_verification_strategy(object, strategy); end
-  def constant_mutator_for(name); end
-  def ensure_registered(object); end
-  def id_for(object); end
+
+class RSpec::Mocks::Configuration
   def initialize; end
-  def new_mutex; end
-  def new_scope; end
-  def proxies; end
-  def proxies_of(klass); end
-  def proxy_for(object); end
-  def proxy_mutex; end
-  def proxy_not_found_for(id, object); end
-  def register_constant_mutator(mutator); end
-  def registered?(object); end
-  def reset_all; end
-  def superclass_proxy_for(klass); end
-  def superclass_proxy_not_found_for(id, object); end
-  def verify_all; end
-end
-class RSpec::Mocks::NestedSpace < RSpec::Mocks::Space
-  def any_instance_recorder_not_found_for(id, klass); end
-  def constant_mutator_for(name); end
-  def initialize(parent); end
-  def proxies_of(klass); end
-  def proxy_not_found_for(id, object); end
-  def registered?(object); end
+
+  def add_stub_and_should_receive_to(*modules); end
+  def allow_message_expectations_on_nil; end
+  def allow_message_expectations_on_nil=(_arg0); end
+  def before_verifying_doubles(&block); end
+  def color?; end
+  def patch_marshal_to_support_partial_doubles=(val); end
+  def reset_syntaxes_to_default; end
+  def syntax; end
+  def syntax=(*values); end
+  def temporarily_suppress_partial_double_verification; end
+  def temporarily_suppress_partial_double_verification=(_arg0); end
+  def transfer_nested_constants=(_arg0); end
+  def transfer_nested_constants?; end
+  def verify_doubled_constant_names=(_arg0); end
+  def verify_doubled_constant_names?; end
+  def verify_partial_doubles=(val); end
+  def verify_partial_doubles?; end
+  def verifying_double_callbacks; end
+  def when_declaring_verifying_double(&block); end
+  def yield_receiver_to_any_instance_implementation_blocks=(_arg0); end
+  def yield_receiver_to_any_instance_implementation_blocks?; end
 end
+
 class RSpec::Mocks::Constant
-  def hidden=(arg0); end
-  def hidden?; end
+  extend ::RSpec::Support::RecursiveConstMethods
+
   def initialize(name); end
+
+  def hidden=(_arg0); end
+  def hidden?; end
   def inspect; end
   def mutated?; end
   def name; end
   def original_value; end
-  def original_value=(arg0); end
-  def previously_defined=(arg0); end
+  def original_value=(_arg0); end
+  def previously_defined=(_arg0); end
   def previously_defined?; end
-  def self.original(name); end
-  def self.unmutated(name); end
-  def stubbed=(arg0); end
+  def stubbed=(_arg0); end
   def stubbed?; end
   def to_s; end
-  def valid_name=(arg0); end
+  def valid_name=(_arg0); end
   def valid_name?; end
-  extend RSpec::Support::RecursiveConstMethods
+
+  class << self
+    def original(name); end
+    def unmutated(name); end
+  end
 end
+
 class RSpec::Mocks::ConstantMutator
-  def self.hide(constant_name); end
-  def self.mutate(mutator); end
-  def self.raise_on_invalid_const; end
-  def self.stub(constant_name, value, options = nil); end
-  extend RSpec::Support::RecursiveConstMethods
+  extend ::RSpec::Support::RecursiveConstMethods
+
+  class << self
+    def hide(constant_name); end
+    def mutate(mutator); end
+    def raise_on_invalid_const; end
+    def stub(constant_name, value, options = T.unsafe(nil)); end
+  end
 end
+
 class RSpec::Mocks::ConstantMutator::BaseMutator
+  include ::RSpec::Support::RecursiveConstMethods
+
+  def initialize(full_constant_name, mutated_value, transfer_nested_constants); end
+
   def full_constant_name; end
   def idempotently_reset; end
-  def initialize(full_constant_name, mutated_value, transfer_nested_constants); end
   def original_value; end
   def to_constant; end
-  include RSpec::Support::RecursiveConstMethods
 end
-class RSpec::Mocks::ConstantMutator::ConstantHider < RSpec::Mocks::ConstantMutator::BaseMutator
+
+class RSpec::Mocks::ConstantMutator::ConstantHider < ::RSpec::Mocks::ConstantMutator::BaseMutator
   def mutate; end
   def reset; end
   def to_constant; end
 end
-class RSpec::Mocks::ConstantMutator::DefinedConstantReplacer < RSpec::Mocks::ConstantMutator::BaseMutator
+
+class RSpec::Mocks::ConstantMutator::DefinedConstantReplacer < ::RSpec::Mocks::ConstantMutator::BaseMutator
   def initialize(*args); end
+
   def mutate; end
   def reset; end
   def should_transfer_nested_constants?; end
@@ -603,422 +492,266 @@ class RSpec::Mocks::ConstantMutator::DefinedConstantReplacer < RSpec::Mocks::Con
   def transfer_nested_constants; end
   def verify_constants_to_transfer!; end
 end
-class RSpec::Mocks::ConstantMutator::UndefinedConstantSetter < RSpec::Mocks::ConstantMutator::BaseMutator
+
+class RSpec::Mocks::ConstantMutator::UndefinedConstantSetter < ::RSpec::Mocks::ConstantMutator::BaseMutator
   def mutate; end
-  def name_for(parent, name); end
   def reset; end
   def to_constant; end
+
+  private
+
+  def name_for(parent, name); end
 end
-module RSpec::Mocks::TargetDelegationClassMethods
-  def delegate_not_to(matcher_method, options = nil); end
-  def delegate_to(matcher_method); end
-  def disallow_negation(method_name); end
-end
-module RSpec::Mocks::TargetDelegationInstanceMethods
-  def define_matcher(matcher, name, &block); end
-  def matcher_allowed?(matcher); end
-  def raise_negation_unsupported(method_name, matcher); end
-  def raise_unsupported_matcher(method_name, matcher); end
+
+RSpec::Mocks::DEFAULT_CALLBACK_INVOCATION_STRATEGY = T.let(T.unsafe(nil), RSpec::Mocks::CallbackInvocationStrategy)
+
+class RSpec::Mocks::DirectObjectReference
+  def initialize(object); end
+
+  def const_to_replace; end
+  def defined?; end
+  def description; end
   def target; end
+  def when_loaded; end
 end
-class RSpec::Mocks::TargetBase
-  def initialize(target); end
-  extend RSpec::Mocks::TargetDelegationClassMethods
-  include RSpec::Mocks::TargetDelegationInstanceMethods
+
+class RSpec::Mocks::Double
+  include ::RSpec::Mocks::TestDouble
 end
-module RSpec::Mocks::ExpectationTargetMethods
-  def expression; end
-  def not_to(matcher, &block); end
-  def to(matcher, &block); end
-  def to_not(matcher, &block); end
-  extend RSpec::Mocks::TargetDelegationClassMethods
-  include RSpec::Mocks::TargetDelegationInstanceMethods
+
+class RSpec::Mocks::ErrorGenerator
+  def initialize(target = T.unsafe(nil)); end
+
+  def default_error_message(expectation, expected_args, actual_args); end
+  def describe_expectation(verb, message, expected_received_count, _actual_received_count, args); end
+  def expectation_on_nil_message(method_name); end
+  def intro(unwrapped = T.unsafe(nil)); end
+  def method_call_args_description(args, generic_prefix = T.unsafe(nil), matcher_prefix = T.unsafe(nil)); end
+  def opts; end
+  def opts=(_arg0); end
+  def raise_already_invoked_error(message, calling_customization); end
+  def raise_cant_constrain_count_for_negated_have_received_error(count_constraint); end
+  def raise_double_negation_error(wrapped_expression); end
+  def raise_expectation_error(message, expected_received_count, argument_list_matcher, actual_received_count, expectation_count_type, args, backtrace_line = T.unsafe(nil), source_id = T.unsafe(nil)); end
+  def raise_expectation_on_mocked_method(method); end
+  def raise_expectation_on_nil_error(method_name); end
+  def raise_expectation_on_unstubbed_method(method); end
+  def raise_expired_test_double_error; end
+  def raise_have_received_disallowed(type, reason); end
+  def raise_invalid_arguments_error(verifier); end
+  def raise_method_not_stubbed_error(method_name); end
+  def raise_missing_block_error(args_to_yield); end
+  def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end
+  def raise_non_public_error(method_name, visibility); end
+  def raise_only_valid_on_a_partial_double(method); end
+  def raise_out_of_order_error(message); end
+  def raise_similar_message_args_error(expectation, args_for_multiple_calls, backtrace_line = T.unsafe(nil)); end
+  def raise_unexpected_message_args_error(expectation, args_for_multiple_calls, source_id = T.unsafe(nil)); end
+  def raise_unexpected_message_error(message, args); end
+  def raise_unimplemented_error(doubled_module, method_name, object); end
+  def raise_verifying_double_not_defined_error(ref); end
+  def raise_wrong_arity_error(args_to_yield, signature); end
+
+  private
+
+  def __raise(message, backtrace_line = T.unsafe(nil), source_id = T.unsafe(nil)); end
+  def arg_list(args); end
+  def count_message(count, expectation_count_type = T.unsafe(nil)); end
+  def diff_message(expected_args, actual_args); end
+  def differ; end
+  def error_message(expectation, args_for_multiple_calls); end
+  def expected_part_of_expectation_error(expected_received_count, expectation_count_type, argument_list_matcher); end
+  def format_args(args); end
+  def format_received_args(args_for_multiple_calls); end
+  def group_count(index, args); end
+  def grouped_args(args); end
+  def list_of_exactly_one_string?(args); end
+  def notify(*args); end
+  def prepend_to_backtrace(exception, line); end
+  def received_part_of_expectation_error(actual_received_count, args); end
+  def times(count); end
+  def unexpected_arguments_message(expected_args_string, actual_args_string); end
+  def unpack_string_args(formatted_expected_args, actual_args); end
+end
+
+module RSpec::Mocks::ExampleMethods
+  include ::RSpec::Mocks::ArgumentMatchers
+  include ::RSpec::Mocks::ExampleMethods::ExpectHost
+
+  def allow(target); end
+  def allow_any_instance_of(klass); end
+  def allow_message_expectations_on_nil; end
+  def class_double(doubled_class, *args); end
+  def class_spy(*args); end
+  def double(*args); end
+  def expect_any_instance_of(klass); end
+  def have_received(method_name, &block); end
+  def hide_const(constant_name); end
+  def instance_double(doubled_class, *args); end
+  def instance_spy(*args); end
+  def object_double(object_or_name, *args); end
+  def object_spy(*args); end
+  def receive(method_name, &block); end
+  def receive_message_chain(*messages, &block); end
+  def receive_messages(message_return_value_hash); end
+  def spy(*args); end
+  def stub_const(constant_name, value, options = T.unsafe(nil)); end
+  def without_partial_double_verification; end
+
+  class << self
+    def declare_double(type, *args); end
+    def declare_verifying_double(type, ref, *args); end
+    def extended(object); end
+    def included(klass); end
+  end
 end
-class RSpec::Mocks::ExpectationTarget < RSpec::Mocks::TargetBase
-  include RSpec::Mocks::ExpectationTargetMethods
+
+module RSpec::Mocks::ExampleMethods::ExpectHost
+  def expect(target); end
 end
-class RSpec::Mocks::AllowanceTarget < RSpec::Mocks::TargetBase
-  def expression; end
-  def not_to(matcher, *_args); end
-  def to(matcher, &block); end
-  def to_not(matcher, *_args); end
+
+class RSpec::Mocks::ExpectChain < ::RSpec::Mocks::MessageChain
+  private
+
+  def expectation(object, message, &return_block); end
+
+  class << self
+    def expect_chain_on(object, *chain, &blk); end
+  end
 end
-class RSpec::Mocks::AnyInstanceAllowanceTarget < RSpec::Mocks::TargetBase
-  def expression; end
-  def not_to(matcher, *_args); end
-  def to(matcher, &block); end
-  def to_not(matcher, *_args); end
+
+class RSpec::Mocks::ExpectationTarget < ::RSpec::Mocks::TargetBase
+  include ::RSpec::Mocks::ExpectationTargetMethods
 end
-class RSpec::Mocks::AnyInstanceExpectationTarget < RSpec::Mocks::TargetBase
+
+module RSpec::Mocks::ExpectationTargetMethods
+  include ::RSpec::Mocks::TargetDelegationInstanceMethods
+  extend ::RSpec::Mocks::TargetDelegationClassMethods
+
   def expression; end
   def not_to(matcher, &block); end
   def to(matcher, &block); end
   def to_not(matcher, &block); end
 end
-module RSpec::Mocks::Syntax
-  def self.default_should_syntax_host; end
-  def self.disable_expect(syntax_host = nil); end
-  def self.disable_should(syntax_host = nil); end
-  def self.enable_expect(syntax_host = nil); end
-  def self.enable_should(syntax_host = nil); end
-  def self.expect_enabled?(syntax_host = nil); end
-  def self.should_enabled?(syntax_host = nil); end
-  def self.warn_about_should!; end
-  def self.warn_unless_should_configured(method_name, replacement = nil); end
-end
-class BasicObject
-  def as_null_object; end
-  def null_object?; end
-  def received_message?(message, *args, &block); end
-  def should_not_receive(message, &block); end
-  def should_receive(message, opts = nil, &block); end
-  def stub(message_or_hash, opts = nil, &block); end
-  def stub_chain(*chain, &blk); end
-  def unstub(message); end
-end
-class Class < Module
-  def any_instance; end
-end
-class RSpec::Mocks::Configuration
-  def add_stub_and_should_receive_to(*modules); end
-  def allow_message_expectations_on_nil; end
-  def allow_message_expectations_on_nil=(arg0); end
-  def before_verifying_doubles(&block); end
-  def color?; end
-  def initialize; end
-  def patch_marshal_to_support_partial_doubles=(val); end
-  def reset_syntaxes_to_default; end
-  def syntax; end
-  def syntax=(*values); end
-  def temporarily_suppress_partial_double_verification; end
-  def temporarily_suppress_partial_double_verification=(arg0); end
-  def transfer_nested_constants=(arg0); end
-  def transfer_nested_constants?; end
-  def verify_doubled_constant_names=(arg0); end
-  def verify_doubled_constant_names?; end
-  def verify_partial_doubles=(val); end
-  def verify_partial_doubles?; end
-  def verifying_double_callbacks; end
-  def when_declaring_verifying_double(&block); end
-  def yield_receiver_to_any_instance_implementation_blocks=(arg0); end
-  def yield_receiver_to_any_instance_implementation_blocks?; end
-end
-class RSpec::Mocks::VerifyingMessageExpectation < RSpec::Mocks::MessageExpectation
-  def initialize(*args); end
-  def method_reference; end
-  def method_reference=(arg0); end
-  def validate_expected_arguments!; end
-  def with(*args, &block); end
-end
-class RSpec::Mocks::MethodReference
-  def defined?; end
-  def implemented?; end
-  def initialize(object_reference, method_name); end
-  def original_method; end
-  def self.for(object_reference, method_name); end
-  def self.instance_method_visibility_for(klass, method_name); end
-  def self.method_defined_at_any_visibility?(klass, method_name); end
-  def self.method_visibility_for(object, method_name); end
-  def unimplemented?; end
-  def visibility; end
-  def with_signature; end
+
+class RSpec::Mocks::ExpiredTestDoubleError < ::RSpec::Mocks::MockExpectationError; end
+RSpec::Mocks::IGNORED_BACKTRACE_LINE = T.let(T.unsafe(nil), String)
+
+class RSpec::Mocks::Implementation
+  def call(*args, &block); end
+  def initial_action; end
+  def initial_action=(_arg0); end
+  def inner_action; end
+  def inner_action=(_arg0); end
+  def present?; end
+  def terminal_action; end
+  def terminal_action=(_arg0); end
+
+  private
+
+  def actions; end
 end
-class RSpec::Mocks::InstanceMethodReference < RSpec::Mocks::MethodReference
+
+class RSpec::Mocks::InstanceMethodReference < ::RSpec::Mocks::MethodReference
+  private
+
   def find_method(mod); end
   def method_defined?(mod); end
   def method_implemented?(mod); end
   def visibility_from(mod); end
 end
-class RSpec::Mocks::ObjectMethodReference < RSpec::Mocks::MethodReference
-  def find_method(object); end
-  def method_defined?(object); end
-  def method_implemented?(object); end
-  def self.for(object_reference, method_name); end
-  def visibility_from(object); end
-end
-class RSpec::Mocks::ClassNewMethodReference < RSpec::Mocks::ObjectMethodReference
-  def self.applies_to?(method_name); end
-  def with_signature; end
-end
-class RSpec::Mocks::CallbackInvocationStrategy
-  def call(doubled_module); end
-end
-class RSpec::Mocks::NoCallbackInvocationStrategy
-  def call(_doubled_module); end
-end
-module RSpec::Mocks::VerifyingProxyMethods
-  def add_message_expectation(method_name, opts = nil, &block); end
-  def add_simple_stub(method_name, *args); end
-  def add_stub(method_name, opts = nil, &implementation); end
-  def ensure_implemented(method_name); end
-  def ensure_publicly_implemented(method_name, _object); end
-end
-class RSpec::Mocks::VerifyingProxy < RSpec::Mocks::TestDoubleProxy
-  def initialize(object, order_group, doubled_module, method_reference_class); end
-  def method_reference; end
-  def validate_arguments!(method_name, args); end
-  def visibility_for(method_name); end
-  include RSpec::Mocks::VerifyingProxyMethods
-end
-class RSpec::Mocks::VerifyingPartialDoubleProxy < RSpec::Mocks::PartialDoubleProxy
-  def ensure_implemented(_method_name); end
-  def initialize(object, expectation_ordering, optional_callback_invocation_strategy = nil); end
-  def method_reference; end
-  include RSpec::Mocks::VerifyingProxyMethods
-end
-class RSpec::Mocks::VerifyingPartialClassDoubleProxy < RSpec::Mocks::VerifyingPartialDoubleProxy
-  include RSpec::Mocks::PartialClassDoubleProxyMethods
-end
-class RSpec::Mocks::VerifyingMethodDouble < RSpec::Mocks::MethodDouble
-  def add_expectation(*args, &block); end
-  def add_stub(*args, &block); end
-  def initialize(object, method_name, proxy, method_reference); end
-  def message_expectation_class; end
-  def proxy_method_invoked(obj, *args, &block); end
-  def validate_arguments!(actual_args); end
-end
-class RSpec::Mocks::VerifyingExistingMethodDouble < RSpec::Mocks::VerifyingMethodDouble
-  def initialize(object, method_name, proxy); end
-  def self.for(object, method_name, proxy); end
-  def unimplemented?; end
-  def with_signature; end
-end
-class RSpec::Mocks::VerifyingExistingClassNewMethodDouble < RSpec::Mocks::VerifyingExistingMethodDouble
-  def with_signature; end
-end
-module RSpec::Mocks::VerifyingDouble
-  def __send__(name, *args, &block); end
-  def initialize(doubled_module, *args); end
-  def method_missing(message, *args, &block); end
-  def respond_to?(message, include_private = nil); end
-  def send(name, *args, &block); end
-end
-module RSpec::Mocks::VerifyingDouble::SilentIO
-  def self.method_missing(*arg0); end
-  def self.respond_to?(*arg0); end
+
+class RSpec::Mocks::InstanceMethodStasher
+  def initialize(object, method); end
+
+  def handle_restoration_failures; end
+  def method_is_stashed?; end
+  def original_method; end
+  def restore; end
+  def stash; end
+
+  private
+
+  def method_defined_directly_on_klass?; end
+  def method_defined_on_klass?(klass = T.unsafe(nil)); end
+  def method_owned_by_klass?; end
 end
+
 class RSpec::Mocks::InstanceVerifyingDouble
+  include ::RSpec::Mocks::TestDouble
+  include ::RSpec::Mocks::VerifyingDouble
+
   def __build_mock_proxy(order_group); end
-  include RSpec::Mocks::TestDouble
-  include RSpec::Mocks::VerifyingDouble
-end
-module RSpec::Mocks::ObjectVerifyingDoubleMethods
-  def __build_mock_proxy(order_group); end
-  def as_stubbed_const(options = nil); end
-  include RSpec::Mocks::TestDouble
-  include RSpec::Mocks::VerifyingDouble
-end
-class RSpec::Mocks::ObjectVerifyingDouble
-  include RSpec::Mocks::ObjectVerifyingDoubleMethods
-end
-class RSpec::Mocks::ClassVerifyingDouble < Module
-  include RSpec::Mocks::ObjectVerifyingDoubleMethods
 end
-module RSpec::Mocks::Version
-end
-module RSpec::Support
-  def self.require_rspec_mocks(f); end
+
+class RSpec::Mocks::MarshalExtension
+  class << self
+    def patch!; end
+    def unpatch!; end
+  end
 end
-module RSpec::Mocks::Matchers
+
+module RSpec::Mocks::Matchers; end
+
+class RSpec::Mocks::Matchers::ExpectationCustomization
+  def initialize(method_name, args, block); end
+
+  def block; end
+  def block=(_arg0); end
+  def playback_onto(expectation); end
 end
-module RSpec::Mocks::Matchers::Matcher
-end
-module RSpec::Mocks::AnyInstance
-  def self.error_generator; end
-end
-class RSpec::Mocks::AnyInstance::Chain
-  def constrained_to_any_of?(*constraints); end
-  def expectation_fulfilled!; end
-  def initialize(recorder, *args, &block); end
-  def last_message; end
-  def matches_args?(*args); end
-  def messages; end
-  def negated?; end
-  def never; end
-  def playback!(instance); end
-  def record(rspec_method_name, *args, &block); end
-  def with(*args, &block); end
-  include RSpec::Mocks::AnyInstance::Chain::Customizations
-end
-module RSpec::Mocks::AnyInstance::Chain::Customizations
-  def and_call_original(*args, &block); end
-  def and_raise(*args, &block); end
-  def and_return(*args, &block); end
-  def and_throw(*args, &block); end
-  def and_wrap_original(*args, &block); end
-  def and_yield(*args, &block); end
-  def at_least(*args, &block); end
-  def at_most(*args, &block); end
-  def exactly(*args, &block); end
-  def never(*args, &block); end
-  def once(*args, &block); end
-  def self.record(method_name); end
-  def thrice(*args, &block); end
-  def time(*args, &block); end
-  def times(*args, &block); end
-  def twice(*args, &block); end
-  def with(*args, &block); end
-end
-class RSpec::Mocks::AnyInstance::ErrorGenerator < RSpec::Mocks::ErrorGenerator
-  def raise_does_not_implement_error(klass, method_name); end
-  def raise_message_already_received_by_other_instance_error(method_name, object_inspect, invoked_instance); end
-  def raise_not_supported_with_prepend_error(method_name, problem_mod); end
-  def raise_second_instance_received_message_error(unfulfilled_expectations); end
-end
-class RSpec::Mocks::AnyInstance::StubChain < RSpec::Mocks::AnyInstance::Chain
-  def create_message_expectation_on(instance); end
-  def expectation_fulfilled?; end
-  def invocation_order; end
-  def verify_invocation_order(rspec_method_name, *_args, &_block); end
-end
-class RSpec::Mocks::AnyInstance::StubChainChain < RSpec::Mocks::AnyInstance::StubChain
-  def create_message_expectation_on(instance); end
-  def initialize(*args); end
-  def invocation_order; end
-end
-class RSpec::Mocks::AnyInstance::ExpectChainChain < RSpec::Mocks::AnyInstance::StubChain
-  def create_message_expectation_on(instance); end
-  def expectation_fulfilled?; end
-  def initialize(*args); end
-  def invocation_order; end
-  def playback!(instance); end
-end
-class RSpec::Mocks::AnyInstance::ExpectationChain < RSpec::Mocks::AnyInstance::Chain
-  def expectation_fulfilled?; end
-  def initialize(*args, &block); end
-  def verify_invocation_order(_rspec_method_name, *_args, &_block); end
-end
-class RSpec::Mocks::AnyInstance::PositiveExpectationChain < RSpec::Mocks::AnyInstance::ExpectationChain
-  def create_message_expectation_on(instance); end
-  def invocation_order; end
-end
-class RSpec::Mocks::AnyInstance::MessageChains
-  def [](method_name); end
-  def add(method_name, chain); end
-  def all_expectations_fulfilled?; end
-  def each_unfulfilled_expectation_matching(method_name, *args); end
-  def has_expectation?(method_name); end
-  def initialize; end
-  def playback!(instance, method_name); end
-  def raise_if_second_instance_to_receive_message(instance); end
-  def received_expected_message!(method_name); end
-  def remove_stub_chains_for!(method_name); end
-  def unfulfilled_expectations; end
-end
-class RSpec::Mocks::AnyInstance::Recorder
-  def allow_no_prepended_module_definition_of(method_name); end
-  def already_observing?(method_name); end
-  def ancestor_is_an_observer?(method_name); end
-  def backup_method!(method_name); end
-  def build_alias_method_name(method_name); end
-  def expect_chain(*method_names_and_optional_return_values, &block); end
-  def initialize(klass); end
-  def instance_that_received(method_name); end
-  def klass; end
-  def mark_invoked!(method_name); end
-  def message_chains; end
-  def normalize_chain(*args); end
-  def notify_received_message(_object, message, args, _blk); end
-  def observe!(method_name); end
-  def playback!(instance, method_name); end
-  def public_protected_or_private_method_defined?(method_name); end
-  def received_expected_message!(method_name); end
-  def remove_dummy_method!(method_name); end
-  def restore_method!(method_name); end
-  def restore_original_method!(method_name); end
-  def should_not_receive(method_name, &block); end
-  def should_receive(method_name, &block); end
-  def stop_all_observation!; end
-  def stop_observing!(method_name); end
-  def stub(method_name, &block); end
-  def stub_chain(*method_names_and_optional_return_values, &block); end
-  def stubs; end
-  def super_class_observers_for(method_name); end
-  def super_class_observing?(method_name); end
-  def unstub(method_name); end
-  def verify; end
-end
-class RSpec::Mocks::AnyInstance::Proxy
-  def expect_chain(*chain, &block); end
-  def initialize(recorder, target_proxies); end
-  def klass; end
-  def perform_proxying(method_name, args, block, &target_proxy_block); end
-  def should_not_receive(method_name, &block); end
-  def should_receive(method_name, &block); end
-  def stub(method_name_or_method_map, &block); end
-  def stub_chain(*chain, &block); end
-  def unstub(method_name); end
-end
-class RSpec::Mocks::AnyInstance::FluentInterfaceProxy
-  def initialize(targets); end
-  def method_missing(*args, &block); end
-  def respond_to_missing?(method_name, include_private = nil); end
-end
-class RSpec::Mocks::MessageChain
-  def block; end
-  def chain; end
-  def chain_on(object, *chain, &block); end
-  def find_matching_expectation; end
-  def find_matching_stub; end
-  def format_chain(*chain, &blk); end
-  def initialize(object, *chain, &blk); end
-  def object; end
-  def setup_chain; end
-end
-class RSpec::Mocks::ExpectChain < RSpec::Mocks::MessageChain
-  def expectation(object, message, &return_block); end
-  def self.expect_chain_on(object, *chain, &blk); end
-end
-class RSpec::Mocks::StubChain < RSpec::Mocks::MessageChain
-  def expectation(object, message, &return_block); end
-  def self.stub_chain_on(object, *chain, &blk); end
-end
-class RSpec::Mocks::MarshalExtension
-  def self.patch!; end
-  def self.unpatch!; end
-end
-class RSpec::Mocks::Matchers::HaveReceived
-  def apply_constraints_to(expectation); end
-  def at_least(*args); end
-  def at_most(*args); end
-  def capture_failure_message; end
-  def count_constraint; end
-  def description; end
-  def disallow(type, reason = nil); end
-  def does_not_match?(subject); end
-  def ensure_count_unconstrained; end
-  def exactly(*args); end
-  def expect; end
-  def expected_messages_received_in_order?; end
-  def failure_message; end
-  def failure_message_when_negated; end
-  def initialize(method_name, &block); end
-  def matches?(subject, &block); end
-  def mock_proxy; end
-  def name; end
-  def notify_failure_message; end
-  def once(*args); end
-  def ordered(*args); end
-  def setup_allowance(_subject, &_block); end
-  def setup_any_instance_allowance(_subject, &_block); end
-  def setup_any_instance_expectation(_subject, &_block); end
-  def setup_any_instance_negative_expectation(_subject, &_block); end
-  def setup_expectation(subject, &block); end
-  def setup_negative_expectation(subject, &block); end
-  def thrice(*args); end
-  def time(*args); end
-  def times(*args); end
-  def twice(*args); end
-  def with(*args); end
-  include RSpec::Mocks::Matchers::Matcher
-end
-class RSpec::Mocks::Matchers::ExpectationCustomization
-  def block; end
-  def block=(arg0); end
-  def initialize(method_name, args, block); end
-  def playback_onto(expectation); end
+
+class RSpec::Mocks::Matchers::HaveReceived
+  include ::RSpec::Mocks::Matchers::Matcher
+
+  def initialize(method_name, &block); end
+
+  def at_least(*args); end
+  def at_most(*args); end
+  def description; end
+  def does_not_match?(subject); end
+  def exactly(*args); end
+  def failure_message; end
+  def failure_message_when_negated; end
+  def matches?(subject, &block); end
+  def name; end
+  def once(*args); end
+  def ordered(*args); end
+  def setup_allowance(_subject, &_block); end
+  def setup_any_instance_allowance(_subject, &_block); end
+  def setup_any_instance_expectation(_subject, &_block); end
+  def setup_any_instance_negative_expectation(_subject, &_block); end
+  def setup_expectation(subject, &block); end
+  def setup_negative_expectation(subject, &block); end
+  def thrice(*args); end
+  def time(*args); end
+  def times(*args); end
+  def twice(*args); end
+  def with(*args); end
+
+  private
+
+  def apply_constraints_to(expectation); end
+  def capture_failure_message; end
+  def count_constraint; end
+  def disallow(type, reason = T.unsafe(nil)); end
+  def ensure_count_unconstrained; end
+  def expect; end
+  def expected_messages_received_in_order?; end
+  def mock_proxy; end
+  def notify_failure_message; end
 end
+
+RSpec::Mocks::Matchers::HaveReceived::ARGS_CONSTRAINTS = T.let(T.unsafe(nil), Array)
+RSpec::Mocks::Matchers::HaveReceived::CONSTRAINTS = T.let(T.unsafe(nil), Array)
+RSpec::Mocks::Matchers::HaveReceived::COUNT_CONSTRAINTS = T.let(T.unsafe(nil), Array)
+module RSpec::Mocks::Matchers::Matcher; end
+
 class RSpec::Mocks::Matchers::Receive
+  include ::RSpec::Mocks::Matchers::Matcher
+
+  def initialize(message, block); end
+
   def and_call_original(*args, &block); end
   def and_raise(*args, &block); end
   def and_return(*args, &block); end
@@ -1027,13 +760,10 @@ class RSpec::Mocks::Matchers::Receive
   def and_yield(*args, &block); end
   def at_least(*args, &block); end
   def at_most(*args, &block); end
-  def describable; end
   def description; end
   def does_not_match?(subject, &block); end
   def exactly(*args, &block); end
-  def initialize(message, block); end
   def matches?(subject, &block); end
-  def move_block_to_last_customization(block); end
   def name; end
   def never(*args, &block); end
   def once(*args, &block); end
@@ -1041,25 +771,36 @@ class RSpec::Mocks::Matchers::Receive
   def setup_allowance(subject, &block); end
   def setup_any_instance_allowance(subject, &block); end
   def setup_any_instance_expectation(subject, &block); end
-  def setup_any_instance_method_substitute(subject, method, block); end
   def setup_any_instance_negative_expectation(subject, &block); end
   def setup_expectation(subject, &block); end
-  def setup_method_substitute(host, method, block, *args); end
-  def setup_mock_proxy_method_substitute(subject, method, block); end
   def setup_negative_expectation(subject, &block); end
   def thrice(*args, &block); end
   def time(*args, &block); end
   def times(*args, &block); end
   def twice(*args, &block); end
-  def warn_if_any_instance(expression, subject); end
   def with(*args, &block); end
-  include RSpec::Mocks::Matchers::Matcher
+
+  private
+
+  def describable; end
+  def move_block_to_last_customization(block); end
+  def setup_any_instance_method_substitute(subject, method, block); end
+  def setup_method_substitute(host, method, block, *args); end
+  def setup_mock_proxy_method_substitute(subject, method, block); end
+  def warn_if_any_instance(expression, subject); end
 end
+
 class RSpec::Mocks::Matchers::Receive::DefaultDescribable
-  def description_for(verb); end
   def initialize(message); end
+
+  def description_for(verb); end
 end
+
 class RSpec::Mocks::Matchers::ReceiveMessageChain
+  include ::RSpec::Mocks::Matchers::Matcher
+
+  def initialize(chain, &block); end
+
   def and_call_original(*args, &block); end
   def and_raise(*args, &block); end
   def and_return(*args, &block); end
@@ -1067,33 +808,655 @@ class RSpec::Mocks::Matchers::ReceiveMessageChain
   def and_yield(*args, &block); end
   def description; end
   def does_not_match?(*_args); end
-  def formatted_chain; end
-  def initialize(chain, &block); end
   def matches?(subject, &block); end
   def name; end
-  def replay_customizations(chain); end
   def setup_allowance(subject, &block); end
   def setup_any_instance_allowance(subject, &block); end
   def setup_any_instance_expectation(subject, &block); end
   def setup_expectation(subject, &block); end
   def setup_negative_expectation(*_args); end
   def with(*args, &block); end
-  include RSpec::Mocks::Matchers::Matcher
+
+  private
+
+  def formatted_chain; end
+  def replay_customizations(chain); end
 end
+
 class RSpec::Mocks::Matchers::ReceiveMessages
-  def any_instance_of(subject); end
+  include ::RSpec::Mocks::Matchers::Matcher
+
+  def initialize(message_return_value_hash); end
+
   def description; end
   def does_not_match?(_subject); end
-  def each_message_on(host); end
-  def initialize(message_return_value_hash); end
   def matches?(subject); end
   def name; end
-  def proxy_on(subject); end
   def setup_allowance(subject); end
   def setup_any_instance_allowance(subject); end
   def setup_any_instance_expectation(subject); end
   def setup_expectation(subject); end
   def setup_negative_expectation(_subject); end
   def warn_about_block; end
-  include RSpec::Mocks::Matchers::Matcher
+
+  private
+
+  def any_instance_of(subject); end
+  def each_message_on(host); end
+  def proxy_on(subject); end
+end
+
+class RSpec::Mocks::MessageChain
+  def initialize(object, *chain, &blk); end
+
+  def block; end
+  def chain; end
+  def object; end
+  def setup_chain; end
+
+  private
+
+  def chain_on(object, *chain, &block); end
+  def find_matching_expectation; end
+  def find_matching_stub; end
+  def format_chain(*chain, &blk); end
 end
+
+class RSpec::Mocks::MessageExpectation
+  include ::RSpec::Mocks::MessageExpectation::ImplementationDetails
+
+  def and_call_original; end
+  def and_raise(*args); end
+  def and_return(first_value, *values); end
+  def and_throw(*args); end
+  def and_wrap_original(&block); end
+  def and_yield(*args, &block); end
+  def at_least(n, &block); end
+  def at_most(n, &block); end
+  def exactly(n, &block); end
+  def inspect; end
+  def never; end
+  def once(&block); end
+  def ordered(&block); end
+  def thrice(&block); end
+  def time(&block); end
+  def times(&block); end
+  def to_s; end
+  def twice(&block); end
+  def with(*args, &block); end
+end
+
+module RSpec::Mocks::MessageExpectation::ImplementationDetails
+  def initialize(error_generator, expectation_ordering, expected_from, method_double, type = T.unsafe(nil), opts = T.unsafe(nil), &implementation_block); end
+
+  def actual_received_count_matters?; end
+  def additional_expected_calls; end
+  def advise(*args); end
+  def and_yield_receiver_to_implementation; end
+  def argument_list_matcher=(_arg0); end
+  def called_max_times?; end
+  def description_for(verb); end
+  def ensure_expected_ordering_received!; end
+  def error_generator; end
+  def expectation_count_type; end
+  def expected_args; end
+  def expected_messages_received?; end
+  def generate_error; end
+  def ignoring_args?; end
+  def implementation; end
+  def increase_actual_received_count!; end
+  def invoke(parent_stub, *args, &block); end
+  def invoke_without_incrementing_received_count(parent_stub, *args, &block); end
+  def matches?(message, *args); end
+  def matches_at_least_count?; end
+  def matches_at_most_count?; end
+  def matches_exact_count?; end
+  def matches_name_but_not_args(message, *args); end
+  def message; end
+  def negative?; end
+  def negative_expectation_for?(message); end
+  def ordered?; end
+  def orig_object; end
+  def raise_out_of_order_error; end
+  def raise_unexpected_message_args_error(args_for_multiple_calls); end
+  def safe_invoke(parent_stub, *args, &block); end
+  def similar_messages; end
+  def type; end
+  def unadvise(args); end
+  def verify_messages_received; end
+  def yield_receiver_to_implementation_block?; end
+
+  protected
+
+  def error_generator=(_arg0); end
+  def expected_from=(_arg0); end
+  def expected_received_count=(_arg0); end
+  def implementation=(_arg0); end
+
+  private
+
+  def exception_source_id; end
+  def has_been_invoked?; end
+  def initial_implementation_action=(action); end
+  def inner_implementation_action=(action); end
+  def invoke_incrementing_actual_calls_by(increment, allowed_to_fail, parent_stub, *args, &block); end
+  def raise_already_invoked_error_if_necessary(calling_customization); end
+  def set_expected_received_count(relativity, n); end
+  def terminal_implementation_action=(action); end
+  def warn_about_stub_override; end
+  def wrap_original(method_name, &block); end
+end
+
+class RSpec::Mocks::MethodDouble
+  def initialize(object, method_name, proxy); end
+
+  def add_default_stub(*args, &implementation); end
+  def add_expectation(error_generator, expectation_ordering, expected_from, opts, &implementation); end
+  def add_simple_expectation(method_name, response, error_generator, backtrace_line); end
+  def add_simple_stub(method_name, response); end
+  def add_stub(error_generator, expectation_ordering, expected_from, opts = T.unsafe(nil), &implementation); end
+  def build_expectation(error_generator, expectation_ordering); end
+  def clear; end
+  def configure_method; end
+  def define_proxy_method; end
+  def expectations; end
+  def message_expectation_class; end
+  def method_name; end
+  def method_stasher; end
+  def object; end
+  def object_singleton_class; end
+  def original_implementation_callable; end
+  def original_method; end
+  def proxy_method_invoked(_obj, *args, &block); end
+  def raise_method_not_stubbed_error; end
+  def remove_stub; end
+  def remove_stub_if_present; end
+  def reset; end
+  def restore_original_method; end
+  def restore_original_visibility; end
+  def save_original_implementation_callable!; end
+  def setup_simple_method_double(method_name, response, collection, error_generator = T.unsafe(nil), backtrace_line = T.unsafe(nil)); end
+  def show_frozen_warning; end
+  def stubs; end
+  def verify; end
+  def visibility; end
+
+  private
+
+  def definition_target; end
+  def new_rspec_prepended_module; end
+  def remove_method_from_definition_target; end
+  def usable_rspec_prepended_module; end
+end
+
+class RSpec::Mocks::MethodDouble::RSpecPrependedModule < ::Module; end
+
+class RSpec::Mocks::MethodReference
+  def initialize(object_reference, method_name); end
+
+  def defined?; end
+  def implemented?; end
+  def unimplemented?; end
+  def visibility; end
+  def with_signature; end
+
+  private
+
+  def original_method; end
+
+  class << self
+    def for(object_reference, method_name); end
+    def instance_method_visibility_for(klass, method_name); end
+    def method_defined_at_any_visibility?(klass, method_name); end
+    def method_visibility_for(object, method_name); end
+  end
+end
+
+class RSpec::Mocks::MockExpectationAlreadyInvokedError < ::Exception; end
+class RSpec::Mocks::MockExpectationError < ::Exception; end
+
+class RSpec::Mocks::NamedObjectReference
+  def initialize(const_name); end
+
+  def const_to_replace; end
+  def defined?; end
+  def description; end
+  def target; end
+  def when_loaded; end
+
+  private
+
+  def object; end
+end
+
+class RSpec::Mocks::NegationUnsupportedError < ::StandardError; end
+
+class RSpec::Mocks::NestedSpace < ::RSpec::Mocks::Space
+  def initialize(parent); end
+
+  def constant_mutator_for(name); end
+  def proxies_of(klass); end
+  def registered?(object); end
+
+  private
+
+  def any_instance_recorder_not_found_for(id, klass); end
+  def proxy_not_found_for(id, object); end
+end
+
+class RSpec::Mocks::NoCallbackInvocationStrategy
+  def call(_doubled_module); end
+end
+
+class RSpec::Mocks::ObjectMethodReference < ::RSpec::Mocks::MethodReference
+  private
+
+  def find_method(object); end
+  def method_defined?(object); end
+  def method_implemented?(object); end
+  def visibility_from(object); end
+
+  class << self
+    def for(object_reference, method_name); end
+  end
+end
+
+class RSpec::Mocks::ObjectReference
+  class << self
+    def for(object_module_or_name, allow_direct_object_refs = T.unsafe(nil)); end
+
+    private
+
+    def anonymous_module?(mod); end
+    def name_of(mod); end
+  end
+end
+
+RSpec::Mocks::ObjectReference::MODULE_NAME_METHOD = T.let(T.unsafe(nil), UnboundMethod)
+
+class RSpec::Mocks::ObjectVerifyingDouble
+  include ::RSpec::Mocks::TestDouble
+  include ::RSpec::Mocks::VerifyingDouble
+  include ::RSpec::Mocks::ObjectVerifyingDoubleMethods
+end
+
+module RSpec::Mocks::ObjectVerifyingDoubleMethods
+  include ::RSpec::Mocks::TestDouble
+  include ::RSpec::Mocks::VerifyingDouble
+
+  def as_stubbed_const(options = T.unsafe(nil)); end
+
+  private
+
+  def __build_mock_proxy(order_group); end
+end
+
+class RSpec::Mocks::OrderGroup
+  def initialize; end
+
+  def clear; end
+  def consume; end
+  def empty?; end
+  def handle_order_constraint(expectation); end
+  def invoked(message); end
+  def ready_for?(expectation); end
+  def register(expectation); end
+  def verify_invocation_order(expectation); end
+
+  private
+
+  def expectation_for(message); end
+  def expectations_invoked_in_order?; end
+  def expected_invocations; end
+  def invoked_expectations; end
+  def remaining_expectations; end
+end
+
+class RSpec::Mocks::OutsideOfExampleError < ::StandardError; end
+
+class RSpec::Mocks::PartialClassDoubleProxy < ::RSpec::Mocks::PartialDoubleProxy
+  include ::RSpec::Mocks::PartialClassDoubleProxyMethods
+end
+
+module RSpec::Mocks::PartialClassDoubleProxyMethods
+  def initialize(source_space, *args); end
+
+  def original_method_handle_for(message); end
+
+  protected
+
+  def method_double_from_ancestor_for(message); end
+  def original_unbound_method_handle_from_ancestor_for(message); end
+  def superclass_proxy; end
+end
+
+class RSpec::Mocks::PartialDoubleProxy < ::RSpec::Mocks::Proxy
+  def add_simple_expectation(method_name, response, location); end
+  def add_simple_stub(method_name, response); end
+  def message_received(message, *args, &block); end
+  def original_method_handle_for(message); end
+  def reset; end
+  def visibility_for(method_name); end
+
+  private
+
+  def any_instance_class_recorder_observing_method?(klass, method_name); end
+end
+
+class RSpec::Mocks::Proxy
+  def initialize(object, order_group, options = T.unsafe(nil)); end
+
+  def add_message_expectation(method_name, opts = T.unsafe(nil), &block); end
+  def add_simple_expectation(method_name, response, location); end
+  def add_simple_stub(method_name, response); end
+  def add_stub(method_name, opts = T.unsafe(nil), &implementation); end
+  def as_null_object; end
+  def build_expectation(method_name); end
+  def check_for_unexpected_arguments(expectation); end
+  def ensure_can_be_proxied!(object); end
+  def ensure_implemented(*_args); end
+  def has_negative_expectation?(message); end
+  def message_received(message, *args, &block); end
+  def messages_arg_list; end
+  def method_double_if_exists_for_message(message); end
+  def null_object?; end
+  def object; end
+  def original_method_handle_for(_message); end
+  def prepended_modules_of_singleton_class; end
+  def raise_missing_default_stub_error(expectation, args_for_multiple_calls); end
+  def raise_unexpected_message_error(method_name, args); end
+  def received_message?(method_name, *args, &block); end
+  def record_message_received(message, *args, &block); end
+  def remove_stub(method_name); end
+  def remove_stub_if_present(method_name); end
+  def replay_received_message_on(expectation, &block); end
+  def reset; end
+  def verify; end
+  def visibility_for(_method_name); end
+
+  private
+
+  def find_almost_matching_expectation(method_name, *args); end
+  def find_almost_matching_stub(method_name, *args); end
+  def find_best_matching_expectation_for(method_name); end
+  def find_matching_expectation(method_name, *args); end
+  def find_matching_method_stub(method_name, *args); end
+  def method_double_for(message); end
+
+  class << self
+    def prepended_modules_of(klass); end
+  end
+end
+
+RSpec::Mocks::Proxy::DEFAULT_MESSAGE_EXPECTATION_OPTS = T.let(T.unsafe(nil), Hash)
+
+class RSpec::Mocks::Proxy::SpecificMessage < ::Struct
+  def ==(expectation); end
+  def args; end
+  def args=(_); end
+  def message; end
+  def message=(_); end
+  def object; end
+  def object=(_); end
+
+  class << self
+    def [](*_arg0); end
+    def inspect; end
+    def members; end
+    def new(*_arg0); end
+  end
+end
+
+class RSpec::Mocks::ProxyForNil < ::RSpec::Mocks::PartialDoubleProxy
+  def initialize(order_group); end
+
+  def add_message_expectation(method_name, opts = T.unsafe(nil), &block); end
+  def add_stub(method_name, opts = T.unsafe(nil), &implementation); end
+  def disallow_expectations; end
+  def disallow_expectations=(_arg0); end
+  def warn_about_expectations; end
+  def warn_about_expectations=(_arg0); end
+
+  private
+
+  def raise_error(method_name); end
+  def set_expectation_behavior; end
+  def warn(method_name); end
+  def warn_or_raise!(method_name); end
+end
+
+class RSpec::Mocks::RootSpace
+  def any_instance_proxy_for(*_args); end
+  def any_instance_recorder_for(*_args); end
+  def any_instance_recorders_from_ancestry_of(_object); end
+  def new_scope; end
+  def proxy_for(*_args); end
+  def register_constant_mutator(_mutator); end
+  def registered?(_object); end
+  def reset_all; end
+  def superclass_proxy_for(*_args); end
+  def verify_all; end
+
+  private
+
+  def raise_lifecycle_message; end
+end
+
+class RSpec::Mocks::SimpleMessageExpectation
+  def initialize(message, response, error_generator, backtrace_line = T.unsafe(nil)); end
+
+  def called_max_times?; end
+  def invoke(*_); end
+  def matches?(message, *_); end
+  def unadvise(_); end
+  def verify_messages_received; end
+end
+
+class RSpec::Mocks::Space
+  def initialize; end
+
+  def any_instance_mutex; end
+  def any_instance_proxy_for(klass); end
+  def any_instance_recorder_for(klass, only_return_existing = T.unsafe(nil)); end
+  def any_instance_recorders; end
+  def any_instance_recorders_from_ancestry_of(object); end
+  def constant_mutator_for(name); end
+  def ensure_registered(object); end
+  def new_scope; end
+  def proxies; end
+  def proxies_of(klass); end
+  def proxy_for(object); end
+  def proxy_mutex; end
+  def register_constant_mutator(mutator); end
+  def registered?(object); end
+  def reset_all; end
+  def superclass_proxy_for(klass); end
+  def verify_all; end
+
+  private
+
+  def any_instance_recorder_not_found_for(id, klass); end
+  def class_proxy_with_callback_verification_strategy(object, strategy); end
+  def id_for(object); end
+  def new_mutex; end
+  def proxy_not_found_for(id, object); end
+  def superclass_proxy_not_found_for(id, object); end
+end
+
+class RSpec::Mocks::StubChain < ::RSpec::Mocks::MessageChain
+  private
+
+  def expectation(object, message, &return_block); end
+
+  class << self
+    def stub_chain_on(object, *chain, &blk); end
+  end
+end
+
+module RSpec::Mocks::Syntax
+  class << self
+    def default_should_syntax_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_unless_should_configured(method_name, replacement = T.unsafe(nil)); end
+  end
+end
+
+class RSpec::Mocks::TargetBase
+  include ::RSpec::Mocks::TargetDelegationInstanceMethods
+  extend ::RSpec::Mocks::TargetDelegationClassMethods
+
+  def initialize(target); end
+end
+
+module RSpec::Mocks::TargetDelegationClassMethods
+  def delegate_not_to(matcher_method, options = T.unsafe(nil)); end
+  def delegate_to(matcher_method); end
+  def disallow_negation(method_name); end
+end
+
+module RSpec::Mocks::TargetDelegationInstanceMethods
+  def target; end
+
+  private
+
+  def define_matcher(matcher, name, &block); end
+  def matcher_allowed?(matcher); end
+  def raise_negation_unsupported(method_name, matcher); end
+  def raise_unsupported_matcher(method_name, matcher); end
+end
+
+module RSpec::Mocks::TestDouble
+  def initialize(name = T.unsafe(nil), stubs = T.unsafe(nil)); end
+
+  def ==(other); end
+  def __build_mock_proxy_unless_expired(order_group); end
+  def __disallow_further_usage!; end
+  def as_null_object; end
+  def freeze; end
+  def inspect; end
+  def null_object?; end
+  def respond_to?(message, incl_private = T.unsafe(nil)); end
+  def to_s; end
+
+  private
+
+  def __build_mock_proxy(order_group); end
+  def __mock_proxy; end
+  def __raise_expired_error; end
+  def assign_stubs(stubs); end
+  def initialize_copy(other); end
+  def method_missing(message, *args, &block); end
+end
+
+module RSpec::Mocks::TestDoubleFormatter
+  class << self
+    def format(dbl, unwrap = T.unsafe(nil)); end
+
+    private
+
+    def name_desc(dbl); end
+    def type_desc(dbl); end
+    def verified_module_desc(dbl); end
+  end
+end
+
+class RSpec::Mocks::TestDoubleProxy < ::RSpec::Mocks::Proxy
+  def reset; end
+end
+
+class RSpec::Mocks::UnsupportedMatcherError < ::StandardError; end
+
+module RSpec::Mocks::VerifyingDouble
+  def initialize(doubled_module, *args); end
+
+  def __send__(name, *args, &block); end
+  def method_missing(message, *args, &block); end
+  def respond_to?(message, include_private = T.unsafe(nil)); end
+  def send(name, *args, &block); end
+end
+
+module RSpec::Mocks::VerifyingDouble::SilentIO
+  class << self
+    def method_missing(*_arg0); end
+    def respond_to?(*_arg0); end
+  end
+end
+
+class RSpec::Mocks::VerifyingDoubleNotDefinedError < ::StandardError; end
+
+class RSpec::Mocks::VerifyingExistingClassNewMethodDouble < ::RSpec::Mocks::VerifyingExistingMethodDouble
+  def with_signature; end
+end
+
+class RSpec::Mocks::VerifyingExistingMethodDouble < ::RSpec::Mocks::VerifyingMethodDouble
+  def initialize(object, method_name, proxy); end
+
+  def unimplemented?; end
+  def with_signature; end
+
+  class << self
+    def for(object, method_name, proxy); end
+  end
+end
+
+class RSpec::Mocks::VerifyingMessageExpectation < ::RSpec::Mocks::MessageExpectation
+  def initialize(*args); end
+
+  def method_reference; end
+  def method_reference=(_arg0); end
+  def with(*args, &block); end
+
+  private
+
+  def validate_expected_arguments!; end
+end
+
+class RSpec::Mocks::VerifyingMethodDouble < ::RSpec::Mocks::MethodDouble
+  def initialize(object, method_name, proxy, method_reference); end
+
+  def add_expectation(*args, &block); end
+  def add_stub(*args, &block); end
+  def message_expectation_class; end
+  def proxy_method_invoked(obj, *args, &block); end
+  def validate_arguments!(actual_args); end
+end
+
+class RSpec::Mocks::VerifyingPartialClassDoubleProxy < ::RSpec::Mocks::VerifyingPartialDoubleProxy
+  include ::RSpec::Mocks::PartialClassDoubleProxyMethods
+end
+
+class RSpec::Mocks::VerifyingPartialDoubleProxy < ::RSpec::Mocks::PartialDoubleProxy
+  include ::RSpec::Mocks::VerifyingProxyMethods
+
+  def initialize(object, expectation_ordering, optional_callback_invocation_strategy = T.unsafe(nil)); end
+
+  def ensure_implemented(_method_name); end
+  def method_reference; end
+end
+
+class RSpec::Mocks::VerifyingProxy < ::RSpec::Mocks::TestDoubleProxy
+  include ::RSpec::Mocks::VerifyingProxyMethods
+
+  def initialize(object, order_group, doubled_module, method_reference_class); end
+
+  def method_reference; end
+  def validate_arguments!(method_name, args); end
+  def visibility_for(method_name); end
+end
+
+module RSpec::Mocks::VerifyingProxyMethods
+  def add_message_expectation(method_name, opts = T.unsafe(nil), &block); end
+  def add_simple_stub(method_name, *args); end
+  def add_stub(method_name, opts = T.unsafe(nil), &implementation); end
+  def ensure_implemented(method_name); end
+  def ensure_publicly_implemented(method_name, _object); end
+end
+
+module RSpec::Mocks::Version; end
+RSpec::Mocks::Version::STRING = T.let(T.unsafe(nil), String)