# typed: true

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


module ERB::Escape; end

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

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

module RSpec::Core
  class << self
    def path_to_executable; end
  end
end

class RSpec::Core::AnonymousExampleGroup < ::RSpec::Core::ExampleGroup
  class << self
    def metadata; end
  end
end

class RSpec::Core::BacktraceFormatter
  def initialize; end

  def backtrace_line(line); end
  def exclude?(line); end
  def exclusion_patterns; end
  def exclusion_patterns=(_arg0); end
  def filter_gem(gem_name); end
  def format_backtrace(backtrace, options = T.unsafe(nil)); end
  def full_backtrace=(_arg0); end
  def full_backtrace?; end
  def inclusion_patterns; end
  def inclusion_patterns=(_arg0); end

  private

  def matches?(patterns, line); end
end

class RSpec::Core::Configuration
  include ::RSpec::Core::Hooks
  include ::RSpec::Core::Configuration::Readers

  def initialize; end

  def add_formatter(formatter, output = T.unsafe(nil)); end
  def add_setting(name, opts = T.unsafe(nil)); end
  def after(scope = T.unsafe(nil), *meta, &block); end
  def alias_example_group_to(new_name, *args); end
  def alias_example_to(name, *args); end
  def alias_it_behaves_like_to(new_name, report_label = T.unsafe(nil)); end
  def alias_it_should_behave_like_to(new_name, report_label = T.unsafe(nil)); end
  def append_after(scope = T.unsafe(nil), *meta, &block); end
  def append_before(scope = T.unsafe(nil), *meta, &block); end
  def apply_derived_metadata_to(metadata); end
  def around(scope = T.unsafe(nil), *meta, &block); end
  def backtrace_exclusion_patterns; end
  def backtrace_exclusion_patterns=(patterns); end
  def backtrace_formatter; end
  def backtrace_inclusion_patterns; end
  def backtrace_inclusion_patterns=(patterns); end
  def before(scope = T.unsafe(nil), *meta, &block); end
  def bisect_runner; end
  def bisect_runner=(value); end
  def bisect_runner_class; end
  def color; end
  def color=(_arg0); end
  def color_enabled?(output = T.unsafe(nil)); end
  def color_mode; end
  def color_mode=(_arg0); end
  def configure_example(example, example_hooks); end
  def configure_expectation_framework; end
  def configure_group(group); end
  def configure_mock_framework; end
  def default_color; end
  def default_color=(_arg0); end
  def default_color?; end
  def default_formatter; end
  def default_formatter=(value); end
  def default_path; end
  def default_path=(path); end
  def default_path?; end
  def define_derived_metadata(*filters, &block); end
  def deprecation_stream; end
  def deprecation_stream=(value); end
  def detail_color; end
  def detail_color=(_arg0); end
  def detail_color?; end
  def disable_monkey_patching; end
  def disable_monkey_patching!; end
  def disable_monkey_patching=(_arg0); end
  def drb; end
  def drb=(_arg0); end
  def drb?; end
  def drb_port; end
  def drb_port=(_arg0); end
  def drb_port?; end
  def dry_run; end
  def dry_run=(_arg0); end
  def dry_run?; end
  def error_exit_code; end
  def error_exit_code=(_arg0); end
  def error_exit_code?; end
  def error_stream; end
  def error_stream=(_arg0); end
  def error_stream?; end
  def example_status_persistence_file_path; end
  def example_status_persistence_file_path=(value); end
  def exclude_pattern; end
  def exclude_pattern=(value); end
  def exclusion_filter; end
  def exclusion_filter=(filter); end
  def expect_with(*frameworks); end
  def expectation_framework=(framework); end
  def expectation_frameworks; end
  def expose_current_running_example_as(method_name); end
  def expose_dsl_globally=(value); end
  def expose_dsl_globally?; end
  def extend(mod, *filters); end
  def fail_fast; end
  def fail_fast=(value); end
  def fail_if_no_examples; end
  def fail_if_no_examples=(_arg0); end
  def fail_if_no_examples?; end
  def failure_color; end
  def failure_color=(_arg0); end
  def failure_color?; end
  def failure_exit_code; end
  def failure_exit_code=(_arg0); end
  def failure_exit_code?; end
  def files_or_directories_to_run=(*files); end
  def files_to_run; end
  def files_to_run=(_arg0); end
  def filter; end
  def filter=(filter); end
  def filter_gems_from_backtrace(*gem_names); end
  def filter_manager; end
  def filter_manager=(_arg0); end
  def filter_run(*args); end
  def filter_run_excluding(*args); end
  def filter_run_including(*args); end
  def filter_run_when_matching(*args); end
  def fixed_color; end
  def fixed_color=(_arg0); end
  def fixed_color?; end
  def force(hash); end
  def format_docstrings(&block); end
  def format_docstrings_block; end
  def formatter=(formatter, output = T.unsafe(nil)); end
  def formatter_loader; end
  def formatters; end
  def full_backtrace=(true_or_false); end
  def full_backtrace?; end
  def full_cause_backtrace; end
  def full_cause_backtrace=(_arg0); end
  def full_cause_backtrace?; end
  def full_description; end
  def full_description=(description); end
  def hooks; end
  def in_project_source_dir_regex; end
  def include(mod, *filters); end
  def include_context(shared_group_name, *filters); end
  def inclusion_filter; end
  def inclusion_filter=(filter); end
  def last_run_statuses; end
  def libs; end
  def libs=(libs); end
  def load_spec_files; end
  def loaded_spec_files; end
  def max_displayed_failure_line_count; end
  def max_displayed_failure_line_count=(_arg0); end
  def max_displayed_failure_line_count?; end
  def mock_framework; end
  def mock_framework=(framework); end
  def mock_with(framework); end
  def on_example_group_definition(&block); end
  def on_example_group_definition_callbacks; end
  def only_failures; end
  def only_failures?; end
  def only_failures_but_not_configured?; end
  def order=(*args, &block); end
  def ordering_manager; end
  def ordering_registry(*args, &block); end
  def output_stream; end
  def output_stream=(value); end
  def pattern; end
  def pattern=(value); end
  def pending_color; end
  def pending_color=(_arg0); end
  def pending_color?; end
  def pending_failure_output; end
  def pending_failure_output=(mode); end
  def pending_failure_output?; end
  def prepend(mod, *filters); end
  def prepend_after(scope = T.unsafe(nil), *meta, &block); end
  def prepend_before(scope = T.unsafe(nil), *meta, &block); end
  def profile_examples; end
  def profile_examples=(_arg0); end
  def profile_examples?; end
  def project_source_dirs; end
  def project_source_dirs=(_arg0); end
  def project_source_dirs?; end
  def raise_errors_for_deprecations!; end
  def raise_on_warning=(value); end
  def register_ordering(*args, &block); end
  def reporter; end
  def requires; end
  def requires=(paths); end
  def reset; end
  def reset_filters; end
  def reset_reporter; end
  def run_all_when_everything_filtered; end
  def run_all_when_everything_filtered=(_arg0); end
  def run_all_when_everything_filtered?; end
  def seed(*args, &block); end
  def seed=(*args, &block); end
  def seed_used?(*args, &block); end
  def shared_context_metadata_behavior; end
  def shared_context_metadata_behavior=(value); end
  def silence_filter_announcements; end
  def silence_filter_announcements=(_arg0); end
  def silence_filter_announcements?; end
  def spec_files_with_failures; end
  def start_time; end
  def start_time=(_arg0); end
  def start_time?; end
  def static_config_filter_manager; end
  def static_config_filter_manager=(_arg0); end
  def success_color; end
  def success_color=(_arg0); end
  def success_color?; end
  def threadsafe; end
  def threadsafe=(_arg0); end
  def threadsafe?; end
  def treat_symbols_as_metadata_keys_with_true_values=(_value); end
  def tty; end
  def tty=(_arg0); end
  def tty?; end
  def warnings=(value); end
  def warnings?; end
  def when_first_matching_example_defined(*filters); end
  def with_suite_hooks; end
  def world; end
  def world=(_arg0); end

  private

  def absolute_pattern?(pattern); end
  def add_hook_to_existing_matching_groups(meta, scope, &block); end
  def assert_no_example_groups_defined(config_option); end
  def clear_values_derived_from_example_status_persistence_file_path; end
  def command; end
  def conditionally_disable_expectations_monkey_patching; end
  def conditionally_disable_mocks_monkey_patching; end
  def configure_group_with(group, module_list, application_method); end
  def define_built_in_hooks; end
  def define_mixed_in_module(mod, filters, mod_list, config_method, &block); end
  def extract_location(path); end
  def file_glob_from(path, pattern); end
  def gather_directories(path); end
  def get_files_to_run(paths); end
  def get_matching_files(path, pattern); end
  def handle_suite_hook(scope, meta); end
  def load_file_handling_errors(method, file); end
  def metadata_applies_to_group?(meta, group); end
  def on_existing_matching_groups(meta); end
  def output_to_tty?(output = T.unsafe(nil)); end
  def output_wrapper; end
  def paths_to_check(paths); end
  def pattern_might_load_specs_from_vendored_dirs?; end
  def rspec_expectations_loaded?; end
  def rspec_mocks_loaded?; end
  def run_suite_hooks(hook_description, hooks); end
  def safe_extend(mod, host); end
  def safe_include(mod, host); end
  def safe_prepend(mod, host); end
  def update_pattern_attr(name, value); end
  def value_for(key); end

  class << self
    def add_read_only_setting(name, opts = T.unsafe(nil)); end
    def add_setting(name, opts = T.unsafe(nil)); end
    def define_alias(name, alias_name); end
    def define_predicate(name); end
    def define_reader(name); end
    def delegate_to_ordering_manager(*methods); end
  end
end

RSpec::Core::Configuration::DEFAULT_FORMATTER = T.let(T.unsafe(nil), Proc)

class RSpec::Core::Configuration::DeprecationReporterBuffer
  def initialize; end

  def deprecation(*args); end
  def play_onto(reporter); end
end

module RSpec::Core::Configuration::ExposeCurrentExample; end
RSpec::Core::Configuration::FAILED_STATUS = T.let(T.unsafe(nil), String)
RSpec::Core::Configuration::MOCKING_ADAPTERS = T.let(T.unsafe(nil), Hash)
class RSpec::Core::Configuration::MustBeConfiguredBeforeExampleGroupsError < ::StandardError; end
RSpec::Core::Configuration::PASSED_STATUS = T.let(T.unsafe(nil), String)
RSpec::Core::Configuration::PENDING_STATUS = T.let(T.unsafe(nil), String)
RSpec::Core::Configuration::RAISE_ERROR_WARNING_NOTIFIER = T.let(T.unsafe(nil), Proc)

module RSpec::Core::Configuration::Readers
  def default_color; end
  def default_path; end
  def deprecation_stream; end
  def detail_color; end
  def drb; end
  def drb_port; end
  def dry_run; end
  def error_exit_code; end
  def error_stream; end
  def example_status_persistence_file_path; end
  def exclude_pattern; end
  def fail_fast; end
  def fail_if_no_examples; end
  def failure_color; end
  def failure_exit_code; end
  def fixed_color; end
  def full_cause_backtrace; end
  def libs; end
  def max_displayed_failure_line_count; end
  def only_failures; end
  def output_stream; end
  def pattern; end
  def pending_color; end
  def pending_failure_output; end
  def project_source_dirs; end
  def requires; end
  def run_all_when_everything_filtered; end
  def shared_context_metadata_behavior; end
  def silence_filter_announcements; end
  def start_time; end
  def success_color; end
  def threadsafe; end
  def tty; end
end

RSpec::Core::Configuration::UNKNOWN_STATUS = T.let(T.unsafe(nil), String)
RSpec::Core::Configuration::VALID_STATUSES = T.let(T.unsafe(nil), Array)

class RSpec::Core::ConfigurationOptions
  def initialize(args); end

  def args; end
  def configure(config); end
  def configure_filter_manager(filter_manager); end
  def options; end

  private

  def args_from_options_file(path); end
  def command_line_options; end
  def custom_options; end
  def custom_options_file; end
  def env_options; end
  def file_options; end
  def force?(key); end
  def global_options; end
  def global_options_file; end
  def home_options_file_path; end
  def load_formatters_into(config); end
  def local_options; end
  def local_options_file; end
  def options_file_as_erb_string(path); end
  def options_from(path); end
  def order(keys); end
  def organize_options; end
  def parse_args_ignoring_files_or_dirs_to_run(args, source); end
  def process_options_into(config); end
  def project_options; end
  def project_options_file; end
  def resolve_xdg_config_home; end
  def xdg_options_file_if_exists; end
  def xdg_options_file_path; end
end

RSpec::Core::ConfigurationOptions::OPTIONS_ORDER = T.let(T.unsafe(nil), Array)
RSpec::Core::ConfigurationOptions::UNFORCED_OPTIONS = T.let(T.unsafe(nil), RSpec::Core::Set)
RSpec::Core::ConfigurationOptions::UNPROCESSABLE_OPTIONS = T.let(T.unsafe(nil), RSpec::Core::Set)

module RSpec::Core::DSL
  class << self
    def change_global_dsl(&changes); end
    def example_group_aliases; end
    def expose_example_group_alias(name); end
    def expose_example_group_alias_globally(method_name); end
    def expose_globally!; end
    def exposed_globally?; end
    def remove_globally!; end
    def top_level; end
    def top_level=(_arg0); end
  end
end

class RSpec::Core::DeprecationError < ::StandardError; end

class RSpec::Core::DidYouMean
  def initialize(relative_file_name); end

  def call; end
  def relative_file_name; end

  private

  def formats(probables); end
  def red_font(mytext); end
  def top_and_tail(rspec_format); end
end

class RSpec::Core::Example
  def initialize(example_group_class, description, user_metadata, example_block = T.unsafe(nil)); end

  def clock; end
  def clock=(_arg0); end
  def description; end
  def display_exception; end
  def display_exception=(ex); end
  def duplicate_with(metadata_overrides = T.unsafe(nil)); end
  def example_group; end
  def example_group_instance; end
  def exception; end
  def execution_result; end
  def fail_with_exception(reporter, exception); end
  def file_path; end
  def full_description; end
  def id; end
  def inspect; end
  def inspect_output; end
  def instance_exec(*args, &block); end
  def location; end
  def location_rerun_argument; end
  def metadata; end
  def pending; end
  def pending?; end
  def reporter; end
  def rerun_argument; end
  def run(example_group_instance, reporter); end
  def set_aggregate_failures_exception(exception); end
  def set_exception(exception); end
  def skip; end
  def skip_with_exception(reporter, exception); end
  def skipped?; end
  def to_s; end
  def update_inherited_metadata(updates); end

  private

  def assign_generated_description; end
  def finish(reporter); end
  def generate_description; end
  def hooks; end
  def location_description; end
  def mocks_need_verification?; end
  def record_finished(status, reporter); end
  def run_after_example; end
  def run_before_example; end
  def start(reporter); end
  def verify_mocks; end
  def with_around_and_singleton_context_hooks; end
  def with_around_example_hooks; end

  class << self
    def delegate_to_metadata(key); end
    def parse_id(id); end
  end
end

RSpec::Core::Example::AllExceptionsExcludingDangerousOnesOnRubiesThatAllowIt = RSpec::Support::AllExceptionsExceptOnesWeMustNotRescue

class RSpec::Core::Example::ExecutionResult
  include ::RSpec::Core::HashImitatable
  extend ::RSpec::Core::HashImitatable::ClassMethods

  def ensure_timing_set(clock); end
  def example_skipped?; end
  def exception; end
  def exception=(_arg0); end
  def finished_at; end
  def finished_at=(_arg0); end
  def pending_exception; end
  def pending_exception=(_arg0); end
  def pending_fixed; end
  def pending_fixed=(_arg0); end
  def pending_fixed?; end
  def pending_message; end
  def pending_message=(_arg0); end
  def record_finished(status, finished_at); end
  def run_time; end
  def run_time=(_arg0); end
  def started_at; end
  def started_at=(_arg0); end
  def status; end
  def status=(_arg0); end

  private

  def calculate_run_time(finished_at); end
  def get_value(name); end
  def hash_for_delegation; end
  def issue_deprecation(_method_name, *_args); end
  def set_value(name, value); end
end

class RSpec::Core::Example::Procsy
  def initialize(example, &block); end

  def <<(*a, &b); end
  def ==(*a, &b); end
  def ===(*a, &b); end
  def >>(*a, &b); end
  def [](*a, &b); end
  def arity(*a, &b); end
  def binding(*a, &b); end
  def call(*args, &block); end
  def clock(*a, &b); end
  def clock=(*a, &b); end
  def clone(*a, &b); end
  def curry(*a, &b); end
  def description(*a, &b); end
  def dup(*a, &b); end
  def duplicate_with(*a, &b); end
  def eql?(*a, &b); end
  def example; end
  def example_group(*a, &b); end
  def example_group_instance(*a, &b); end
  def exception(*a, &b); end
  def executed?; end
  def execution_result(*a, &b); end
  def file_path(*a, &b); end
  def full_description(*a, &b); end
  def hash(*a, &b); end
  def id(*a, &b); end
  def inspect; end
  def inspect_output(*a, &b); end
  def lambda?(*a, &b); end
  def location(*a, &b); end
  def location_rerun_argument(*a, &b); end
  def metadata(*a, &b); end
  def parameters(*a, &b); end
  def pending(*a, &b); end
  def pending?(*a, &b); end
  def reporter(*a, &b); end
  def rerun_argument(*a, &b); end
  def ruby2_keywords(*a, &b); end
  def run(*args, &block); end
  def skip(*a, &b); end
  def skipped?(*a, &b); end
  def source_location(*a, &b); end
  def to_proc; end
  def update_inherited_metadata(*a, &b); end
  def wrap(&block); end
  def yield(*a, &b); end
end

class RSpec::Core::ExampleGroup
  include ::RSpec::Core::MemoizedHelpers
  include ::RSpec::Core::Pending
  extend ::RSpec::Core::Hooks
  extend ::RSpec::Core::MemoizedHelpers::ClassMethods
  extend ::RSpec::Core::SharedExampleGroup

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

  def described_class; end
  def inspect; end

  private

  def method_missing(name, *args, **_arg2); end

  class << self
    def add_example(example); end
    def before_context_ivars; end
    def children; end
    def context(*args, &example_group_block); end
    def currently_executing_a_context_hook?; end
    def declaration_locations; end
    def define_example_group_method(name, metadata = T.unsafe(nil)); end
    def define_example_method(name, extra_options = T.unsafe(nil)); end
    def define_nested_shared_group_method(new_name, report_label = T.unsafe(nil)); end
    def delegate_to_metadata(*names); end
    def descendant_filtered_examples; end
    def descendants; end
    def describe(*args, &example_group_block); end
    def described_class; end
    def description; end
    def each_instance_variable_for_example(group); end
    def ensure_example_groups_are_configured; end
    def example(*all_args, &block); end
    def example_group(*args, &example_group_block); end
    def examples; end
    def fcontext(*args, &example_group_block); end
    def fdescribe(*args, &example_group_block); end
    def fexample(*all_args, &block); end
    def file_path; end
    def filtered_examples; end
    def find_and_eval_shared(label, name, inclusion_location, *args, &customization_block); end
    def fit(*all_args, &block); end
    def focus(*all_args, &block); end
    def for_filtered_examples(reporter, &block); end
    def fspecify(*all_args, &block); end
    def id; end
    def idempotently_define_singleton_method(name, &definition); end
    def include_context(name, *args, &block); end
    def include_examples(name, *args, &block); end
    def it(*all_args, &block); end
    def it_behaves_like(name, *args, &customization_block); end
    def it_should_behave_like(name, *args, &customization_block); end
    def location; end
    def metadata; end
    def next_runnable_index_for(file); end
    def ordering_strategy; end
    def parent_groups; end
    def pending(*all_args, &block); end
    def remove_example(example); end
    def reset_memoized; end
    def run(reporter = T.unsafe(nil)); end
    def run_after_context_hooks(example_group_instance); end
    def run_before_context_hooks(example_group_instance); end
    def run_examples(reporter); end
    def set_it_up(description, args, registration_collection, &example_group_block); end
    def set_ivars(instance, ivars); end
    def skip(*all_args, &block); end
    def specify(*all_args, &block); end
    def store_before_context_ivars(example_group_instance); end
    def subclass(parent, description, args, registration_collection, &example_group_block); end
    def superclass_before_context_ivars; end
    def superclass_metadata; end
    def top_level?; end
    def top_level_description; end
    def traverse_tree_until(&block); end
    def update_inherited_metadata(updates); end
    def with_replaced_metadata(meta); end
    def xcontext(*args, &example_group_block); end
    def xdescribe(*args, &example_group_block); end
    def xexample(*all_args, &block); end
    def xit(*all_args, &block); end
    def xspecify(*all_args, &block); end

    private

    def method_missing(name, *args); end
  end
end

RSpec::Core::ExampleGroup::INSTANCE_VARIABLE_TO_IGNORE = T.let(T.unsafe(nil), Symbol)
class RSpec::Core::ExampleGroup::WrongScopeError < ::NoMethodError; end

class RSpec::Core::ExampleStatusDumper
  def initialize(examples); end

  def dump; end

  private

  def column_widths; end
  def formatted_header_rows; end
  def formatted_row_from(row_values); end
  def formatted_value_rows; end
  def headers; end
  def rows; end

  class << self
    def dump(examples); end
  end
end

class RSpec::Core::ExampleStatusMerger
  def initialize(this_run, from_previous_runs); end

  def merge; end

  private

  def delete_previous_examples_that_no_longer_exist; end
  def example_must_no_longer_exist?(ex_id); end
  def hash_from(example_list); end
  def loaded_spec_files; end
  def sort_value_from(example); end
  def spec_file_from(ex_id); end

  class << self
    def merge(this_run, from_previous_runs); end
  end
end

class RSpec::Core::ExampleStatusParser
  def initialize(string); end

  def parse; end

  private

  def headers; end
  def parse_row(line); end
  def split_line(line); end

  class << self
    def parse(string); end
  end
end

class RSpec::Core::ExampleStatusPersister
  def initialize(examples, file_name); end

  def persist; end

  private

  def dump_statuses(unparsed_previous_runs); end
  def statuses_from_this_run; end

  class << self
    def load_from(file_name); end
    def persist(examples, file_name); end
  end
end

RSpec::Core::ExclusionRules = RSpec::Core::FilterRules

class RSpec::Core::FilterManager
  def initialize; end

  def add_ids(rerun_path, scoped_ids); end
  def add_location(file_path, line_numbers); end
  def empty?; end
  def exclude(*args); end
  def exclude_only(*args); end
  def exclude_with_low_priority(*args); end
  def exclusions; end
  def include(*args); end
  def include_only(*args); end
  def include_with_low_priority(*args); end
  def inclusions; end
  def prune(examples); end

  private

  def add_path_to_arrays_filter(filter_key, path, values); end
  def file_scoped_include?(ex_metadata, ids, locations); end
  def prune_conditionally_filtered_examples(examples); end
end

class RSpec::Core::FilterRules
  def initialize(rules = T.unsafe(nil)); end

  def [](key); end
  def add(updated); end
  def add_with_low_priority(updated); end
  def clear; end
  def delete(key); end
  def description; end
  def each_pair(&block); end
  def empty?; end
  def fetch(*args, &block); end
  def include_example?(example); end
  def opposite; end
  def opposite=(_arg0); end
  def rules; end
  def use_only(updated); end

  class << self
    def build; end
  end
end

RSpec::Core::FilterRules::PROC_HEX_NUMBER = T.let(T.unsafe(nil), Regexp)
RSpec::Core::FilterRules::PROJECT_DIR = T.let(T.unsafe(nil), String)
module RSpec::Core::FilterableItemRepository; end

class RSpec::Core::FilterableItemRepository::QueryOptimized < ::RSpec::Core::FilterableItemRepository::UpdateOptimized
  def initialize(applies_predicate); end

  def append(item, metadata); end
  def delete(item, metadata); end
  def items_for(metadata); end
  def prepend(item, metadata); end

  private

  def applicable_metadata_from(metadata); end
  def find_items_for(request_meta); end
  def handle_mutation(metadata); end
  def proc_keys_from(metadata); end
  def reconstruct_caches; end
end

class RSpec::Core::FilterableItemRepository::UpdateOptimized
  def initialize(applies_predicate); end

  def append(item, metadata); end
  def delete(item, metadata); end
  def items_and_filters; end
  def items_for(request_meta); end
  def prepend(item, metadata); end
end

module RSpec::Core::FlatMap
  private

  def flat_map(array, &block); end

  class << self
    def flat_map(array, &block); end
  end
end

module RSpec::Core::Formatters
  class << self
    def register(formatter_class, *notifications); end
  end
end

class RSpec::Core::Formatters::BaseFormatter
  def initialize(output); end

  def close(_notification); end
  def example_group; end
  def example_group=(_arg0); end
  def example_group_started(notification); end
  def output; end
  def start(notification); end

  private

  def output_supports_sync; end
  def restore_sync_output; end
  def start_sync_output; end
end

class RSpec::Core::Formatters::BaseTextFormatter < ::RSpec::Core::Formatters::BaseFormatter
  def close(_notification); end
  def dump_failures(notification); end
  def dump_pending(notification); end
  def dump_summary(summary); end
  def message(notification); end
  def seed(notification); end
end

module RSpec::Core::Formatters::ConsoleCodes
  private

  def config_colors_to_methods; end
  def console_code_for(code_or_symbol); end
  def wrap(text, code_or_symbol); end

  class << self
    def config_colors_to_methods; end
    def console_code_for(code_or_symbol); end
    def wrap(text, code_or_symbol); end
  end
end

RSpec::Core::Formatters::ConsoleCodes::VT100_CODES = T.let(T.unsafe(nil), Hash)
RSpec::Core::Formatters::ConsoleCodes::VT100_CODE_VALUES = T.let(T.unsafe(nil), Hash)

class RSpec::Core::Formatters::DeprecationFormatter
  def initialize(deprecation_stream, summary_stream); end

  def count; end
  def deprecation(notification); end
  def deprecation_message_for(data); end
  def deprecation_stream; end
  def deprecation_summary(_notification); end
  def output; end
  def printer; end
  def summary_stream; end
end

RSpec::Core::Formatters::DeprecationFormatter::DEPRECATION_STREAM_NOTICE = T.let(T.unsafe(nil), String)

class RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter
  def initialize(deprecation_stream, summary_stream, deprecation_formatter); end

  def deprecation_formatter; end
  def deprecation_stream; end
  def deprecation_summary; end
  def print_deferred_deprecation_warnings; end
  def print_deprecation_message(data); end
  def stash_deprecation_message(deprecation_message); end
  def summary_stream; end
end

RSpec::Core::Formatters::DeprecationFormatter::DelayedPrinter::TOO_MANY_USES_LIMIT = T.let(T.unsafe(nil), Integer)

class RSpec::Core::Formatters::DeprecationFormatter::FileStream
  def initialize(file); end

  def puts(*args); end
  def summarize(summary_stream, deprecation_count); end
end

class RSpec::Core::Formatters::DeprecationFormatter::GeneratedDeprecationMessage < ::Struct
  def initialize(data); end

  def to_s; end
  def too_many_warnings_message; end
  def type; end
  def type=(_); end

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

class RSpec::Core::Formatters::DeprecationFormatter::ImmediatePrinter
  def initialize(deprecation_stream, summary_stream, deprecation_formatter); end

  def deprecation_formatter; end
  def deprecation_stream; end
  def deprecation_summary; end
  def print_deprecation_message(data); end
  def summary_stream; end
end

RSpec::Core::Formatters::DeprecationFormatter::RAISE_ERROR_CONFIG_NOTICE = T.let(T.unsafe(nil), String)

class RSpec::Core::Formatters::DeprecationFormatter::RaiseErrorStream
  def puts(message); end
  def summarize(summary_stream, deprecation_count); end
end

class RSpec::Core::Formatters::DeprecationFormatter::SpecifiedDeprecationMessage < ::Struct
  def initialize(data); end

  def to_s; end
  def too_many_warnings_message; end
  def type; end
  def type=(_); end

  private

  def deprecation_type_for(data); end
  def output_formatted(str); end

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

RSpec::Core::Formatters::DeprecationFormatter::TOO_MANY_WARNINGS_NOTICE = T.let(T.unsafe(nil), String)

class RSpec::Core::Formatters::DocumentationFormatter < ::RSpec::Core::Formatters::BaseTextFormatter
  def initialize(output); end

  def example_failed(failure); end
  def example_group_finished(_notification); end
  def example_group_started(notification); end
  def example_passed(passed); end
  def example_pending(pending); end
  def example_started(_notification); end
  def message(notification); end

  private

  def current_indentation(offset = T.unsafe(nil)); end
  def failure_output(example); end
  def flush_messages; end
  def next_failure_index; end
  def passed_output(example); end
  def pending_output(example, message); end
end

class RSpec::Core::Formatters::ExceptionPresenter
  def initialize(exception, example, options = T.unsafe(nil)); end

  def colorized_formatted_backtrace(colorizer = T.unsafe(nil)); end
  def colorized_message_lines(colorizer = T.unsafe(nil)); end
  def description; end
  def example; end
  def exception; end
  def formatted_backtrace(exception = T.unsafe(nil)); end
  def formatted_cause(exception); end
  def fully_formatted(failure_number, colorizer = T.unsafe(nil)); end
  def fully_formatted_lines(failure_number, colorizer); end
  def message_lines; end

  private

  def add_shared_group_lines(lines, colorizer); end
  def backtrace_formatter; end
  def detail_formatter; end
  def encoded_description(description); end
  def encoded_string(string); end
  def encoding_of(string); end
  def exception_backtrace; end
  def exception_class_name(exception = T.unsafe(nil)); end
  def exception_lines; end
  def exception_message_string(exception); end
  def extra_detail_formatter; end
  def extra_failure_lines; end
  def failure_lines; end
  def failure_slash_error_lines; end
  def final_exception(exception, previous = T.unsafe(nil)); end
  def find_failed_line; end
  def formatted_message_and_backtrace(colorizer); end
  def indent_lines(lines, failure_number); end
  def message_color; end
  def read_failed_lines; end
end

class RSpec::Core::Formatters::ExceptionPresenter::Factory
  def initialize(example); end

  def build; end

  private

  def multiple_exception_summarizer(exception, prior_detail_formatter, color); end
  def multiple_exceptions_error?(exception); end
  def options; end
  def pending_options; end
  def sub_failure_list_formatter(exception, message_color); end
  def with_multiple_error_options_as_needed(exception, options); end
end

class RSpec::Core::Formatters::ExceptionPresenter::Factory::CommonBacktraceTruncater
  def initialize(parent); end

  def with_truncated_backtrace(child); end
end

module RSpec::Core::Formatters::ExceptionPresenter::Factory::EmptyBacktraceFormatter
  class << self
    def format_backtrace(*_arg0); end
  end
end

RSpec::Core::Formatters::ExceptionPresenter::PENDING_DETAIL_FORMATTER = T.let(T.unsafe(nil), Proc)

class RSpec::Core::Formatters::FailureListFormatter < ::RSpec::Core::Formatters::BaseFormatter
  def dump_profile(_profile); end
  def example_failed(failure); end
  def message(_message); end
end

class RSpec::Core::Formatters::FallbackMessageFormatter
  def initialize(output); end

  def message(notification); end
  def output; end
end

module RSpec::Core::Formatters::Helpers
  class << self
    def format_duration(duration); end
    def format_seconds(float, precision = T.unsafe(nil)); end
    def organize_ids(ids); end
    def pluralize(count, string); end

    private

    def strip_trailing_zeroes(string); end
  end
end

RSpec::Core::Formatters::Helpers::DEFAULT_PRECISION = T.let(T.unsafe(nil), Integer)
RSpec::Core::Formatters::Helpers::SUB_SECOND_PRECISION = T.let(T.unsafe(nil), Integer)

class RSpec::Core::Formatters::HtmlFormatter < ::RSpec::Core::Formatters::BaseFormatter
  def initialize(output); end

  def dump_summary(summary); end
  def example_failed(failure); end
  def example_group_started(notification); end
  def example_passed(passed); end
  def example_pending(pending); end
  def example_started(_notification); end
  def start(notification); end
  def start_dump(_notification); end

  private

  def example_group_number; end
  def example_number; end
  def extra_failure_content(failure); end
  def percent_done; end
end

class RSpec::Core::Formatters::HtmlPrinter
  include ::ERB::Escape
  include ::ERB::Util

  def initialize(output); end

  def flush; end
  def make_example_group_header_red(group_id); end
  def make_example_group_header_yellow(group_id); end
  def make_header_red; end
  def make_header_yellow; end
  def move_progress(percent_done); end
  def print_example_failed(pending_fixed, description, run_time, failure_id, exception, extra_content); end
  def print_example_group_end; end
  def print_example_group_start(group_id, description, number_of_parents); end
  def print_example_passed(description, run_time); end
  def print_example_pending(description, pending_message); end
  def print_html_start; end
  def print_summary(duration, example_count, failure_count, pending_count); end

  private

  def indentation_style(number_of_parents); end
end

RSpec::Core::Formatters::HtmlPrinter::GLOBAL_SCRIPTS = T.let(T.unsafe(nil), String)
RSpec::Core::Formatters::HtmlPrinter::GLOBAL_STYLES = T.let(T.unsafe(nil), String)
RSpec::Core::Formatters::HtmlPrinter::HTML_HEADER = T.let(T.unsafe(nil), String)
RSpec::Core::Formatters::HtmlPrinter::REPORT_HEADER = T.let(T.unsafe(nil), String)

class RSpec::Core::Formatters::JsonFormatter < ::RSpec::Core::Formatters::BaseFormatter
  def initialize(output); end

  def close(_notification); end
  def dump_profile(profile); end
  def dump_profile_slowest_example_groups(profile); end
  def dump_profile_slowest_examples(profile); end
  def dump_summary(summary); end
  def message(notification); end
  def output_hash; end
  def seed(notification); end
  def stop(group_notification); end

  private

  def format_example(example); end
end

class RSpec::Core::Formatters::Loader
  def initialize(reporter); end

  def add(formatter_to_use, *paths); end
  def default_formatter; end
  def default_formatter=(_arg0); end
  def formatters; end
  def prepare_default(output_stream, deprecation_stream); end
  def reporter; end
  def setup_default(output_stream, deprecation_stream); end

  private

  def built_in_formatter(key); end
  def custom_formatter(formatter_ref); end
  def duplicate_formatter_exists?(new_formatter); end
  def existing_formatter_implements?(notification); end
  def find_formatter(formatter_to_use); end
  def has_matching_output?(formatter, new_formatter); end
  def notifications_for(formatter_class); end
  def open_stream(path_or_wrapper); end
  def path_for(const_ref); end
  def register(formatter, notifications); end
  def string_const?(str); end
  def underscore(camel_cased_word); end
  def underscore_with_fix_for_non_standard_rspec_naming(string); end

  class << self
    def formatters; end
  end
end

class RSpec::Core::Formatters::ProfileFormatter
  def initialize(output); end

  def dump_profile(profile); end
  def output; end

  private

  def bold(text); end
  def dump_profile_slowest_example_groups(profile); end
  def dump_profile_slowest_examples(profile); end
  def format_caller(caller_info); end
end

class RSpec::Core::Formatters::ProgressFormatter < ::RSpec::Core::Formatters::BaseTextFormatter
  def example_failed(_notification); end
  def example_passed(_notification); end
  def example_pending(_notification); end
  def start_dump(_notification); end
end

class RSpec::Core::Formatters::SnippetExtractor
  def initialize(source, beginning_line_number, max_line_count = T.unsafe(nil)); end

  def beginning_line_number; end
  def expression_lines; end
  def max_line_count; end
  def source; end

  private

  def expression_node; end
  def expression_outmost_node?(node); end
  def line_range_of_expression; end
  def line_range_of_location_nodes_in_expression; end
  def location_nodes_at_beginning_line; end
  def unclosed_tokens_in_line_range(line_range); end

  class << self
    def extract_expression_lines_at(file_path, beginning_line_number, max_line_count = T.unsafe(nil)); end
    def extract_line_at(file_path, line_number); end
    def least_indentation_from(lines); end
    def source_from_file(path); end
  end
end

class RSpec::Core::Formatters::SnippetExtractor::NoExpressionAtLineError < ::StandardError; end
class RSpec::Core::Formatters::SnippetExtractor::NoSuchFileError < ::StandardError; end
class RSpec::Core::Formatters::SnippetExtractor::NoSuchLineError < ::StandardError; end

class RSpec::Core::Formatters::SyntaxHighlighter
  def initialize(configuration); end

  def highlight(lines); end

  private

  def color_enabled_implementation; end
  def implementation; end

  class << self
    def attempt_to_add_rspec_terms_to_coderay_keywords; end
  end
end

module RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation
  class << self
    def highlight_syntax(lines); end
  end
end

RSpec::Core::Formatters::SyntaxHighlighter::CodeRayImplementation::RESET_CODE = T.let(T.unsafe(nil), String)

module RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation
  class << self
    def highlight_syntax(lines); end
  end
end

RSpec::Core::Formatters::SyntaxHighlighter::WindowsImplementation = RSpec::Core::Formatters::SyntaxHighlighter::NoSyntaxHighlightingImplementation

module RSpec::Core::HashImitatable
  mixes_in_class_methods ::RSpec::Core::HashImitatable::ClassMethods

  def <(*args, &block); end
  def <=(*args, &block); end
  def >(*args, &block); end
  def >=(*args, &block); end
  def [](key); end
  def []=(key, value); end
  def all?(*args, &block); end
  def any?(*args, &block); end
  def assoc(*args, &block); end
  def chain(*args, &block); end
  def chunk(*args, &block); end
  def chunk_while(*args, &block); end
  def clear(*args, &block); end
  def collect(*args, &block); end
  def collect_concat(*args, &block); end
  def compact(*args, &block); end
  def compact!(*args, &block); end
  def compare_by_identity(*args, &block); end
  def compare_by_identity?(*args, &block); end
  def count(*args, &block); end
  def cycle(*args, &block); end
  def deconstruct_keys(*args, &block); end
  def default(*args, &block); end
  def default=(*args, &block); end
  def default_proc(*args, &block); end
  def default_proc=(*args, &block); end
  def delete(*args, &block); end
  def delete_if(*args, &block); end
  def detect(*args, &block); end
  def dig(*args, &block); end
  def drop(*args, &block); end
  def drop_while(*args, &block); end
  def each(*args, &block); end
  def each_cons(*args, &block); end
  def each_entry(*args, &block); end
  def each_key(*args, &block); end
  def each_pair(*args, &block); end
  def each_slice(*args, &block); end
  def each_value(*args, &block); end
  def each_with_index(*args, &block); end
  def each_with_object(*args, &block); end
  def empty?(*args, &block); end
  def entries(*args, &block); end
  def except(*args, &block); end
  def fetch(*args, &block); end
  def fetch_values(*args, &block); end
  def filter(*args, &block); end
  def filter!(*args, &block); end
  def filter_map(*args, &block); end
  def find(*args, &block); end
  def find_all(*args, &block); end
  def find_index(*args, &block); end
  def first(*args, &block); end
  def flat_map(*args, &block); end
  def flatten(*args, &block); end
  def grep(*args, &block); end
  def grep_v(*args, &block); end
  def group_by(*args, &block); end
  def has_key?(*args, &block); end
  def has_value?(*args, &block); end
  def include?(*args, &block); end
  def inject(*args, &block); end
  def invert(*args, &block); end
  def keep_if(*args, &block); end
  def key(*args, &block); end
  def key?(*args, &block); end
  def keys(*args, &block); end
  def lazy(*args, &block); end
  def length(*args, &block); end
  def map(*args, &block); end
  def max(*args, &block); end
  def max_by(*args, &block); end
  def member?(*args, &block); end
  def merge(*args, &block); end
  def merge!(*args, &block); end
  def min(*args, &block); end
  def min_by(*args, &block); end
  def minmax(*args, &block); end
  def minmax_by(*args, &block); end
  def none?(*args, &block); end
  def one?(*args, &block); end
  def partition(*args, &block); end
  def rassoc(*args, &block); end
  def reduce(*args, &block); end
  def rehash(*args, &block); end
  def reject(*args, &block); end
  def reject!(*args, &block); end
  def replace(*args, &block); end
  def reverse_each(*args, &block); end
  def select(*args, &block); end
  def select!(*args, &block); end
  def shift(*args, &block); end
  def size(*args, &block); end
  def slice(*args, &block); end
  def slice_after(*args, &block); end
  def slice_before(*args, &block); end
  def slice_when(*args, &block); end
  def sort(*args, &block); end
  def sort_by(*args, &block); end
  def store(*args, &block); end
  def sum(*args, &block); end
  def take(*args, &block); end
  def take_while(*args, &block); end
  def tally(*args, &block); end
  def to_a(*args, &block); end
  def to_h; end
  def to_hash(*args, &block); end
  def to_proc(*args, &block); end
  def to_set(*args, &block); end
  def transform_keys(*args, &block); end
  def transform_keys!(*args, &block); end
  def transform_values(*args, &block); end
  def transform_values!(*args, &block); end
  def uniq(*args, &block); end
  def update(*args, &block); end
  def value?(*args, &block); end
  def values(*args, &block); end
  def values_at(*args, &block); end
  def zip(*args, &block); end

  private

  def directly_supports_attribute?(name); end
  def extra_hash_attributes; end
  def get_value(name); end
  def hash_for_delegation; end
  def issue_deprecation(_method_name, *_args); end
  def set_value(name, value); end

  class << self
    def included(klass); end
  end
end

module RSpec::Core::HashImitatable::ClassMethods
  def attr_accessor(*names); end
  def hash_attribute_names; end
end

module RSpec::Core::Hooks
  def after(*args, &block); end
  def append_after(*args, &block); end
  def append_before(*args, &block); end
  def around(*args, &block); end
  def before(*args, &block); end
  def hooks; end
  def prepend_after(*args, &block); end
  def prepend_before(*args, &block); end
end

class RSpec::Core::Hooks::AfterContextHook < ::RSpec::Core::Hooks::Hook
  def run(example); end
end

class RSpec::Core::Hooks::AfterHook < ::RSpec::Core::Hooks::Hook
  def run(example); end
end

class RSpec::Core::Hooks::AroundHook < ::RSpec::Core::Hooks::Hook
  def execute_with(example, procsy); end
  def hook_description; end
end

class RSpec::Core::Hooks::BeforeHook < ::RSpec::Core::Hooks::Hook
  def run(example); end
end

class RSpec::Core::Hooks::Hook < ::Struct
  def block; end
  def block=(_); end
  def options; end
  def options=(_); end

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

class RSpec::Core::Hooks::HookCollections
  def initialize(owner, filterable_item_repo_class); end

  def register(prepend_or_append, position, *args, &block); end
  def register_global_singleton_context_hooks(example, globals); end
  def register_globals(host, globals); end
  def run(position, scope, example_or_group); end

  protected

  def all_hooks_for(position, scope); end
  def matching_hooks_for(position, scope, example_or_group); end
  def processable_hooks_for(position, scope, host); end
  def run_owned_hooks_for(position, scope, example_or_group); end

  private

  def ensure_hooks_initialized_for(position, scope); end
  def extract_scope_from(args); end
  def hooks_for(position, scope); end
  def known_scope?(scope); end
  def normalized_scope_for(scope); end
  def owner_parent_groups; end
  def process(host, parent_groups, globals, position, scope); end
  def run_around_example_hooks_for(example); end
  def run_example_hooks_for(example, position, each_method); end
  def scope_and_options_from(*args); end
end

RSpec::Core::Hooks::HookCollections::EMPTY_HOOK_ARRAY = T.let(T.unsafe(nil), Array)
RSpec::Core::Hooks::HookCollections::HOOK_TYPES = T.let(T.unsafe(nil), Hash)
RSpec::Core::Hooks::HookCollections::SCOPES = T.let(T.unsafe(nil), Array)
RSpec::Core::Hooks::HookCollections::SCOPE_ALIASES = T.let(T.unsafe(nil), Hash)

class RSpec::Core::InclusionRules < ::RSpec::Core::FilterRules
  def add(*args); end
  def add_with_low_priority(*args); end
  def include_example?(example); end
  def split_file_scoped_rules; end
  def standalone?; end

  private

  def apply_standalone_filter(updated); end
  def is_standalone_filter?(rules); end
  def replace_filters(new_rules); end
end

module RSpec::Core::Invocations; end

class RSpec::Core::Invocations::Bisect
  def call(options, err, out); end

  private

  def bisect_formatter_klass_for(argument); end
end

class RSpec::Core::Invocations::DRbWithFallback
  def call(options, err, out); end
end

class RSpec::Core::Invocations::InitializeProject
  def call(*_args); end
end

class RSpec::Core::Invocations::PrintHelp < ::Struct
  def call(_options, _err, out); end
  def hidden_options; end
  def hidden_options=(_); end
  def parser; end
  def parser=(_); end

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

class RSpec::Core::Invocations::PrintVersion
  def call(_options, _err, out); end
end

class RSpec::Core::LegacyExampleGroupHash
  include ::RSpec::Core::HashImitatable
  extend ::RSpec::Core::HashImitatable::ClassMethods

  def initialize(metadata); end

  def to_h; end

  private

  def directly_supports_attribute?(name); end
  def get_value(name); end
  def set_value(name, value); end
end

module RSpec::Core::MemoizedHelpers
  def initialize(*_arg0); end

  def is_expected; end
  def should(matcher = T.unsafe(nil), message = T.unsafe(nil)); end
  def should_not(matcher = T.unsafe(nil), message = T.unsafe(nil)); end
  def subject; end

  private

  def __init_memoized; end
  def __memoized; end
  def enforce_value_expectation(matcher, method_name); end
  def matcher_supports_value_expectations?(matcher); end

  class << self
    def define_helpers_on(example_group); end
    def get_constant_or_yield(example_group, name); end
    def module_for(example_group); end
  end
end

module RSpec::Core::MemoizedHelpers::ClassMethods
  def let(name, &block); end
  def let!(name, &block); end
  def subject(name = T.unsafe(nil), &block); end
  def subject!(name = T.unsafe(nil), &block); end
end

class RSpec::Core::MemoizedHelpers::ContextHookMemoized
  class << self
    def fetch_or_store(key, &_block); end
    def isolate_for_context_hook(example_group_instance); end
  end
end

class RSpec::Core::MemoizedHelpers::ContextHookMemoized::After < ::RSpec::Core::MemoizedHelpers::ContextHookMemoized
  class << self
    def article; end
    def hook_expression; end
    def hook_intention; end
  end
end

class RSpec::Core::MemoizedHelpers::ContextHookMemoized::Before < ::RSpec::Core::MemoizedHelpers::ContextHookMemoized
  class << self
    def article; end
    def hook_expression; end
    def hook_intention; end
  end
end

class RSpec::Core::MemoizedHelpers::NonThreadSafeMemoized
  def initialize; end

  def fetch_or_store(key); end
end

class RSpec::Core::MemoizedHelpers::ThreadsafeMemoized
  def initialize; end

  def fetch_or_store(key); end
end

module RSpec::Core::Metadata
  class << self
    def ascend(metadata); end
    def ascending(metadata); end
    def build_hash_from(args, warn_about_example_group_filtering = T.unsafe(nil)); end
    def deep_hash_dup(object); end
    def id_from(metadata); end
    def location_tuple_from(metadata); end
    def relative_path(line); end
    def relative_path_regex; end
  end
end

class RSpec::Core::Metadata::ExampleGroupHash < ::RSpec::Core::Metadata::HashPopulator
  private

  def described_class; end
  def full_description; end

  class << self
    def backwards_compatibility_default_proc(&example_group_selector); end
    def create(parent_group_metadata, user_metadata, example_group_index, *args, &block); end
    def hash_with_backwards_compatibility_default_proc; end
  end
end

class RSpec::Core::Metadata::ExampleHash < ::RSpec::Core::Metadata::HashPopulator
  private

  def described_class; end
  def full_description; end

  class << self
    def create(group_metadata, user_metadata, index_provider, description, block); end
  end
end

class RSpec::Core::Metadata::HashPopulator
  def initialize(metadata, user_metadata, index_provider, description_args, block); end

  def block; end
  def description_args; end
  def metadata; end
  def populate; end
  def user_metadata; end

  private

  def build_description_from(parent_description = T.unsafe(nil), my_description = T.unsafe(nil)); end
  def build_scoped_id_for(file_path); end
  def description_separator(parent_part, child_part); end
  def ensure_valid_user_keys; end
  def file_path_and_line_number_from(backtrace); end
  def populate_location_attributes; end
end

RSpec::Core::Metadata::RESERVED_KEYS = T.let(T.unsafe(nil), Array)

module RSpec::Core::MetadataFilter
  class << self
    def apply?(predicate, filters, metadata); end
    def filter_applies?(key, filter_value, metadata); end
    def silence_metadata_example_group_deprecations; end

    private

    def filter_applies_to_any_value?(key, value, metadata); end
    def filters_apply?(key, value, metadata); end
    def id_filter_applies?(rerun_paths_to_scoped_ids, metadata); end
    def location_filter_applies?(locations, metadata); end
    def proc_filter_applies?(key, proc, metadata); end
  end
end

class RSpec::Core::MultipleExceptionError < ::StandardError
  include ::RSpec::Core::MultipleExceptionError::InterfaceTag

  def initialize(*exceptions); end

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

module RSpec::Core::MultipleExceptionError::InterfaceTag
  def add(exception); end

  class << self
    def for(ex); end
  end
end

module RSpec::Core::Notifications; end

class RSpec::Core::Notifications::CustomNotification < ::Struct
  class << self
    def for(options = T.unsafe(nil)); end
  end
end

class RSpec::Core::Notifications::DeprecationNotification < ::Struct
  def call_site; end
  def call_site=(_); end
  def deprecated; end
  def deprecated=(_); end
  def message; end
  def message=(_); end
  def replacement; end
  def replacement=(_); end

  class << self
    def [](*_arg0); end
    def from_hash(data); end
    def inspect; end
    def keyword_init?; end
    def members; end

    private

    def new(*_arg0); end
  end
end

class RSpec::Core::Notifications::ExampleNotification < ::Struct
  def example; end
  def example=(_); end

  class << self
    def [](*_arg0); end
    def for(example); end
    def inspect; end
    def keyword_init?; end
    def members; end

    private

    def new(*_arg0); end
  end
end

class RSpec::Core::Notifications::ExamplesNotification
  def initialize(reporter); end

  def examples; end
  def failed_examples; end
  def failure_notifications; end
  def fully_formatted_failed_examples(colorizer = T.unsafe(nil)); end
  def fully_formatted_pending_examples(colorizer = T.unsafe(nil)); end
  def notifications; end
  def pending_examples; end
  def pending_notifications; end

  private

  def format_examples(examples); end
end

class RSpec::Core::Notifications::FailedExampleNotification < ::RSpec::Core::Notifications::ExampleNotification
  def initialize(example, exception_presenter = T.unsafe(nil)); end

  def colorized_formatted_backtrace(colorizer = T.unsafe(nil)); end
  def colorized_message_lines(colorizer = T.unsafe(nil)); end
  def description; end
  def exception; end
  def formatted_backtrace; end
  def fully_formatted(failure_number, colorizer = T.unsafe(nil)); end
  def fully_formatted_lines(failure_number, colorizer = T.unsafe(nil)); end
  def message_lines; end

  class << self
    def new(*_arg0); end
  end
end

class RSpec::Core::Notifications::GroupNotification < ::Struct
  def group; end
  def group=(_); end

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

class RSpec::Core::Notifications::MessageNotification < ::Struct
  def message; end
  def message=(_); end

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

module RSpec::Core::Notifications::NullColorizer
  private

  def wrap(line, _code_or_symbol); end

  class << self
    def wrap(line, _code_or_symbol); end
  end
end

class RSpec::Core::Notifications::NullNotification; end
class RSpec::Core::Notifications::PendingExampleFailedAsExpectedNotification < ::RSpec::Core::Notifications::FailedExampleNotification; end
class RSpec::Core::Notifications::PendingExampleFixedNotification < ::RSpec::Core::Notifications::FailedExampleNotification; end

class RSpec::Core::Notifications::ProfileNotification
  def initialize(duration, examples, number_of_examples, example_groups); end

  def duration; end
  def examples; end
  def number_of_examples; end
  def percentage; end
  def slow_duration; end
  def slowest_examples; end
  def slowest_groups; end

  private

  def calculate_slowest_groups; end
end

class RSpec::Core::Notifications::SeedNotification < ::Struct
  def fully_formatted; end
  def seed; end
  def seed=(_); end
  def seed_used?; end
  def used=(_); end

  private

  def used; end

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

class RSpec::Core::Notifications::SkippedExampleNotification < ::RSpec::Core::Notifications::ExampleNotification
  def fully_formatted(pending_number, colorizer = T.unsafe(nil)); end

  class << self
    def new(*_arg0); end
  end
end

class RSpec::Core::Notifications::StartNotification < ::Struct
  def count; end
  def count=(_); end
  def load_time; end
  def load_time=(_); end

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

class RSpec::Core::Notifications::SummaryNotification < ::Struct
  include ::RSpec::Core::ShellEscape

  def colorized_rerun_commands(colorizer = T.unsafe(nil)); end
  def colorized_totals_line(colorizer = T.unsafe(nil)); end
  def duration; end
  def duration=(_); end
  def errors_outside_of_examples_count; end
  def errors_outside_of_examples_count=(_); end
  def example_count; end
  def examples; end
  def examples=(_); end
  def failed_examples; end
  def failed_examples=(_); end
  def failure_count; end
  def formatted_duration; end
  def formatted_load_time; end
  def fully_formatted(colorizer = T.unsafe(nil)); end
  def load_time; end
  def load_time=(_); end
  def pending_count; end
  def pending_examples; end
  def pending_examples=(_); end
  def totals_line; end

  private

  def duplicate_rerun_locations; end
  def rerun_argument_for(example); end

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

class RSpec::Core::NullReporter
  class << self
    private

    def method_missing(*_arg0); end
  end
end

module RSpec::Core::Ordering; end

class RSpec::Core::Ordering::ConfigurationManager
  def initialize; end

  def force(hash); end
  def order=(type); end
  def ordering_registry; end
  def register_ordering(name, strategy = T.unsafe(nil)); end
  def seed; end
  def seed=(seed); end
  def seed_used?; end
end

class RSpec::Core::Ordering::Custom
  def initialize(callable); end

  def order(list); end
end

class RSpec::Core::Ordering::Delayed
  def initialize(registry, name); end

  def order(list); end

  private

  def lookup_strategy; end
  def strategy; end
end

class RSpec::Core::Ordering::Identity
  def order(items); end
end

class RSpec::Core::Ordering::Random
  def initialize(configuration); end

  def order(items); end
  def used?; end

  private

  def jenkins_hash_digest(string); end
end

RSpec::Core::Ordering::Random::MAX_32_BIT = T.let(T.unsafe(nil), Integer)

class RSpec::Core::Ordering::RecentlyModified
  def order(list); end
end

class RSpec::Core::Ordering::Registry
  def initialize(configuration); end

  def fetch(name, &fallback); end
  def has_strategy?(name); end
  def register(sym, strategy); end
  def used_random_seed?; end
end

class RSpec::Core::OutputWrapper
  def initialize(output); end

  def <<(*args, &block); end
  def advise(*args, &block); end
  def autoclose=(*args, &block); end
  def autoclose?(*args, &block); end
  def beep(*args, &block); end
  def binmode(*args, &block); end
  def binmode?(*args, &block); end
  def check_winsize_changed(*args, &block); end
  def clear_screen(*args, &block); end
  def close(*args, &block); end
  def close_on_exec=(*args, &block); end
  def close_on_exec?(*args, &block); end
  def close_read(*args, &block); end
  def close_write(*args, &block); end
  def closed?(*args, &block); end
  def console_mode(*args, &block); end
  def console_mode=(*args, &block); end
  def cooked(*args, &block); end
  def cooked!(*args, &block); end
  def cursor(*args, &block); end
  def cursor=(*args, &block); end
  def cursor_down(*args, &block); end
  def cursor_left(*args, &block); end
  def cursor_right(*args, &block); end
  def cursor_up(*args, &block); end
  def each(*args, &block); end
  def each_byte(*args, &block); end
  def each_char(*args, &block); end
  def each_codepoint(*args, &block); end
  def each_line(*args, &block); end
  def echo=(*args, &block); end
  def echo?(*args, &block); end
  def eof(*args, &block); end
  def eof?(*args, &block); end
  def erase_line(*args, &block); end
  def erase_screen(*args, &block); end
  def external_encoding(*args, &block); end
  def fcntl(*args, &block); end
  def fdatasync(*args, &block); end
  def fileno(*args, &block); end
  def flush(*args, &block); end
  def fsync(*args, &block); end
  def getbyte(*args, &block); end
  def getc(*args, &block); end
  def getch(*args, &block); end
  def getpass(*args, &block); end
  def gets(*args, &block); end
  def goto(*args, &block); end
  def goto_column(*args, &block); end
  def iflush(*args, &block); end
  def inspect(*args, &block); end
  def internal_encoding(*args, &block); end
  def ioctl(*args, &block); end
  def ioflush(*args, &block); end
  def isatty(*args, &block); end
  def lineno(*args, &block); end
  def lineno=(*args, &block); end
  def method_missing(name, *args, &block); end
  def noecho(*args, &block); end
  def nread(*args, &block); end
  def oflush(*args, &block); end
  def output; end
  def output=(_arg0); end
  def path(*args, &block); end
  def pathconf(*args, &block); end
  def pid(*args, &block); end
  def pos(*args, &block); end
  def pos=(*args, &block); end
  def pread(*args, &block); end
  def pressed?(*args, &block); end
  def print(*args, &block); end
  def printf(*args, &block); end
  def putc(*args, &block); end
  def puts(*args, &block); end
  def pwrite(*args, &block); end
  def raw(*args, &block); end
  def raw!(*args, &block); end
  def read(*args, &block); end
  def read_nonblock(*args, &block); end
  def readbyte(*args, &block); end
  def readchar(*args, &block); end
  def readline(*args, &block); end
  def readlines(*args, &block); end
  def readpartial(*args, &block); end
  def ready?(*args, &block); end
  def reopen(*args, &block); end
  def respond_to?(name, priv = T.unsafe(nil)); end
  def rewind(*args, &block); end
  def scroll_backward(*args, &block); end
  def scroll_forward(*args, &block); end
  def seek(*args, &block); end
  def set_encoding(*args, &block); end
  def set_encoding_by_bom(*args, &block); end
  def stat(*args, &block); end
  def sync(*args, &block); end
  def sync=(*args, &block); end
  def sysread(*args, &block); end
  def sysseek(*args, &block); end
  def syswrite(*args, &block); end
  def tell(*args, &block); end
  def timeout(*args, &block); end
  def timeout=(*args, &block); end
  def to_i(*args, &block); end
  def to_io(*args, &block); end
  def to_path(*args, &block); end
  def tty?(*args, &block); end
  def ttyname(*args, &block); end
  def ungetbyte(*args, &block); end
  def ungetc(*args, &block); end
  def wait(*args, &block); end
  def wait_priority(*args, &block); end
  def wait_readable(*args, &block); end
  def wait_writable(*args, &block); end
  def winsize(*args, &block); end
  def winsize=(*args, &block); end
  def write(*args, &block); end
  def write_nonblock(*args, &block); end
end

class RSpec::Core::Parser
  def initialize(original_args); end

  def original_args; end
  def parse(source = T.unsafe(nil)); end

  private

  def add_tag_filter(options, filter_type, tag_name, value = T.unsafe(nil)); end
  def configure_only_failures(options); end
  def parser(options); end
  def set_fail_fast(options, value); end

  class << self
    def parse(args, source = T.unsafe(nil)); end
  end
end

module RSpec::Core::Pending
  def pending(message = T.unsafe(nil), &_block); end
  def skip(message = T.unsafe(nil)); end

  class << self
    def mark_fixed!(example); end
    def mark_pending!(example, message_or_bool); end
    def mark_skipped!(example, message_or_bool); end
  end
end

RSpec::Core::Pending::NOT_YET_IMPLEMENTED = T.let(T.unsafe(nil), String)
RSpec::Core::Pending::NO_REASON_GIVEN = T.let(T.unsafe(nil), String)
class RSpec::Core::Pending::PendingExampleFixedError < ::StandardError; end

class RSpec::Core::Pending::SkipDeclaredInExample < ::StandardError
  def initialize(argument); end

  def argument; end
end

class RSpec::Core::Profiler
  def initialize; end

  def example_group_finished(notification); end
  def example_group_started(notification); end
  def example_groups; end
  def example_started(notification); end
end

RSpec::Core::Profiler::NOTIFICATIONS = T.let(T.unsafe(nil), Array)

class RSpec::Core::Reporter
  def initialize(configuration); end

  def abort_with(msg, exit_status); end
  def close_after; end
  def deprecation(hash); end
  def example_failed(example); end
  def example_finished(example); end
  def example_group_finished(group); end
  def example_group_started(group); end
  def example_passed(example); end
  def example_pending(example); end
  def example_started(example); end
  def examples; end
  def exit_early(exit_code); end
  def fail_fast_limit_met?; end
  def failed_examples; end
  def finish; end
  def message(message); end
  def notify(event, notification); end
  def notify_non_example_exception(exception, context_description); end
  def pending_examples; end
  def prepare_default(loader, output_stream, deprecation_stream); end
  def publish(event, options = T.unsafe(nil)); end
  def register_listener(listener, *notifications); end
  def registered_listeners(notification); end
  def report(expected_example_count); end
  def start(expected_example_count, time = T.unsafe(nil)); end
  def stop(notification); end

  private

  def close; end
  def ensure_listeners_ready; end
  def mute_profile_output?; end
  def seed_used?; end
end

RSpec::Core::Reporter::RSPEC_NOTIFICATIONS = T.let(T.unsafe(nil), RSpec::Core::Set)

module RSpec::Core::RubyProject
  private

  def add_dir_to_load_path(dir); end
  def add_to_load_path(*dirs); end
  def ascend_until; end
  def determine_root; end
  def find_first_parent_containing(dir); end
  def root; end

  class << self
    def add_dir_to_load_path(dir); end
    def add_to_load_path(*dirs); end
    def ascend_until; end
    def determine_root; end
    def find_first_parent_containing(dir); end
    def root; end
  end
end

class RSpec::Core::Runner
  def initialize(options, configuration = T.unsafe(nil), world = T.unsafe(nil)); end

  def configuration; end
  def configure(err, out); end
  def exit_code(examples_passed = T.unsafe(nil)); end
  def options; end
  def run(err, out); end
  def run_specs(example_groups); end
  def setup(err, out); end
  def world; end

  private

  def persist_example_statuses; end

  class << self
    def autorun; end
    def autorun_disabled?; end
    def disable_autorun!; end
    def handle_interrupt; end
    def installed_at_exit?; end
    def invoke; end
    def perform_at_exit; end
    def run(args, err = T.unsafe(nil), out = T.unsafe(nil)); end
    def running_in_drb?; end
    def trap_interrupt; end
  end
end

class RSpec::Core::Set
  include ::Enumerable

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

  def <<(key); end
  def clear; end
  def delete(key); end
  def each(&block); end
  def empty?; end
  def include?(key); end
  def merge(values); end
end

module RSpec::Core::SharedContext
  def __shared_context_recordings; end
  def after(*args, &block); end
  def append_after(*args, &block); end
  def append_before(*args, &block); end
  def around(*args, &block); end
  def before(*args, &block); end
  def context(*args, &block); end
  def describe(*args, &block); end
  def hooks(*args, &block); end
  def included(group); end
  def let(*args, &block); end
  def let!(*args, &block); end
  def prepend_after(*args, &block); end
  def prepend_before(*args, &block); end
  def subject(*args, &block); end
  def subject!(*args, &block); end

  class << self
    def record(methods); end
  end
end

class RSpec::Core::SharedContext::Recording < ::Struct
  def args; end
  def args=(_); end
  def block; end
  def block=(_); end
  def method_name; end
  def method_name=(_); end
  def playback_onto(group); end

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

module RSpec::Core::SharedExampleGroup
  def shared_context(name, *args, &block); end
  def shared_examples(name, *args, &block); end
  def shared_examples_for(name, *args, &block); end
end

class RSpec::Core::SharedExampleGroup::Registry
  def add(context, name, *metadata_args, &block); end
  def find(lookup_contexts, name); end

  private

  def ensure_block_has_source_location(_block); end
  def formatted_location(block); end
  def legacy_add(context, name, *metadata_args, &block); end
  def shared_example_groups; end
  def valid_name?(candidate); end
  def warn_if_key_taken(context, key, new_block); end
end

module RSpec::Core::SharedExampleGroup::TopLevelDSL
  class << self
    def definitions; end
    def expose_globally!; end
    def exposed_globally?; end
    def remove_globally!; end
  end
end

class RSpec::Core::SharedExampleGroupInclusionStackFrame
  def initialize(shared_group_name, inclusion_location); end

  def description; end
  def formatted_inclusion_location; end
  def inclusion_location; end
  def shared_group_name; end

  class << self
    def current_backtrace; end
    def shared_example_group_inclusions; end
    def with_frame(name, location); end
  end
end

class RSpec::Core::SharedExampleGroupModule < ::Module
  def initialize(description, definition, metadata); end

  def definition; end
  def include_in(klass, inclusion_line, args, customization_block); end
  def included(klass); end
  def inspect; end
  def to_s; end
end

module RSpec::Core::ShellEscape
  private

  def conditionally_quote(id); end
  def escape(shell_command); end
  def quote(argument); end
  def shell_allows_unquoted_ids?; end

  class << self
    def conditionally_quote(id); end
    def escape(shell_command); end
    def quote(argument); end
    def shell_allows_unquoted_ids?; end
  end
end

RSpec::Core::ShellEscape::SHELLS_ALLOWING_UNQUOTED_IDS = T.let(T.unsafe(nil), Array)

class RSpec::Core::SuiteHookContext < ::RSpec::Core::Example
  def initialize(hook_description, reporter); end

  def set_exception(exception); end
end

class RSpec::Core::Time
  class << self
    def now(in: T.unsafe(nil)); end
  end
end

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

module RSpec::Core::Warnings
  def deprecate(deprecated, data = T.unsafe(nil)); end
  def warn_deprecation(message, opts = T.unsafe(nil)); end
  def warn_with(message, options = T.unsafe(nil)); end
end

class RSpec::Core::World
  def initialize(configuration = T.unsafe(nil)); end

  def all_example_groups; end
  def all_examples; end
  def announce_exclusion_filter(announcements); end
  def announce_filters; end
  def announce_inclusion_filter(announcements); end
  def everything_filtered_message; end
  def example_count(groups = T.unsafe(nil)); end
  def example_group_counts_by_spec_file; end
  def example_groups; end
  def exclusion_filter; end
  def filter_manager; end
  def filtered_examples; end
  def inclusion_filter; end
  def non_example_failure; end
  def non_example_failure=(_arg0); end
  def num_example_groups_defined_in(file); end
  def ordered_example_groups; end
  def preceding_declaration_line(absolute_file_name, filter_line); end
  def prepare_example_filtering; end
  def record(example_group); end
  def registered_example_group_files; end
  def report_filter_message(message); end
  def reporter; end
  def reset; end
  def rspec_is_quitting; end
  def rspec_is_quitting=(_arg0); end
  def shared_example_group_registry; end
  def source_from_file(path); end
  def syntax_highlighter; end
  def traverse_example_group_trees_until(&block); end
  def wants_to_quit; end
  def wants_to_quit=(_arg0); end

  private

  def descending_declaration_line_numbers_by_file; end
  def fail_if_config_and_cli_options_invalid; end
end

module RSpec::Core::World::Null
  class << self
    def all_example_groups; end
    def example_groups; end
    def non_example_failure; end
    def non_example_failure=(_); end
    def registered_example_group_files; end
    def traverse_example_group_trees_until(&_block); end
  end
end

module RSpec::ExampleGroups
  extend ::RSpec::Support::RecursiveConstMethods

  class << self
    def assign_const(group); end
    def base_name_for(group); end
    def constant_scope_for(group); end
    def disambiguate(name, const_scope); end
    def remove_all_constants; end
  end
end

RSpec::MODULES_TO_AUTOLOAD = T.let(T.unsafe(nil), Hash)
RSpec::SharedContext = RSpec::Core::SharedContext
