# typed: true

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


module SimpleCov
  extend ::SimpleCov::Configuration

  class << self
    def at_exit_behavior; end
    def clear_result; end
    def collate(result_filenames, profile = T.unsafe(nil), ignore_timeout: T.unsafe(nil), &_arg3); end
    def collating_result?; end
    def coverage_statistics_key(criterion); end
    def defer_to_existing_report?; end
    def existing_report_newer_than_us?; end
    def exit_and_report_previous_error(exit_status); end
    def exit_status_from_exception; end
    def external_at_exit; end
    def external_at_exit=(_arg0); end
    def external_at_exit?; end
    def filtered(files); end
    def final_result_process?; end
    def forked_subprocess?; end
    def grouped(files, groups: T.unsafe(nil)); end
    def install_at_exit_hook; end
    def load_profile(name); end
    def mark_forked_subprocess!; end
    def monotonic_time; end
    def next_subprocess_serial!; end
    def parallel_results_complete?; end
    def parallel_wait_timed_out?(deadline, expected, seen); end
    def pid; end
    def pid=(_arg0); end
    def previous_error?(error_exit_status); end
    def process_result(result); end
    def process_results_and_report_error; end
    def process_start_time; end
    def process_start_time=(_arg0); end
    def ready_to_process_results?; end
    def result; end
    def result?; end
    def result_exit_status(result); end
    def resultset_count_settled?(tracker, count); end
    def round_coverage(coverage); end
    def run_exit_tasks!; end
    def start(profile = T.unsafe(nil), &_arg1); end
    def start_tracking; end
    def subprocess_serial; end
    def wait_for_other_processes; end
    def wait_for_parallel_results(expected, native_wait: T.unsafe(nil)); end
    def warn_about_deferred_report; end
    def warn_about_incomplete_parallel_results(expected, seen); end
    def warn_about_start_in_dot_simplecov; end
    def with_dot_simplecov_autoload; end
    def write_last_run(result); end

    private

    def add_not_loaded_files(result); end
    def build_coverage_limits; end
    def defer_to_minitest_after_run; end
    def discover_unloaded_paths(globs); end
    def grouped_file_set(grouped); end
    def initial_setup(profile, &block); end
    def inject_unloaded_files(result, candidate_paths); end
    def minitest_autorun_pending?; end
    def process_coverage_result(report:); end
    def start_coverage_measurement; end
    def unloaded_file_discovery_globs; end
    def warn_if_jruby_full_trace_disabled; end
  end
end

class SimpleCov::ArrayFilter < ::SimpleCov::Filter
  def initialize(filter_argument); end

  def matches?(source_files_list); end
end

class SimpleCov::BlockFilter < ::SimpleCov::Filter
  def matches?(source_file); end
end

SimpleCov::CRITERION_TO_RUBY_COVERAGE = T.let(T.unsafe(nil), Hash)

module SimpleCov::Color
  private

  def colorize(text, color, enabled: T.unsafe(nil)); end
  def colorize_percent(percent, text = T.unsafe(nil), enabled: T.unsafe(nil)); end
  def enabled?(stream = T.unsafe(nil)); end
  def env_set?(name); end
  def for_percent(percent); end

  class << self
    def colorize(text, color, enabled: T.unsafe(nil)); end
    def colorize_percent(percent, text = T.unsafe(nil), enabled: T.unsafe(nil)); end
    def enabled?(stream = T.unsafe(nil)); end
    def env_set?(name); end
    def for_percent(percent); end
  end
end

SimpleCov::Color::ANSI = T.let(T.unsafe(nil), Hash)
SimpleCov::Color::GREEN_THRESHOLD = T.let(T.unsafe(nil), Integer)
SimpleCov::Color::YELLOW_THRESHOLD = T.let(T.unsafe(nil), Integer)

module SimpleCov::Combine
  private

  def combine(combiner_module, coverage_a, coverage_b); end
  def empty_coverage?(coverage_a, coverage_b); end
  def existing_coverage(coverage_a, coverage_b); end

  class << self
    def combine(combiner_module, coverage_a, coverage_b); end
    def empty_coverage?(coverage_a, coverage_b); end
    def existing_coverage(coverage_a, coverage_b); end
  end
end

module SimpleCov::Combine::BranchesCombiner
  private

  def combine(coverage_a, coverage_b); end
  def merge_branches(target, source); end
  def tuple_identity(tuple); end

  class << self
    def combine(coverage_a, coverage_b); end
    def merge_branches(target, source); end
    def tuple_identity(tuple); end
  end
end

module SimpleCov::Combine::FilesCombiner
  private

  def combine(coverage_a, coverage_b); end
  def executed?(coverage); end
  def reconcile_synthesized(coverage_a, coverage_b); end

  class << self
    def combine(coverage_a, coverage_b); end
    def executed?(coverage); end
    def reconcile_synthesized(coverage_a, coverage_b); end
  end
end

SimpleCov::Combine::FilesCombiner::EMPTY_TABLE = T.let(T.unsafe(nil), Hash)
SimpleCov::Combine::FilesCombiner::NO_SYNTHESIZED = T.let(T.unsafe(nil), Hash)

module SimpleCov::Combine::LinesCombiner
  private

  def combine(coverage_a, coverage_b); end
  def merge_line_coverage(first_val, second_val); end

  class << self
    def combine(coverage_a, coverage_b); end
    def merge_line_coverage(first_val, second_val); end
  end
end

module SimpleCov::Combine::MethodsCombiner
  private

  def combine(coverage_a, coverage_b); end
  def source_identity(key); end

  class << self
    def combine(coverage_a, coverage_b); end
    def source_identity(key); end
  end
end

module SimpleCov::Combine::ResultsCombiner
  private

  def combine(*results); end
  def combine_file_coverage(coverage_a, coverage_b); end
  def combine_result_sets(combined_results, result); end

  class << self
    def combine(*results); end
    def combine_file_coverage(coverage_a, coverage_b); end
    def combine_result_sets(combined_results, result); end
  end
end

module SimpleCov::CommandGuesser
  class << self
    def guess; end
    def original_run_command; end
    def original_run_command=(_arg0); end

    private

    def from_command_line_options; end
    def from_defined_constants; end
    def parallel_data; end
  end
end

module SimpleCov::Configuration
  def active_session?; end
  def add_filter(filter_argument = T.unsafe(nil), &block); end
  def add_group(group_name, filter_argument = T.unsafe(nil), &block); end
  def at_exit(&block); end
  def at_fork(&block); end
  def branch_coverage?; end
  def branch_coverage_supported?; end
  def clear_coverage_criteria; end
  def clear_filters; end
  def color(value = T.unsafe(nil)); end
  def command_name(name = T.unsafe(nil)); end
  def configure(&block); end
  def cover(*args, &block); end
  def cover_filters; end
  def cover_globs; end
  def coverage(criterion, primary: T.unsafe(nil), enabled: T.unsafe(nil), oneshot: T.unsafe(nil), **thresholds, &block); end
  def coverage_criteria; end
  def coverage_criterion_enabled?(criterion); end
  def coverage_criterion_supported?(criterion); end
  def coverage_dir(dir = T.unsafe(nil)); end
  def coverage_for_eval_enabled?; end
  def coverage_for_eval_supported?; end
  def coverage_path(path = T.unsafe(nil)); end
  def current_nocov_token(value = T.unsafe(nil)); end
  def disable_coverage(criterion); end
  def enable_coverage(*criteria); end
  def enable_coverage_for_eval; end
  def enable_for_subprocesses(value = T.unsafe(nil)); end
  def enabled_for_subprocesses?; end
  def expected_coverage(coverage = T.unsafe(nil)); end
  def filters; end
  def filters=(_arg0); end
  def finalize_merge(value = T.unsafe(nil)); end
  def finalize_merge?; end
  def formatter(formatter = T.unsafe(nil)); end
  def formatter=(_arg0); end
  def formatters(formatters = T.unsafe(nil)); end
  def formatters=(formatters); end
  def group(group_name, filter_argument = T.unsafe(nil), &_arg2); end
  def groups; end
  def groups=(_arg0); end
  def ignore_branches(*types); end
  def ignore_methods(*types); end
  def ignored_branch?(type); end
  def ignored_branches; end
  def ignored_method?(type); end
  def ignored_methods; end
  def maximum_coverage(coverage = T.unsafe(nil)); end
  def maximum_coverage_drop(coverage_drop = T.unsafe(nil)); end
  def merge_finalization_owner?; end
  def merge_subprocesses(value = T.unsafe(nil)); end
  def merge_timeout(seconds = T.unsafe(nil)); end
  def merging(use = T.unsafe(nil)); end
  def method_coverage?; end
  def method_coverage_supported?; end
  def minimum_coverage(coverage = T.unsafe(nil)); end
  def minimum_coverage_by_file(coverage = T.unsafe(nil)); end
  def minimum_coverage_by_file_overrides; end
  def minimum_coverage_by_group(coverage = T.unsafe(nil)); end
  def no_default_skips; end
  def nocov_token(nocov_token = T.unsafe(nil)); end
  def parallel_tests(value = T.unsafe(nil)); end
  def parallel_wait_timeout(seconds = T.unsafe(nil)); end
  def primary_coverage(criterion = T.unsafe(nil)); end
  def print_error_status; end
  def print_error_status=(_arg0); end
  def print_errors(value = T.unsafe(nil)); end
  def profiles; end
  def project_name(new_name = T.unsafe(nil)); end
  def raise_on_invalid_coverage(coverage, coverage_setting); end
  def refuse_coverage_drop(*criteria); end
  def remove_filter(filter_argument); end
  def root(root = T.unsafe(nil)); end
  def skip(filter_argument = T.unsafe(nil), &_arg1); end
  def skip_token(nocov_token = T.unsafe(nil)); end
  def source_in_json(value = T.unsafe(nil)); end
  def track_files(glob); end
  def track_files_replacement_hint(glob); end
  def tracked_files; end
  def use_merging(use = T.unsafe(nil)); end
  def validate_coverage_criteria!; end

  private

  def apply_threshold_options(configurator, options); end
  def build_cover_filter(arg); end
  def collect_cover_globs(filter_list); end
  def default_primary_coverage; end
  def enable_coverage_criterion(criterion, enabled:, oneshot:); end
  def enable_eval_coverage; end
  def enable_eval_coverage_criterion; end
  def enable_oneshot_line(criterion); end
  def explicit_coverage_destination?; end
  def explicit_custom_coverage_destination?; end
  def inferred_finalize_merge?; end
  def inferred_finalize_merge_warning; end
  def minimum_possible_coverage_exceeded(coverage_option); end
  def parallel_worker_environment?; end
  def parse_filter(filter_argument = T.unsafe(nil), &filter_proc); end
  def partition_per_file_thresholds(coverage); end
  def per_file_coverage_replacement(defaults, overrides); end
  def per_group_coverage_replacement(coverage); end
  def raise_if_branch_type_unsupported(type); end
  def raise_if_criterion_disabled(criterion); end
  def raise_if_criterion_unsupported(criterion); end
  def raise_if_method_type_unsupported(type); end
  def render_coverage_blocks(by_criterion); end
  def restore_ivars(block_context, saved); end
  def store_minimum_per_file(criterion, percent, target); end
  def store_minimum_per_group(criterion, percent, group_name); end
  def store_overall_threshold(setting, criterion, percent); end
  def swap_ivars_from(block_context); end
  def validate_per_file_key(key); end
  def warn_about_inferred_finalize_merge; end
end

SimpleCov::Configuration::COVERAGE_THRESHOLD_OPTIONS = T.let(T.unsafe(nil), Array)

class SimpleCov::Configuration::CoverageCriterion
  def initialize(config, criterion); end

  def exact(percent); end
  def maximum(percent); end
  def maximum_drop(percent); end
  def minimum(percent); end
  def minimum_per_file(percent, only: T.unsafe(nil)); end
  def minimum_per_group(percent, only:); end
  def primary; end
end

SimpleCov::Configuration::DEFAULT_COVERAGE_CRITERION = T.let(T.unsafe(nil), Symbol)
SimpleCov::Configuration::IGNORABLE_BRANCH_TYPES = T.let(T.unsafe(nil), Array)
SimpleCov::Configuration::IGNORABLE_METHOD_TYPES = T.let(T.unsafe(nil), Array)
SimpleCov::Configuration::ONESHOT_LINE_COVERAGE_CRITERION = T.let(T.unsafe(nil), Symbol)
SimpleCov::Configuration::SUPPORTED_COVERAGE_CRITERIA = T.let(T.unsafe(nil), Array)
class SimpleCov::ConfigurationError < ::StandardError; end

class SimpleCov::CoverageStatistics
  def initialize(covered:, missed:, omitted: T.unsafe(nil), total_strength: T.unsafe(nil), percent: T.unsafe(nil)); end

  def covered; end
  def missed; end
  def omitted; end
  def percent; end
  def strength; end
  def total; end

  private

  def compute_percent(covered, missed, total); end
  def compute_strength(total_strength, total); end

  class << self
    def from(coverage_statistics); end
  end
end

SimpleCov::CoverageStatistics::ZERO_STATS = T.let(T.unsafe(nil), Array)

module SimpleCov::CoverageViolations
  class << self
    def maximum_drop(result, thresholds, last_run: T.unsafe(nil)); end
    def maximum_overall(result, thresholds); end
    def minimum_by_file(result, defaults, overrides = T.unsafe(nil)); end
    def minimum_by_group(result, thresholds); end
    def minimum_overall(result, thresholds); end

    private

    def compute_drop(criterion, result, last_run); end
    def effective_per_file_thresholds(file, defaults, overrides); end
    def file_minimum_violation(file, criterion, expected); end
    def group_minimum_violations(group_name, group, minimums); end
    def lookup_group(result, group_name); end
    def path_matches?(project_filename, pattern); end
    def percent_for(stats_source, criterion); end
    def round(percent); end
  end
end

module SimpleCov::Deprecation
  private

  def emitted; end
  def reset!; end
  def warn(message, location: T.unsafe(nil)); end

  class << self
    def emitted; end
    def reset!; end
    def warn(message, location: T.unsafe(nil)); end
  end
end

class SimpleCov::Directive
  def initialize(line_number:, mode:, categories:, inline:); end

  def apply(ranges, open_starts); end
  def categories; end
  def disabled?; end
  def inline?; end
  def line_number; end
  def mode; end

  class << self
    def disabled_ranges(src_lines); end

    private

    def comments_in(lines); end
    def directives_in(lines); end
    def inline?(lines, line_number, column); end
    def parse_categories(text); end
    def parse_comment(lines, line_number, column, text); end
    def source_might_contain_directive?(lines); end
  end
end

SimpleCov::Directive::CATEGORIES = T.let(T.unsafe(nil), Array)
SimpleCov::Directive::CATEGORIES_PATTERN = T.let(T.unsafe(nil), String)
SimpleCov::Directive::CATEGORY_PATTERN = T.let(T.unsafe(nil), String)
SimpleCov::Directive::PATTERN = T.let(T.unsafe(nil), Regexp)

module SimpleCov::ExitCodes
  class << self
    def print_error(message); end
  end
end

SimpleCov::ExitCodes::EXCEPTION = T.let(T.unsafe(nil), Integer)

module SimpleCov::ExitCodes::ExitCodeHandling
  private

  def call(result, coverage_limits:); end
  def coverage_checks(result, coverage_limits); end

  class << self
    def call(result, coverage_limits:); end
    def coverage_checks(result, coverage_limits); end
  end
end

SimpleCov::ExitCodes::MAXIMUM_COVERAGE = T.let(T.unsafe(nil), Integer)
SimpleCov::ExitCodes::MAXIMUM_COVERAGE_DROP = T.let(T.unsafe(nil), Integer)
SimpleCov::ExitCodes::MINIMUM_COVERAGE = T.let(T.unsafe(nil), Integer)

class SimpleCov::ExitCodes::MaximumCoverageDropCheck
  def initialize(result, maximum_coverage_drop); end

  def exit_code; end
  def failing?; end
  def report; end

  private

  def message_for(violation); end
  def violations; end
end

class SimpleCov::ExitCodes::MaximumOverallCoverageCheck
  def initialize(result, maximum_coverage); end

  def exit_code; end
  def failing?; end
  def report; end

  private

  def report_violation(violation); end
  def violations; end
end

class SimpleCov::ExitCodes::MinimumCoverageByFileCheck
  def initialize(result, minimum_coverage_by_file, overrides = T.unsafe(nil)); end

  def exit_code; end
  def failing?; end
  def report; end

  private

  def violations; end
end

class SimpleCov::ExitCodes::MinimumCoverageByGroupCheck
  def initialize(result, minimum_coverage_by_group); end

  def exit_code; end
  def failing?; end
  def report; end

  private

  def violations; end
end

class SimpleCov::ExitCodes::MinimumOverallCoverageCheck
  def initialize(result, minimum_coverage); end

  def exit_code; end
  def failing?; end
  def report; end

  private

  def report_violation(violation); end
  def report_worst_files(criterion); end
  def violations; end
  def worst_files_for(criterion); end
end

SimpleCov::ExitCodes::MinimumOverallCoverageCheck::WORST_FILES_LIMIT = T.let(T.unsafe(nil), Integer)
SimpleCov::ExitCodes::SUCCESS = T.let(T.unsafe(nil), Integer)

class SimpleCov::FileList
  include ::Enumerable
  extend ::Forwardable

  def initialize(files); end

  def branch_covered_percent; end
  def count(*_arg0, **_arg1, &_arg2); end
  def coverage_statistics(criterion = T.unsafe(nil)); end
  def coverage_statistics_by_file; end
  def covered_branches; end
  def covered_lines; end
  def covered_methods; end
  def covered_percent(criterion = T.unsafe(nil)); end
  def covered_percentages; end
  def covered_strength(criterion = T.unsafe(nil)); end
  def each(*_arg0, **_arg1, &_arg2); end
  def empty?(*_arg0, **_arg1, &_arg2); end
  def least_covered_file; end
  def length(*_arg0, **_arg1, &_arg2); end
  def lines_of_code; end
  def map(*_arg0, **_arg1, &_arg2); end
  def method_covered_percent; end
  def missed_branches; end
  def missed_lines; end
  def missed_methods; end
  def never_lines; end
  def size(*_arg0, **_arg1, &_arg2); end
  def skipped_lines; end
  def to_a(*_arg0, **_arg1, &_arg2); end
  def to_ary(*_arg0, **_arg1, &_arg2); end
  def total_branches; end
  def total_methods; end

  private

  def compute_coverage_statistics; end
  def compute_coverage_statistics_by_file; end
  def enabled_criteria_for_reporting; end
end

class SimpleCov::Filter
  def initialize(filter_argument); end

  def filter_argument; end
  def matches?(_source_file); end

  class << self
    def build_filter(filter_argument); end
    def class_for_argument(filter_argument); end

    private

    def filter_classes_by_argument_type; end
  end
end

module SimpleCov::Formatter
  class << self
    def instance_for(formatter); end
  end
end

class SimpleCov::Formatter::Base
  def initialize(silent: T.unsafe(nil), output_dir: T.unsafe(nil)); end

  private

  def displayable_output_path; end
  def entry_point_filename; end
  def message_prefix; end
  def output_message(result); end
  def output_path; end
  def relative_or_absolute_output_path; end
  def stats_line(criterion, stat); end
end

class SimpleCov::Formatter::HTMLFormatter < ::SimpleCov::Formatter::Base
  def format(result); end
  def format_from_json(json_path, output_dir); end

  private

  def atomic_write(dest, content); end
  def copy_static_assets(dest_dir = T.unsafe(nil)); end
  def entry_point_filename; end
  def public_dir; end
end

SimpleCov::Formatter::HTMLFormatter::DATA_FILENAME = T.let(T.unsafe(nil), String)

class SimpleCov::Formatter::JSONFormatter < ::SimpleCov::Formatter::Base
  def format(result); end

  private

  def entry_point_filename; end
  def existing_meta(path); end
  def message_prefix; end
  def warn_if_concurrent_overwrite(path, result); end

  class << self
    def build_hash(result, include_source: T.unsafe(nil)); end
  end
end

class SimpleCov::Formatter::JSONFormatter::ErrorsFormatter
  def initialize(result); end

  def call; end

  private

  def bucket(name); end
  def expected_actual(violation); end
  def format_maximum_drop; end
  def format_maximum_overall; end
  def format_minimum_by_file; end
  def format_minimum_by_group; end
  def format_minimum_overall; end
  def key_for(violation); end
  def record_by_file(violation); end
end

SimpleCov::Formatter::JSONFormatter::ErrorsFormatter::CRITERION_KEYS = T.let(T.unsafe(nil), Hash)
SimpleCov::Formatter::JSONFormatter::FILENAME = T.let(T.unsafe(nil), String)

class SimpleCov::Formatter::JSONFormatter::ResultHashFormatter
  def initialize(result, include_source: T.unsafe(nil)); end

  def format; end

  private

  def coverage_flags; end
  def format_coverage_statistics(statistics); end
  def format_files; end
  def format_groups; end
  def format_line_statistic(stat); end
  def format_meta; end
  def format_single_statistic(stat); end
  def git_commit; end
  def line_coverage_enabled?; end
end

SimpleCov::Formatter::JSONFormatter::ResultHashFormatter::SCHEMA_URL = T.let(T.unsafe(nil), String)
SimpleCov::Formatter::JSONFormatter::ResultHashFormatter::SCHEMA_VERSION = T.let(T.unsafe(nil), String)

class SimpleCov::Formatter::JSONFormatter::SourceFileFormatter
  def initialize(source_file, include_source: T.unsafe(nil)); end

  def call; end

  private

  def branch_coverage_section; end
  def ensure_utf8(str); end
  def format_branch(branch); end
  def format_line(line); end
  def format_method(method); end
  def format_source_code; end
  def line_coverage_enabled?; end
  def line_coverage_section; end
  def method_coverage_section; end
end

class SimpleCov::Formatter::MultiFormatter
  class << self
    def new(formatters = T.unsafe(nil)); end
  end
end

module SimpleCov::Formatter::MultiFormatter::InstanceMethods
  def format(result); end
end

class SimpleCov::Formatter::SimpleFormatter
  def format(result); end

  private

  def format_group(name, files); end
end

class SimpleCov::GlobFilter < ::SimpleCov::Filter
  def matches?(source_file); end
end

module SimpleCov::LastRun
  class << self
    def last_run_path; end
    def read; end
    def write(json); end
  end
end

class SimpleCov::LinesClassifier
  def classify(lines); end

  private

  def directive_disabled_line_set(lines); end
  def not_relevant_line?(line, line_number, skipping, directive_disabled); end

  class << self
    def no_cov_line; end
    def no_cov_line?(line); end
    def whitespace_line?(line); end
  end
end

SimpleCov::LinesClassifier::COMMENT_LINE = T.let(T.unsafe(nil), Regexp)
SimpleCov::LinesClassifier::NOT_RELEVANT = T.let(T.unsafe(nil), T.untyped)
SimpleCov::LinesClassifier::RELEVANT = T.let(T.unsafe(nil), Integer)
SimpleCov::LinesClassifier::WHITESPACE_LINE = T.let(T.unsafe(nil), Regexp)
SimpleCov::LinesClassifier::WHITESPACE_OR_COMMENT_LINE = T.let(T.unsafe(nil), Regexp)

module SimpleCov::ParallelAdapters
  private

  def adapters; end
  def current; end
  def register(adapter); end
  def reset_current!; end

  class << self
    def adapters; end
    def current; end
    def register(adapter); end
    def reset_current!; end
  end
end

class SimpleCov::ParallelAdapters::Base
  class << self
    def active?; end
    def expected_worker_count; end
    def first_worker?; end
    def native_wait?; end
    def wait_for_siblings; end
  end
end

class SimpleCov::ParallelAdapters::GenericAdapter < ::SimpleCov::ParallelAdapters::Base
  class << self
    def active?; end
    def expected_worker_count; end
    def first_worker?; end
  end
end

class SimpleCov::ParallelAdapters::ParallelTestsAdapter < ::SimpleCov::ParallelAdapters::Base
  class << self
    def active?; end
    def ensure_loaded; end
    def env_suggests_parallel_tests?; end
    def expected_worker_count; end
    def first_worker?; end
    def native_parallel_tests_environment?; end
    def native_wait?; end
    def wait_for_siblings; end
  end
end

class SimpleCov::Profiles < ::Hash
  def define(name, &blk); end
  def fetch_proc(name); end
  def load(name); end

  private

  def autoload_profile(name); end
end

class SimpleCov::RegexFilter < ::SimpleCov::Filter
  def matches?(source_file); end
end

class SimpleCov::Result
  extend ::Forwardable

  def initialize(original_result, command_name: T.unsafe(nil), created_at: T.unsafe(nil), not_loaded_files: T.unsafe(nil), report: T.unsafe(nil), filter_config: T.unsafe(nil)); end

  def command_name; end
  def command_name=(_arg0); end
  def coverage_for(path); end
  def coverage_statistics(*_arg0, **_arg1, &_arg2); end
  def coverage_statistics_by_file(*_arg0, **_arg1, &_arg2); end
  def covered_branches(*_arg0, **_arg1, &_arg2); end
  def covered_lines(*_arg0, **_arg1, &_arg2); end
  def covered_methods(*_arg0, **_arg1, &_arg2); end
  def covered_percent(*_arg0, **_arg1, &_arg2); end
  def covered_percentages(*_arg0, **_arg1, &_arg2); end
  def covered_strength(*_arg0, **_arg1, &_arg2); end
  def created_at; end
  def created_at=(_arg0); end
  def filenames; end
  def files; end
  def format!; end
  def groups; end
  def least_covered_file(*_arg0, **_arg1, &_arg2); end
  def missed_branches(*_arg0, **_arg1, &_arg2); end
  def missed_lines(*_arg0, **_arg1, &_arg2); end
  def missed_methods(*_arg0, **_arg1, &_arg2); end
  def original_result; end
  def source_file_for(path); end
  def source_files; end
  def to_hash; end
  def total_branches(*_arg0, **_arg1, &_arg2); end
  def total_lines(*_arg0, **_arg1, &_arg2); end
  def total_methods(*_arg0, **_arg1, &_arg2); end

  private

  def apply_cover_filters!(cover_filters); end
  def apply_filters!(filters); end
  def coverage; end
  def warn_about_missing_source_files(missing, input_size); end

  class << self
    def from_hash(hash); end
  end
end

class SimpleCov::Result::FilterConfig
  def initialize(filters: T.unsafe(nil), cover_filters: T.unsafe(nil), groups: T.unsafe(nil)); end

  def cover_filters; end
  def filters; end
  def groups; end
end

class SimpleCov::Result::MissingSourceFilesReporter
  def initialize(missing_paths, input_size:, every_entry_dropped:); end

  def message; end
  def warn!; end

  private

  def all_missing_warning; end
  def partial_missing_warning; end
  def summary; end
end

class SimpleCov::Result::SourceFileBuilder
  def initialize(original_result, not_loaded_files:); end

  def call; end
  def missing_source_files; end

  private

  def build_source_file(filename, coverage); end
  def stringify_outer_keys(coverage); end
end

class SimpleCov::ResultAdapter
  def initialize(result); end

  def adapt; end
  def result; end

  private

  def adapt_one(file_name, cover_statistic); end
  def adapt_oneshot_lines_if_needed(file_name, cover_statistic); end
  def aggregate_duplicated_branches(cover_statistic); end
  def build_line_stub(file_name, oneshot_lines); end
  def class_display_name(klass); end
  def normalize_method_key(key); end
  def normalize_method_keys(cover_statistic); end
  def singleton_wrapper_name(klass); end

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

SimpleCov::ResultAdapter::ADDRESS_PATTERN = T.let(T.unsafe(nil), Regexp)
SimpleCov::ResultAdapter::ADDRESS_PLACEHOLDER = T.let(T.unsafe(nil), String)
SimpleCov::ResultAdapter::SINGLETON_WRAPPER_PATTERN = T.let(T.unsafe(nil), Regexp)

module SimpleCov::ResultMerger
  class << self
    def concurrent_runner_entry?(entry); end
    def create_result(command_names, coverage); end
    def drop_expired_results(results); end
    def merge_and_store(*file_paths, ignore_timeout: T.unsafe(nil)); end
    def merge_coverage(*results); end
    def merge_results(*file_paths, ignore_timeout: T.unsafe(nil)); end
    def merge_valid_results(results, ignore_timeout: T.unsafe(nil)); end
    def merged_entry(existing, incoming); end
    def merged_result; end
    def read_resultset; end
    def resultset_path; end
    def store_result(result); end
    def synchronize_resultset(&_arg0); end
    def valid_results(file_path, ignore_timeout: T.unsafe(nil)); end
    def warn_about_expired_results(expired_command_names); end
    def within_merge_timeout?(data); end
  end
end

module SimpleCov::ResultMerger::LegacyFormatAdapter
  private

  def call(result); end
  def pre_0_18?(result); end
  def upgrade(result); end

  class << self
    def call(result); end
    def pre_0_18?(result); end
    def upgrade(result); end
  end
end

module SimpleCov::ResultMerger::ResultsetFile
  private

  def decode(content); end
  def parse(path); end
  def read(path); end

  class << self
    def decode(content); end
    def parse(path); end
    def read(path); end
  end
end

module SimpleCov::ResultMerger::ResultsetStore
  private

  def resultset_path; end
  def synchronize(&_arg0); end
  def with_flock; end
  def write(resultset); end
  def writelock_path; end

  class << self
    def resultset_path; end
    def synchronize(&_arg0); end
    def with_flock; end
    def write(resultset); end
    def writelock_path; end
  end
end

module SimpleCov::SimulateCoverage
  private

  def call(absolute_path); end
  def coverage_stub(path, source_lines); end
  def read_lines(path); end

  class << self
    def call(absolute_path); end
    def coverage_stub(path, source_lines); end
    def read_lines(path); end
  end
end

class SimpleCov::SourceFile
  include ::SimpleCov::SourceFile::BuilderContext

  def initialize(filename, coverage_data, loaded: T.unsafe(nil)); end

  def branches; end
  def branches_coverage_percent; end
  def branches_for_line(line_number); end
  def branches_report; end
  def coverage_data; end
  def coverage_statistics(criterion = T.unsafe(nil)); end
  def covered_branches; end
  def covered_lines; end
  def covered_methods; end
  def covered_percent(criterion = T.unsafe(nil)); end
  def covered_strength(criterion = T.unsafe(nil)); end
  def filename; end
  def line(number); end
  def line_with_missed_branch?(line_number); end
  def lines; end
  def lines_of_code; end
  def methods; end
  def methods_coverage_percent; end
  def missed_branches; end
  def missed_lines; end
  def missed_methods; end
  def never_lines; end
  def no_branches?; end
  def no_lines?; end
  def not_loaded?; end
  def project_filename; end
  def relevant_lines; end
  def skipped_lines; end
  def source; end
  def source_lines; end
  def src; end
  def total_branches; end
end

class SimpleCov::SourceFile::Branch
  def initialize(start_line:, end_line:, coverage:, inline:, type:); end

  def coverage; end
  def covered?; end
  def end_line; end
  def inline?; end
  def missed?; end
  def overlaps_with?(line_range); end
  def report; end
  def report_line; end
  def skipped!; end
  def skipped?; end
  def start_line; end
  def type; end
end

class SimpleCov::SourceFile::BranchBuilder
  def initialize(source_file); end

  def call; end

  private

  def build_branch(branch_data, hit_count, condition_range); end
  def build_branches_from(condition, branches); end
  def eval_generated_condition_to_ignore?(condition); end
  def implicit_else_to_ignore?(type, branch_range, condition_range); end
  def process_skipped(branches); end
end

module SimpleCov::SourceFile::BuilderContext
  def real_source_positions; end
  def skip_chunks_for(criterion); end
end

class SimpleCov::SourceFile::Line
  def initialize(src, line_number, coverage); end

  def coverage; end
  def covered?; end
  def line; end
  def line_number; end
  def missed?; end
  def never?; end
  def number; end
  def skipped; end
  def skipped!; end
  def skipped?; end
  def source; end
  def src; end
  def status; end
end

class SimpleCov::SourceFile::LineBuilder
  def initialize(source_file); end

  def call; end

  private

  def build_lines; end
  def mark_skipped(lines, chunks); end
end

class SimpleCov::SourceFile::Method
  def initialize(source_file, info, coverage); end

  def class_name; end
  def coverage; end
  def covered?; end
  def end_col; end
  def end_line; end
  def lines; end
  def method_name; end
  def missed?; end
  def overlaps_with?(line_range); end
  def skipped!; end
  def skipped?; end
  def source_file; end
  def start_col; end
  def start_line; end
  def to_s; end
end

class SimpleCov::SourceFile::MethodBuilder
  def initialize(source_file); end

  def call; end

  private

  def eval_generated_to_ignore?(info); end
  def process_skipped(methods); end
end

module SimpleCov::SourceFile::RubyDataParser
  private

  def call(structure); end
  def parse_array_string(str); end
  def parse_cache; end
  def parse_element(node); end
  def parse_integer_node(node); end
  def parse_symbol_node(node); end
  def quote_inspected_class_segments(str); end
  def string_literal_text(string_content); end
  def unescape_ruby(raw); end

  class << self
    def call(structure); end
    def parse_array_string(str); end
    def parse_cache; end
    def parse_element(node); end
    def parse_integer_node(node); end
    def parse_symbol_node(node); end
    def quote_inspected_class_segments(str); end
    def string_literal_text(string_content); end
    def unescape_ruby(raw); end
  end
end

class SimpleCov::SourceFile::SkipChunks
  def initialize(filename, src); end

  def directive_chunks; end
  def for(criterion); end
  def nocov_chunks; end

  private

  def build_nocov_chunks; end
  def warn_nocov_deprecation(first_line_number); end

  class << self
    def nocov_warned; end
  end
end

module SimpleCov::SourceFile::SourceLoader
  private

  def call(filename); end
  def ensure_remove_undefs(file_lines); end
  def read_lines(file, lines, current_line); end
  def set_encoding_based_on_magic_comment(file, line); end
  def shebang?(line); end

  class << self
    def call(filename); end
    def ensure_remove_undefs(file_lines); end
    def read_lines(file, lines, current_line); end
    def set_encoding_based_on_magic_comment(file, line); end
    def shebang?(line); end
  end
end

SimpleCov::SourceFile::SourceLoader::RUBY_FILE_ENCODING_MAGIC_COMMENT_REGEX = T.let(T.unsafe(nil), Regexp)
SimpleCov::SourceFile::SourceLoader::SHEBANG_REGEX = T.let(T.unsafe(nil), Regexp)

class SimpleCov::SourceFile::Statistics
  def initialize(source_file); end

  def call; end

  private

  def branch_statistics; end
  def line_statistics; end
  def method_statistics; end
end

module SimpleCov::StaticCoverageExtractor
  private

  def available?; end
  def call(source); end
  def real_source_positions(source); end

  class << self
    def available?; end
    def call(source); end
    def real_source_positions(source); end
  end
end

module SimpleCov::StaticCoverageExtractor::ConditionFolding
  private

  def static_condition?(node); end
  def unwrap_parentheses(node); end
end

SimpleCov::StaticCoverageExtractor::ConditionFolding::STATIC_CONDITION_TYPES = T.let(T.unsafe(nil), Array)
SimpleCov::StaticCoverageExtractor::ELSE_CLAUSE_METHOD = T.let(T.unsafe(nil), Symbol)
SimpleCov::StaticCoverageExtractor::IF_NODE_SUBSEQUENT_METHOD = T.let(T.unsafe(nil), Symbol)

module SimpleCov::StaticCoverageExtractor::LocationConventions
  private

  def begin_modifier_loop?(node); end
  def case_arm_location(case_node, when_node, when_type); end
  def else_arm_location(node); end
  def elsif_node?(node); end
  def empty_arm_collapses?(node, type); end
  def empty_else_location(node, sub, type); end
  def following_case_content(case_node, when_node); end
  def if_like_else_location(node, type); end
  def if_like_location(node, type); end
  def if_like_subsequent(node); end
  def if_like_then_location(node, type); end
  def legacy_case_tail_end(case_node, when_node); end
  def legacy_content_end(node); end
  def legacy_do_while_body_location(node); end
  def legacy_when_value_location(case_node, when_node); end
  def loop_body_location(node); end
  def point_at_end(location); end
  def safe_navigation_location(node); end
  def value_position?(node); end
end

SimpleCov::StaticCoverageExtractor::LocationConventions::LEGACY_COVERAGE_LOCATIONS = T.let(T.unsafe(nil), FalseClass)

class SimpleCov::StaticCoverageExtractor::LocationConventions::PointLocation < ::Data
  def end_column; end
  def end_line; end
  def start_column; end
  def start_line; end

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

module SimpleCov::StaticCoverageExtractor::MethodCollector
  def visit_class_node(node); end
  def visit_def_node(node); end
  def visit_module_node(node); end

  private

  def constant_name(node); end
  def with_class(name); end
end

module SimpleCov::StaticCoverageExtractor::ValuePositions
  private

  def call(root); end
  def else_clause(node); end
  def mark(node, in_value, positions); end
  def subsequent(node); end
  def tail_children(node, in_value); end

  class << self
    def call(root); end
    def else_clause(node); end
    def mark(node, in_value, positions); end
    def subsequent(node); end
    def tail_children(node, in_value); end
  end
end

class SimpleCov::StaticCoverageExtractor::Visitor < ::Prism::Visitor
  include ::SimpleCov::StaticCoverageExtractor::MethodCollector
  include ::SimpleCov::StaticCoverageExtractor::LocationConventions
  include ::SimpleCov::StaticCoverageExtractor::ConditionFolding

  def initialize; end

  def branches; end
  def methods; end
  def visit_call_node(node); end
  def visit_case_match_node(node); end
  def visit_case_node(node); end
  def visit_if_node(node); end
  def visit_match_predicate_node(node); end
  def visit_match_required_node(node); end
  def visit_program_node(node); end
  def visit_unless_node(node); end
  def visit_until_node(node); end
  def visit_while_node(node); end

  private

  def build_tuple(type, location); end
  def emit_case_like(node, when_type); end
  def emit_if_like(node, type); end
  def emit_loop(node, type); end
  def emit_oneline_pattern(node, else_location); end
  def emit_safe_navigation(node); end
end

class SimpleCov::StringFilter < ::SimpleCov::Filter
  def matches?(source_file); end

  private

  def compute_segment_pattern; end
  def segment_pattern; end
end

module SimpleCov::UselessResultsRemover
  class << self
    def call(coverage_result); end
    def root_regex; end
    def root_regx; end
  end
end

SimpleCov::VERSION = T.let(T.unsafe(nil), String)
