packwerk 1.0.0

data/sorbet/rbi/gems/mocha@1.11.2.rbi

@@ -0,0 +1,964 @@
+# DO NOT EDIT MANUALLY
+# This is an autogenerated file for types exported from the `mocha` gem.
+# Please instead update this file by running `dev typecheck update`.
+
+# typed: true
+
+module Mocha
+  class << self
+    def configuration; end
+    def configure; end
+  end
+end
+
+module Mocha::API
+  include(::Mocha::ParameterMatchers)
+  include(::Mocha::Hooks)
+
+  def mock(*arguments); end
+  def sequence(name); end
+  def states(name); end
+  def stub(*arguments); end
+  def stub_everything(*arguments); end
+
+  class << self
+    def extended(mod); end
+    def included(_mod); end
+  end
+end
+
+class Mocha::AnyInstanceMethod < ::Mocha::StubbedMethod
+
+  private
+
+  def method_body(method); end
+  def mock_owner; end
+  def original_method_owner; end
+  def stubbee_method(method_name); end
+end
+
+class Mocha::AnyInstanceReceiver
+  def initialize(klass); end
+
+  def mocks; end
+end
+
+class Mocha::ArgumentIterator
+  def initialize(argument); end
+
+  def each; end
+end
+
+class Mocha::BacktraceFilter
+  def initialize(lib_directory = T.unsafe(nil)); end
+
+  def filtered(backtrace); end
+end
+
+Mocha::BacktraceFilter::LIB_DIRECTORY = T.let(T.unsafe(nil), String)
+
+module Mocha::BlockMatchers
+end
+
+class Mocha::BlockMatchers::BlockGiven
+  def match?(actual_block); end
+  def mocha_inspect; end
+end
+
+class Mocha::BlockMatchers::NoBlockGiven
+  def match?(actual_block); end
+  def mocha_inspect; end
+end
+
+class Mocha::BlockMatchers::OptionalBlock
+  def match?(_actual_block); end
+  def mocha_inspect; end
+end
+
+class Mocha::Cardinality
+  def initialize(required, maximum); end
+
+  def <<(invocation); end
+  def actual_invocations; end
+  def allowed_any_number_of_times?; end
+  def anticipated_times; end
+  def invocations_allowed?; end
+  def invoked_times; end
+  def needs_verifying?; end
+  def satisfied?; end
+  def used?; end
+  def verified?; end
+
+  protected
+
+  def infinite?(number); end
+  def maximum; end
+  def required; end
+  def times(number); end
+
+  class << self
+    def at_least(count); end
+    def at_most(count); end
+    def exactly(count); end
+    def times(range_or_count); end
+  end
+end
+
+Mocha::Cardinality::INFINITY = T.let(T.unsafe(nil), Float)
+
+class Mocha::Central
+  def initialize; end
+
+  def stub(method); end
+  def stubba_methods; end
+  def stubba_methods=(_); end
+  def unstub(method); end
+  def unstub_all; end
+end
+
+class Mocha::Central::Null < ::Mocha::Central
+  def initialize(&block); end
+
+  def stub(*_); end
+  def unstub(*_); end
+end
+
+class Mocha::ChangeStateSideEffect
+  def initialize(state); end
+
+  def mocha_inspect; end
+  def perform; end
+end
+
+module Mocha::ClassMethods
+  def __method_exists__?(method, include_public_methods = T.unsafe(nil)); end
+  def __method_visibility__(method, include_public_methods = T.unsafe(nil)); end
+  def any_instance; end
+end
+
+class Mocha::ClassMethods::AnyInstance
+  def initialize(klass); end
+
+  def mocha(instantiate = T.unsafe(nil)); end
+  def respond_to?(method); end
+  def stubba_class; end
+  def stubba_method; end
+  def stubba_object; end
+end
+
+class Mocha::Configuration
+  def initialize(options = T.unsafe(nil)); end
+
+  def display_matching_invocations_on_failure=(value); end
+  def display_matching_invocations_on_failure?; end
+  def merge(other); end
+  def reinstate_undocumented_behaviour_from_v1_9=(value); end
+  def reinstate_undocumented_behaviour_from_v1_9?; end
+  def stubbing_method_on_nil; end
+  def stubbing_method_on_nil=(value); end
+  def stubbing_method_on_non_mock_object; end
+  def stubbing_method_on_non_mock_object=(value); end
+  def stubbing_method_unnecessarily; end
+  def stubbing_method_unnecessarily=(value); end
+  def stubbing_non_existent_method; end
+  def stubbing_non_existent_method=(value); end
+  def stubbing_non_public_method; end
+  def stubbing_non_public_method=(value); end
+
+  protected
+
+  def options; end
+
+  private
+
+  def initialize_copy(other); end
+
+  class << self
+    def allow(action, &block); end
+    def allow?(action); end
+    def configuration; end
+    def override(temporary_options); end
+    def prevent(action, &block); end
+    def prevent?(action); end
+    def reset_configuration; end
+    def warn_when(action, &block); end
+    def warn_when?(action); end
+
+    private
+
+    def change_config(action, new_value, &block); end
+    def temporarily_change_config(action, new_value); end
+  end
+end
+
+Mocha::Configuration::DEFAULTS = T.let(T.unsafe(nil), Hash)
+
+module Mocha::Debug
+  class << self
+    def puts(message); end
+  end
+end
+
+Mocha::Debug::OPTIONS = T.let(T.unsafe(nil), Hash)
+
+class Mocha::DefaultName
+  def initialize(mock); end
+
+  def mocha_inspect; end
+end
+
+class Mocha::DefaultReceiver
+  def initialize(mock); end
+
+  def mocks; end
+end
+
+class Mocha::Deprecation
+  class << self
+    def messages; end
+    def messages=(_); end
+    def mode; end
+    def mode=(_); end
+    def warning(*messages); end
+  end
+end
+
+module Mocha::Detection
+end
+
+module Mocha::Detection::MiniTest
+  class << self
+    def testcase; end
+    def version; end
+  end
+end
+
+class Mocha::ErrorWithFilteredBacktrace < ::StandardError
+  def initialize(message = T.unsafe(nil), backtrace = T.unsafe(nil)); end
+end
+
+class Mocha::ExceptionRaiser
+  def initialize(exception, message); end
+
+  def evaluate(invocation); end
+end
+
+class Mocha::Expectation
+  def initialize(mock, expected_method_name, backtrace = T.unsafe(nil)); end
+
+  def add_in_sequence_ordering_constraint(sequence); end
+  def add_ordering_constraint(ordering_constraint); end
+  def add_side_effect(side_effect); end
+  def at_least(minimum_number_of_times); end
+  def at_least_once; end
+  def at_most(maximum_number_of_times); end
+  def at_most_once; end
+  def backtrace; end
+  def in_correct_order?; end
+  def in_sequence(sequence, *sequences); end
+  def inspect; end
+  def invocations_allowed?; end
+  def invoke(invocation); end
+  def match?(invocation); end
+  def matches_method?(method_name); end
+  def method_signature; end
+  def mocha_inspect; end
+  def multiple_yields(*parameter_groups); end
+  def never; end
+  def once; end
+  def perform_side_effects; end
+  def raises(exception = T.unsafe(nil), message = T.unsafe(nil)); end
+  def returns(*values); end
+  def satisfied?; end
+  def then(*parameters); end
+  def throws(tag, object = T.unsafe(nil)); end
+  def times(range); end
+  def twice; end
+  def used?; end
+  def verified?(assertion_counter = T.unsafe(nil)); end
+  def when(state_predicate); end
+  def with(*expected_parameters, &matching_block); end
+  def with_block_given; end
+  def with_no_block_given; end
+  def yields(*parameters); end
+end
+
+class Mocha::ExpectationError < ::Exception
+end
+
+class Mocha::ExpectationErrorFactory
+  class << self
+    def build(message = T.unsafe(nil), backtrace = T.unsafe(nil)); end
+    def exception_class; end
+    def exception_class=(_); end
+  end
+end
+
+class Mocha::ExpectationList
+  def initialize(expectations = T.unsafe(nil)); end
+
+  def +(other); end
+  def add(expectation); end
+  def any?; end
+  def length; end
+  def match(invocation); end
+  def match_allowing_invocation(invocation); end
+  def matches_method?(method_name); end
+  def remove_all_matching_method(method_name); end
+  def to_a; end
+  def to_set; end
+  def verified?(assertion_counter = T.unsafe(nil)); end
+
+  private
+
+  def matching_expectations(invocation); end
+end
+
+module Mocha::Hooks
+  def mocha_setup; end
+  def mocha_teardown; end
+  def mocha_verify(assertion_counter = T.unsafe(nil)); end
+end
+
+class Mocha::ImpersonatingAnyInstanceName
+  def initialize(klass); end
+
+  def mocha_inspect; end
+end
+
+class Mocha::ImpersonatingName
+  def initialize(object); end
+
+  def mocha_inspect; end
+end
+
+class Mocha::InStateOrderingConstraint
+  def initialize(state_predicate); end
+
+  def allows_invocation_now?; end
+  def mocha_inspect; end
+end
+
+module Mocha::Inspect
+end
+
+module Mocha::Inspect::ArrayMethods
+  def mocha_inspect; end
+end
+
+module Mocha::Inspect::DateMethods
+  def mocha_inspect; end
+end
+
+module Mocha::Inspect::HashMethods
+  def mocha_inspect; end
+end
+
+module Mocha::Inspect::ObjectMethods
+  def mocha_inspect; end
+end
+
+module Mocha::Inspect::TimeMethods
+  def mocha_inspect; end
+end
+
+class Mocha::InstanceMethod < ::Mocha::StubbedMethod
+
+  private
+
+  def method_body(method); end
+  def mock_owner; end
+  def original_method_owner; end
+  def stubbee_method(method_name); end
+end
+
+module Mocha::Integration
+end
+
+class Mocha::Integration::AssertionCounter
+  def initialize(test_case); end
+
+  def increment; end
+end
+
+module Mocha::Integration::MiniTest
+  class << self
+    def activate; end
+    def translate(exception); end
+  end
+end
+
+module Mocha::Integration::MiniTest::Adapter
+  include(::Mocha::ParameterMatchers)
+  include(::Mocha::Hooks)
+  include(::Mocha::API)
+
+  def after_teardown; end
+  def before_setup; end
+  def before_teardown; end
+
+  class << self
+    def applicable_to?(mini_test_version); end
+    def description; end
+    def included(_mod); end
+  end
+end
+
+module Mocha::Integration::MiniTest::Nothing
+  class << self
+    def applicable_to?(_test_unit_version, _ruby_version = T.unsafe(nil)); end
+    def description; end
+    def included(_mod); end
+  end
+end
+
+module Mocha::Integration::MiniTest::Version13
+  class << self
+    def applicable_to?(mini_test_version); end
+    def description; end
+    def included(mod); end
+  end
+end
+
+module Mocha::Integration::MiniTest::Version13::RunMethodPatch
+  def run(runner); end
+end
+
+module Mocha::Integration::MiniTest::Version140
+  class << self
+    def applicable_to?(mini_test_version); end
+    def description; end
+    def included(mod); end
+  end
+end
+
+module Mocha::Integration::MiniTest::Version140::RunMethodPatch
+  def run(runner); end
+end
+
+module Mocha::Integration::MiniTest::Version141
+  class << self
+    def applicable_to?(mini_test_version); end
+    def description; end
+    def included(mod); end
+  end
+end
+
+module Mocha::Integration::MiniTest::Version141::RunMethodPatch
+  def run(runner); end
+end
+
+module Mocha::Integration::MiniTest::Version142To172
+  class << self
+    def applicable_to?(mini_test_version); end
+    def description; end
+    def included(mod); end
+  end
+end
+
+module Mocha::Integration::MiniTest::Version142To172::RunMethodPatch
+  def run(runner); end
+end
+
+module Mocha::Integration::MiniTest::Version200
+  class << self
+    def applicable_to?(mini_test_version); end
+    def description; end
+    def included(mod); end
+  end
+end
+
+module Mocha::Integration::MiniTest::Version200::RunMethodPatch
+  def run(runner); end
+end
+
+module Mocha::Integration::MiniTest::Version201To222
+  class << self
+    def applicable_to?(mini_test_version); end
+    def description; end
+    def included(mod); end
+  end
+end
+
+module Mocha::Integration::MiniTest::Version201To222::RunMethodPatch
+  def run(runner); end
+end
+
+module Mocha::Integration::MiniTest::Version2110To2111
+  class << self
+    def applicable_to?(mini_test_version); end
+    def description; end
+    def included(mod); end
+  end
+end
+
+module Mocha::Integration::MiniTest::Version2110To2111::RunMethodPatch
+  def run(runner); end
+end
+
+module Mocha::Integration::MiniTest::Version2112To320
+  class << self
+    def applicable_to?(mini_test_version); end
+    def description; end
+    def included(mod); end
+  end
+end
+
+module Mocha::Integration::MiniTest::Version2112To320::RunMethodPatch
+  def run(runner); end
+end
+
+module Mocha::Integration::MiniTest::Version230To2101
+  class << self
+    def applicable_to?(mini_test_version); end
+    def description; end
+    def included(mod); end
+  end
+end
+
+module Mocha::Integration::MiniTest::Version230To2101::RunMethodPatch
+  def run(runner); end
+end
+
+module Mocha::Integration::MonkeyPatcher
+  class << self
+    def apply(mod, run_method_patch); end
+  end
+end
+
+class Mocha::Invocation
+  def initialize(mock, method_name, *arguments, &block); end
+
+  def arguments; end
+  def block; end
+  def call(yield_parameters = T.unsafe(nil), return_values = T.unsafe(nil)); end
+  def call_description; end
+  def full_description; end
+  def method_name; end
+  def raised(exception); end
+  def result_description; end
+  def returned(value); end
+  def short_call_description; end
+  def threw(tag, value); end
+end
+
+class Mocha::Logger
+  def initialize(io); end
+
+  def warn(message); end
+end
+
+class Mocha::MethodMatcher
+  def initialize(expected_method_name); end
+
+  def expected_method_name; end
+  def match?(actual_method_name); end
+  def mocha_inspect; end
+end
+
+class Mocha::Mock
+  def initialize(mockery, name = T.unsafe(nil), receiver = T.unsafe(nil)); end
+
+  def __expectations__; end
+  def __expects__(method_name_or_hash, backtrace = T.unsafe(nil)); end
+  def __expire__; end
+  def __singleton_class__; end
+  def __stubs__(method_name_or_hash, backtrace = T.unsafe(nil)); end
+  def __verified__?(assertion_counter = T.unsafe(nil)); end
+  def all_expectations; end
+  def any_expectations?; end
+  def ensure_method_not_already_defined(method_name); end
+  def everything_stubbed; end
+  def expects(method_name_or_hash, backtrace = T.unsafe(nil)); end
+  def inspect; end
+  def method_missing(symbol, *arguments, &block); end
+  def mocha_inspect; end
+  def quacks_like(responder); end
+  def quacks_like_instance_of(responder_class); end
+  def responds_like(responder); end
+  def responds_like_instance_of(responder_class); end
+  def stub_everything; end
+  def stubs(method_name_or_hash, backtrace = T.unsafe(nil)); end
+  def unstub(*method_names); end
+
+  private
+
+  def check_expiry; end
+  def check_responder_responds_to(symbol); end
+  def raise_unexpected_invocation_error(invocation, matching_expectation); end
+  def respond_to_missing?(symbol, include_private = T.unsafe(nil)); end
+end
+
+class Mocha::Mockery
+  def logger; end
+  def logger=(_); end
+  def mocha_inspect; end
+  def mock_impersonating(object); end
+  def mock_impersonating_any_instance_of(klass); end
+  def mocks; end
+  def named_mock(name); end
+  def new_state_machine(name); end
+  def on_stubbing(object, method); end
+  def on_stubbing_method_unnecessarily(expectation); end
+  def state_machines; end
+  def stubba; end
+  def teardown; end
+  def unnamed_mock; end
+  def verify(assertion_counter = T.unsafe(nil)); end
+
+  private
+
+  def add_mock(mock); end
+  def add_state_machine(state_machine); end
+  def check(action, description, signature_proc, backtrace = T.unsafe(nil)); end
+  def expectations; end
+  def reset; end
+  def satisfied_expectations; end
+  def unsatisfied_expectations; end
+
+  class << self
+    def instance; end
+    def setup; end
+    def teardown; end
+    def verify(*args); end
+
+    private
+
+    def instances; end
+  end
+end
+
+class Mocha::Mockery::Null < ::Mocha::Mockery
+  def add_mock(*_); end
+  def add_state_machine(*_); end
+  def stubba; end
+
+  private
+
+  def raise_not_initialized_error; end
+end
+
+class Mocha::Name
+  def initialize(name); end
+
+  def mocha_inspect; end
+end
+
+class Mocha::NotInitializedError < ::Mocha::ErrorWithFilteredBacktrace
+end
+
+module Mocha::ObjectMethods
+  def _method(_); end
+  def expects(expected_methods_vs_return_values); end
+  def mocha(instantiate = T.unsafe(nil)); end
+  def reset_mocha; end
+  def stubba_class; end
+  def stubba_method; end
+  def stubba_object; end
+  def stubs(stubbed_methods_vs_return_values); end
+  def unstub(*method_names); end
+end
+
+class Mocha::ObjectReceiver
+  def initialize(object); end
+
+  def mocks; end
+end
+
+module Mocha::ParameterMatchers
+  def Not(matcher); end
+  def all_of(*matchers); end
+  def any_of(*matchers); end
+  def any_parameters; end
+  def anything; end
+  def equals(value); end
+  def equivalent_uri(uri); end
+  def has_entries(entries); end
+  def has_entry(*options); end
+  def has_key(key); end
+  def has_value(value); end
+  def includes(*items); end
+  def instance_of(klass); end
+  def is_a(klass); end
+  def kind_of(klass); end
+  def optionally(*matchers); end
+  def regexp_matches(regexp); end
+  def responds_with(message, result); end
+  def yaml_equivalent(object); end
+end
+
+class Mocha::ParameterMatchers::AllOf < ::Mocha::ParameterMatchers::Base
+  def initialize(*matchers); end
+
+  def matches?(available_parameters); end
+  def mocha_inspect; end
+end
+
+class Mocha::ParameterMatchers::AnyOf < ::Mocha::ParameterMatchers::Base
+  def initialize(*matchers); end
+
+  def matches?(available_parameters); end
+  def mocha_inspect; end
+end
+
+class Mocha::ParameterMatchers::AnyParameters < ::Mocha::ParameterMatchers::Base
+  def matches?(available_parameters); end
+  def mocha_inspect; end
+end
+
+class Mocha::ParameterMatchers::Anything < ::Mocha::ParameterMatchers::Base
+  def matches?(available_parameters); end
+  def mocha_inspect; end
+end
+
+class Mocha::ParameterMatchers::Base
+  def &(other); end
+  def to_matcher; end
+  def |(other); end
+end
+
+class Mocha::ParameterMatchers::Equals < ::Mocha::ParameterMatchers::Base
+  def initialize(value); end
+
+  def matches?(available_parameters); end
+  def mocha_inspect; end
+end
+
+class Mocha::ParameterMatchers::EquivalentUri < ::Mocha::ParameterMatchers::Base
+  def initialize(uri); end
+
+  def matches?(available_parameters); end
+  def mocha_inspect; end
+
+  private
+
+  def explode(uri); end
+end
+
+class Mocha::ParameterMatchers::HasEntries < ::Mocha::ParameterMatchers::Base
+  def initialize(entries); end
+
+  def matches?(available_parameters); end
+  def mocha_inspect; end
+end
+
+class Mocha::ParameterMatchers::HasEntry < ::Mocha::ParameterMatchers::Base
+  def initialize(key, value); end
+
+  def matches?(available_parameters); end
+  def mocha_inspect; end
+end
+
+class Mocha::ParameterMatchers::HasKey < ::Mocha::ParameterMatchers::Base
+  def initialize(key); end
+
+  def matches?(available_parameters); end
+  def mocha_inspect; end
+end
+
+class Mocha::ParameterMatchers::HasValue < ::Mocha::ParameterMatchers::Base
+  def initialize(value); end
+
+  def matches?(available_parameters); end
+  def mocha_inspect; end
+end
+
+class Mocha::ParameterMatchers::Includes < ::Mocha::ParameterMatchers::Base
+  def initialize(*items); end
+
+  def matches?(available_parameters); end
+  def mocha_inspect; end
+end
+
+module Mocha::ParameterMatchers::InstanceMethods
+  def to_matcher; end
+end
+
+class Mocha::ParameterMatchers::InstanceOf < ::Mocha::ParameterMatchers::Base
+  def initialize(klass); end
+
+  def matches?(available_parameters); end
+  def mocha_inspect; end
+end
+
+class Mocha::ParameterMatchers::IsA < ::Mocha::ParameterMatchers::Base
+  def initialize(klass); end
+
+  def matches?(available_parameters); end
+  def mocha_inspect; end
+end
+
+class Mocha::ParameterMatchers::KindOf < ::Mocha::ParameterMatchers::Base
+  def initialize(klass); end
+
+  def matches?(available_parameters); end
+  def mocha_inspect; end
+end
+
+class Mocha::ParameterMatchers::Not < ::Mocha::ParameterMatchers::Base
+  def initialize(matcher); end
+
+  def matches?(available_parameters); end
+  def mocha_inspect; end
+end
+
+class Mocha::ParameterMatchers::Optionally < ::Mocha::ParameterMatchers::Base
+  def initialize(*parameters); end
+
+  def matches?(available_parameters); end
+  def mocha_inspect; end
+end
+
+class Mocha::ParameterMatchers::RegexpMatches < ::Mocha::ParameterMatchers::Base
+  def initialize(regexp); end
+
+  def matches?(available_parameters); end
+  def mocha_inspect; end
+end
+
+class Mocha::ParameterMatchers::RespondsWith < ::Mocha::ParameterMatchers::Base
+  def initialize(message, result); end
+
+  def matches?(available_parameters); end
+  def mocha_inspect; end
+end
+
+class Mocha::ParameterMatchers::YamlEquivalent < ::Mocha::ParameterMatchers::Base
+  def initialize(object); end
+
+  def matches?(available_parameters); end
+  def mocha_inspect; end
+end
+
+class Mocha::ParametersMatcher
+  def initialize(expected_parameters = T.unsafe(nil), &matching_block); end
+
+  def match?(actual_parameters = T.unsafe(nil)); end
+  def matchers; end
+  def mocha_inspect; end
+  def parameters_match?(actual_parameters); end
+end
+
+Mocha::RUBY_V2_PLUS = T.let(T.unsafe(nil), TrueClass)
+
+class Mocha::RaisedException
+  def initialize(exception); end
+
+  def mocha_inspect; end
+end
+
+class Mocha::ReturnValues
+  def initialize(*values); end
+
+  def +(other); end
+  def next(invocation); end
+  def values; end
+  def values=(_); end
+
+  class << self
+    def build(*values); end
+  end
+end
+
+class Mocha::Sequence
+  def initialize(name); end
+
+  def constrain_as_next_in_sequence(expectation); end
+  def mocha_inspect; end
+  def satisfied_to_index?(index); end
+end
+
+class Mocha::Sequence::InSequenceOrderingConstraint
+  def initialize(sequence, index); end
+
+  def allows_invocation_now?; end
+  def mocha_inspect; end
+end
+
+class Mocha::SingleReturnValue
+  def initialize(value); end
+
+  def evaluate(invocation); end
+end
+
+class Mocha::StateMachine
+  def initialize(name); end
+
+  def become(next_state_name); end
+  def current_state; end
+  def current_state=(_); end
+  def is(state_name); end
+  def is_not(state_name); end
+  def mocha_inspect; end
+  def name; end
+  def starts_as(initial_state_name); end
+end
+
+class Mocha::StateMachine::State
+  def initialize(state_machine, state); end
+
+  def activate; end
+  def active?; end
+  def mocha_inspect; end
+end
+
+class Mocha::StateMachine::StatePredicate
+  def initialize(state_machine, state); end
+
+  def active?; end
+  def mocha_inspect; end
+end
+
+class Mocha::StubbedMethod
+  def initialize(stubbee, method_name); end
+
+  def ==(_); end
+  def define_new_method; end
+  def hide_original_method; end
+  def matches?(other); end
+  def method_name; end
+  def mock; end
+  def remove_new_method; end
+  def reset_mocha; end
+  def restore_original_method; end
+  def store_original_method; end
+  def stub; end
+  def stubbee; end
+  def to_s; end
+  def unstub; end
+
+  private
+
+  def remove_original_method_from_stubbee; end
+  def retain_original_visibility(method_owner); end
+  def store_original_method_visibility; end
+  def stub_method_overwrites_original_method?; end
+  def stub_method_owner; end
+  def use_prepended_module_for_stub_method; end
+  def use_prepended_module_for_stub_method?; end
+end
+
+class Mocha::StubbedMethod::PrependedModule < ::Module
+end
+
+class Mocha::StubbingError < ::Mocha::ErrorWithFilteredBacktrace
+end
+
+class Mocha::Thrower
+  def initialize(tag, object = T.unsafe(nil)); end
+
+  def evaluate(invocation); end
+end
+
+class Mocha::ThrownObject
+  def initialize(tag, value = T.unsafe(nil)); end
+
+  def mocha_inspect; end
+end
+
+class Mocha::YieldParameters
+  def initialize; end
+
+  def add(*parameter_groups); end
+  def next_invocation; end
+end